CONVERSÃO DE VARIÁVEIS DE REFERENCIA:
class Game{
}
class TopGear extends Game{
}
public class Rascunho{
public static void main(String[] args) {
TopGear b = (TopGear) new Game();
}
}
Dessa forma, o código consegue ser compilado, mas lança um warning.
Outro motivo de compilar, é por estar todas na mesma árvore de herança, pois um TopGear não pode ser um Jogo!!!
Outra atenção que devemos ter é: o que deve ser convertido é o OBJETO não o TIPO DELE.
class Game{
}
class TopGear extends Game{
}
public class Rascunho{
public static void main(String[] args) {
Game game = new TopGear();
Game gm = (TopGear)game;
//compila porque game é um objeto do tipo TopGear
}
}
Se o tipo do objeto não fazer parte da arvore de herança NÃO É COMPILADO.
Quando tempo fazer algo impossível, uma conversão meio cabulosa, uma exceção é lançada:
TopGear game = new Game();
Outra erro de compilação:
class Pais{
public void pib(){
System.out.println("PIB");
}
}
class Brasil extends Pais{
public void populacao(){
System.out.println("populacao");
}
}
class MinasGerais extends Brasil{
public void comida(){
System.out.println("comida");
}
}
class BH{
public void bairro(){
System.out.println("Bairro");
}
}
class Localizacao extends BH{
public void local(){
System.out.println("local");
}
}
public class Rascunho{
public static void main(String[] args) {
BH bh = new Localizacao();
bh.local();
}
}
Aí não temos o metodo local() na classe BH. Por isso o código não é compilado, devemos converter para que nosso código seja compilado.
((Localizacao)bh).local();
Dessa forma, o nosso código compila.
INTERFACE
- É um contrato que fazemos, onde todos os métodos assinados na interface deverão ser implementados.
- Fornecer implementação concreta para todos os métodos abstratos;
- Seguir regras de sobrecarga;
- Manter assinatura e mesmo tipo de retorno.
Se a classe que tiver implementando uma interface for ABSTRATA, ela não tem obrigação de implementar nenhum método.
Uma classe pode implementar 2 ou mais interfaces.
O que não devemos esquecer:
- Uma interface jamais vai implementar outra.
- Uma interface jamais vai implementar uma classe.
- Interface não extends class
interface veiculo{
void velocidade();
}
interface fabricante{
void modelo();
}
class fusca implements veiculo, fabricante{
public void velocidade() {
}
public void modelo() {
}
}
Neste exemplo a classe fusca implementa as duas interfaces, tem que implementar os metodos das respectivas. Caso um deixe de ser implementado o codigo não é compilado.
Como falamos anteriormente, se a classe for abstrata ela não necessita implementar todos os métodos.
interface veiculo{
void velocidade();
}
interface fabricante{
void modelo();
}
abstract class fusca implements veiculo, fabricante{
public void velocidade() {
}
}
Uma observação que merece ser frisada é que, quando duas interfaces forem implementadas pela mesma classe, as interfaces definitivamente não poderá ter métodos com mesmo nome.
Interfaces não possuem construtores.
TIPOS DE RETORNO:
Void: não retorna nada
public void velocidade() {}
Retorno de Objetos: em um método que tenha um tipo de Objeto como retorno, ela pode retornar qualquer tipo (desde que esteja dentro da arvore de herança)
public Animal velocidade() {
return Cavalo();
}
// a classe deve extends a Animal
CONSTRUTORES:
Serve para inicializar o estado das variáveis de instância. Toda classe possui um (ou mais) construtores.
Construtores não possuem tipo de retorno.
Uma atenção que devemos tomar é: VOID é um tipo de retorno, e um construtor não deve ter um retorno.
abstract class fusca implements veiculo, fabricante{
public void velocidade() {
}
public fusca(){}
}
O código abaixo não compila, pois o construtor da superclasse necessita de um parametro.
class PaisFabricacao{
private String nomePais;
public PaisFabricacao(String nome) {
this.nomePais = nome;
}
}
abstract class fusca extends PaisFabricacao implements veiculo, fabricante{
public void velocidade() {
}
public fusca(){}
}
Como herdamos a classe PaisFabricacao, e o construtor dessa necessita de um parametro, devemos instacia-la passando um paramentro no construtor.
ESTÁTICOS – STATIC
Garante que haverá apenas uma referencia a determinada variável na memoria.
Satic, nos permite acessar diretamente, sem a necessitedade de instanciar o objeto.
class PaisFabricacao{
private String nomePais;
public static String fabricaoEmSerie = "FABRICACAO_EM_SERIE";
public PaisFabricacao() {
}
public PaisFabricacao(String nome) {
this.nomePais = nome;
}
}
abstract class fusca extends PaisFabricacao implements veiculo, fabricante{
public void velocidade() {
}
public fusca(){}
public static void main(String[] args) {
String emSerie = PaisFabricacao.fabricaoEmSerie;
//como é public e static, não nessecitamos de instanciar um objeto
}
}
O mesmo é aplicado para métodos.
COESÃO E ACOPLAMENTO.
COESÃO: Quando uma classe é bem definida e focada. Quando uma classe tem um único objetivo e função. Devemos sempre tentar com uma alta COESÃO.
class VendaCliente{
public void efetuaVenda(){}
public void calculaTotal(){}
}
ACOPLAMENTO:
Quando uma classe tem dependencia com outras. Devemos tentar ao máximo diminuir o acoplamento.
No exemplo abaixo, nada sei sobre o cliente, apenas consumo o seus serviços.
class Cliente{
void verificaCredito(){}
}
class VendaCliente{
private static Cliente cliente;
public void efetuaVenda(){}
public void calculaTotal(){}
public static void main(String[] args) {
cliente.verificaCredito();
}
}
Uma classe não deve saber quase nada da outra, assim garantimos um baixo acoplamento.
Bom, por hoje é só, no próximo resumo entraremos no terceito capitulo do livro da kathy Sierra.
Espero ter ajudado.....
