Não vou alongar demais nos dizeres, hoje continuaremos até o fim do primeiro capitulo, onde estamos falando de Declaração e Controle de Acesso.
Seguindo de onde paramos no post anterior (Primeira Parte), hoje vamos falar de:
Métodos FINAIS:
Qualquer coisa que for declarado como FINAL, não poderá, em hipótese nenhuma ser alterado, sendo assim, podemos definir que vira uma constante. No caso métodos, eles não poderão ser subscritos nas subclasses.
class Veiculo {
public final void valor(){}
}
class Fusca extends Veiculo{
public final void valor(){}
}
Isso não compila
Métodos ABSTRACT:
Métodos com apenas as declarações, não tem nenhuma implementação.
Quem devem implementa-los?
è A primeira classe concreta que extends a classe abstrata desse métodos
Só devem existir em uma classe abstrata.
Eles são sobrecarregados?
è Não. Eles são subscritos.
Uma classe abstrata, é obrigada a ter métodos abstratos?
è Não, uma classe pode ter um ou nenhum método abstrato. Mas se classe tiver pelo menos 1 método abstrato, ele obrigatoriamente deverá ser abstrata.
Lembrete:
Jamais use:
ABSTRACT e FINAL
ABSTRACT E PRIVATE
Métodos Abstract não podem ser também STATIC;
Usar Abstract apenas para Classes e Métodos, nada de variáveis.
Métodos SYNCHRONIZED:
São mais usados com Threads, para sincronia de métodos e blocos de códigos.
Pode ser usado para métodos e variáveis.
Métodos NATIVOS:
Utilizados apenas para métodos. É um modificador de acesso.
Métodos STRICTFP:
Força pontos flutuantes no padrão IEEE 754. Utilizado em métodos e classes.
Agora vamos falar de mais um recurso do java que também é bastante interessante.
VARARGS:
Este recurso permite receber inúmeros valores via parametro de um tipo que foi declarado.
Ajuda a evitar a sobrecarga de métodos.
class Veiculo {
public void valor(int ... a){
}
}
Acima mostramos um exemplo simples do varargs.
Uma pegadinha que pode cair no exame é que os varargs, DEVEM SEMPRE vir por último na lista de parametros.
Alguns lembretes:
Argumento: Aquilo que é passado explicitamente: setX(10)
Paramentro: Quando é passado o tipo que pode receber: setX(int x)
Construtores:
Não tem nenhum tipo de retorno, e tem o mesmo nome da classe. São sempre chamados quando um objeto é construído.
Não podem ser STATIC, FINAL e nem ABSTRACT.
Pode receber o PROTECTED como modificador de acesso.
Algumas atenções que merecem destaque:
class Veiculo {
public Veiculo(String nome) {
}
}
class Fusca extends Veiculo{
aqui chama o super(), implicitamente,logo, isso não compila.
public static void main(String[] args) {
}
}
-------------
class Veiculo {
public Veiculo(String nome) {
}
}
class Fusca extends Veiculo{
acho que ficou pior ainda, constructor dentro de método.
public static void main(String[] args) {
Fusca(){
super("fusca");
}
}
}
-----------------
class Veiculo {
public Veiculo(String nome) {
}
}
class Fusca extends Veiculo{
Fusca(){
super("fusca"); //agora sim!!!!
}
public static void main(String[] args) {
}
VARIÁVEIS:
Primitivos: int, float,double, etc. Uma vez declarado o seu tipo, jamais poderá ser modificado.
VARIÁVEIS DE REFERENCIA:
São usadas para referir a um objeto, e seu tipo não pode ser modificado.
Devemos sempre lembrar que para se referir a um objeto, o teste de E-UM, deverá ser realizado.
class Veiculo {}
class Fusca extends Veiculo{}
Fusca É-UM Veiculo. Sendo assim, posso fazer o seguinte:
class Veiculo {}
class Fusca extends Veiculo{
Veiculo veiculo = new Fusca();
} //Minha variável de referencia veiculo É-UM objeto FUSCA do tipo VEICULO
VARIÁVEIS DE INSTANCIA:
Ficam localizadas dentro das classes e fora dos métodos.
VARIÁVEIS TRANSIENT:
São variáveis que são ignoradas na serialização do objeto.
METODOS E VARIAVEIS STATIC:
Quando se cria variaveis deste com esta configuração, elas são usadas independente de ter uma instancia dessa classe.
É interessante lembrar que um membro STATIC so pode acessar outro membro STATIC.
ENUMS:
Enums são um tipo especial de classes, onde seus membros são constantes .
Podem ser declarados fora ou dentro de classes.
Não podemos é criar enums dentro de métodos.
Enums são: STATIC E FINAL.
enum COR{
PRETO, AMARELO, AZUL
}
class Veiculo {}
class Fusca extends Veiculo{
Veiculo veiculo = new Fusca();
public static void main(String[] args) {
COR cor = COR.PRETO;
System.out.println(cor);
}
}
---------
class classEnum{
enum Tam {
M(10),P(20),G(30);
Tam(int a){
tam = a;
}
private int tam;
public int getTam() {
return tam;
}
}
public static void main(String[] args) {
Tam tam = Tam.G;
System.out.println(tam.getTam());//imprime 30
}
}
Bom, ficamos por aqui por hoje, em breve voltaremos com o proximo capitulo... FUNDAMENTOS.
Nenhum comentário:
Postar um comentário