Resumo SCJP - Parte I
Bom pessoal, como estou estudando para a SCJP e precisando de um grande incentivo para esta tarefa “árdua”, rsrsrs, vou colocando ao longos dos dias um resumo das matérias.
Logo, as explicações serão bastantes objetivas. Então vamos lá....
1 - Declaração e Controle de acesso
Em java os identificadores legais só podem começar com letras, $ ou ‘.’, qualquer coisa diferente disso, o código não é compilado. O uso de palavras reservadas também não poderá ser usado.
Convenção da Sun: Apenas uma forma organizada de desenvolvimento, nada obriga o desenvolvedor codificar do “seu jeito”. Mas para algumas outras provas de certificações o padrão da SUN é exigido.
Declaração de Interfaces:
IPessoaService – a primeira letra maiúscula, quando o nome é composto, a segunda letra (como no exemplo) também deve ser maiúscula. O mesmo serve para as Classes ( Pessoa.java )
Declaração de Métodos:
Os métodos, devem conter a primeira letra minúscula, e caso seja um nome composto, a primeira letra do segundo nome deverá ser maiúscula. (findById();)
É interessante que suas varíaveis de instância, tenham métodos de acesso também. Por exemplo:
Private Integer idade;
Public void setIdade(Integer idade) {
This.idade = idade;
}
Public Integer getIdade(){
Return this.idade;
}
Para os boleanos o devemos alterar o get por is, por exemplo:
Public Boolean isGravou(){...}
Classes
Uma class declarada como default pertence apenas ao pacote onde foi criada, não sendo possível classes de outros pacotes acessarem, mesmo que eles tenham um import.
Classes só podem ser default ou public.
Exemplo:
Package util
Class valida{}
Package service
Import util.makeAll
Class Pessoa extends valida{} Este código não compila.
Para que consigamos acessar a classe, basta alterar o seu modificador de acesso para public.
Classes Abstratas
Classes abstratas jamais podem ser declaradas como FINAL. Ou seja: Abstract Final, não pode andar juntos.
Quando uma classe é abstratada, não é necessário ter um método abstrato, mas se uma classe concreta tiver uma método abstrato, ela obrigatoriamente deve ser abstrata.
Não é possível instanciar classes abstratas, uma boa analogia a isso é que, não podemos criar nada que não é real, ou seja algo que é abstrato, não pode ser criado.
Pegadinhas que podem cair no exame.
package estudo.Carros;
public abstract class Aviao{
String nome = "Boing";
}
package estudo.Cliente
import estudo.Carros.Aviao;
public class Pass extends Aviao{
public static void main(String[] args) {
System.out.println(nome);
}
}
Este código não compila.....
A variável nome, não foi declarada como static, e estamos tentando acesso dentro de um método Static.
Moral da História: “coisas” static, devem ser acessadas dentro de outras “coisas” static..
Dessa forma..
class Rascunho{
String nome = "leandro";
}
class nada extends Rascunho{
public static void main(String[] args) {
System.out.println(nome); //aqui dá erro de compilação
}
private void nda() {
System.out.println(nome); //aqui funfa demais...
}
}
Outra pegadinha que devemos ter muita atenção é a seguinte:
package estudo.Carros;
public abstract class Aviao{
Static String nome = "Boing";
}
package estudo.Cliente
import estudo.Carros.Aviao;
public class Pass extends Aviao{
public static void main(String[] args) {
System.out.println(nome);
}
}
Não compila....
Agora alteramos o modificar de acesso para Static, mas não definimos ela como public, ou seja, não está visível em outro pacote.
Interfaces
Interfaces é apeanas o contrato realizado entre as classes e a interface. Um bom exemplo para isso seria o seguinte: Uma class Ferrari, ou seja, o carro Ferrari, será o único carro com efeitos especiais nos 10 carros que vou produzir.
interface efeitos{
void voa();
void andaNaAgua();
}
class Ferrari implements efeitos{
public void andaNaAgua() {}
public void voa() {}
}
Interfaces são 100% abstratas, e dessa forma não pode de maneira nenhuma ter de maneira nenhuma métodos FINAL. Mas pode ter variáveis, desde que sejam constantes.
· As constantes são public, static e final
· As interfaces sempres são public e abstract.
· Metodos que são implemetados da interfaces, DEVEM OBRIGATORIAMENTE, ser public, caso contrário um erro de compilação é exibido.
· Não podemos criar interfaces com acesso default, todas são implicitamente public
· Interfaces não são implementadas por outras, apenas as estende.
· Não podemos implementar um classe.
package A;
interface IEfeitos{
void voa();
void andaNaAgua();
}
package B;
class Ferrari implements efeitos{
public void andaNaAgua() {
}
public void voa() {
}
} //Não compila...
Colocamos o acesso como default e estamos tentando acessar de outro pacote.
Modificadores de acesso
Como o próprio nome já é sugestivo, os modificadores é que controlam o nível de acesso aos membros de uma class. Podem ser:
Public, private, default e protected. E uma classe só pode ser default ou public
Public = o mundo inteiro vê. Claro, quando estamos em outros demos de importá-los.
Private = Visível apenas dentro da mesma classe. O seu saldo bancário está marcado como private...hehe.....ou pelo menos deveria.
Protected e default = São muito parecidos.
O protected é facilmente acessado de fora do pacote, desde que tenha o import e for através de herança. Ou seja, você precisa de herdar a classe que contem o método para usá-lo.
O default você não tem acesso.
O importante a saber é:
- Variaveis marcadas como protected, não são herdadas em pacote diferentes, mas o métodos podem ser acessados.
- Variaveis locais, não podem receber nenhum modificador, a não ser o FINAL.
Bom pessoal, a primeira parte fica por aqui, em breve (espero que amanhã) já consigo finalizar o primeiro Tema.
Espero ter ajudado.....
Nenhum comentário:
Postar um comentário