O programador pragmático

O programador pragmático from edgarddavidson.com

Herança

     Herança é um princípio de orientação a objetos, que permite que classes compartilhem atributos e métodos, através de "heranças". Ela é usada na intenção de reaproveitar código ou comportamento generalizado ou especializar operações ou atributos. O conceito de herança de várias classes é conhecido como herança múltipla.(Fonte Wikipédia).

    Neste exemplo iremos implementar uma classe pai(Veiculo) e duas classes filhas(Passeio e Transporte) e uma quarta que será a que vai executar nossa implementação.

Então temos:

01) Veiculo.java

02) Passeio.java

03) Transporte.java

04) UsandoVeiculo.java

     Aqui na primeira classe Veiculo.java, adicionamos atributos que são de todos os tipos de veículo, como placa, cor e ano de fabricação.

    Também iremos implementar um método para imprimir o relatório e um outro que traduz um valor booleano em uma string('Sim' e 'Não') para que o usuário possa entender o que esta sendo retornado.

     Implementação da classe pai:

/**

 * @author marco.bidoia@gmail.com

 *

 */

public class Veiculo {

      String placa;

      String cor;

      int ano;

     

      public void Relatorio(){

            System.out.println("Placa: " + placa);

            System.out.println("Cor: " + cor);

            System.out.println("Ano: " + ano);

      }

     

      public String getBooleanToStr(boolean valorBooleano){

            if (valorBooleano){

                  return "Sim";

            }else{

                  return "Não";               

            }

           

      }

}

     Agora vamos implementar a classe filha que herdara todos os atributos e métodos da classe Pai.

    Observe que na primeira linha do método de Relatório usamos a seguinte linha "super.Relatorio();" para garantirmos que o que foi implementado na classe pais seja impresso antes do que tem na classe filha.

/**

 * @author marco.bidoia@gmail.com

 *

 */

public class Passeio extends Veiculo {

      int numPortas;

      boolean direcaohidraulica;

     

      public void Relatorio(){

            super.Relatorio();

            System.out.println("Número de portas: " + numPortas);

            System.out.println("Direção hidraulica: " + getBooleanToStr(direcaohidraulica));

      }

}

     No método de Relatório anterior observe que para imprimir o valor booleano usamos um método chamado  "getBooleanToStr(boolean)" que ao passarmos um valor boolean nos retorna "Sim"(True) ou "não"(False)  para que o resultado fique legível aos usuários.

     Aqui temos mais uma classe que herdou da mesma classe pai, mais que tem os atributos diferentes da outra classe filha. Mas também compartilha os atributos da classe pai e no método de relatório também utiliza o "super.Relatorio();" para imprimir os atributos da classe pai.

/**

 * @author marco.bidoia@gmail.com

 *

 */

public class Transporte extends Veiculo{

      int capacidade;

      String tipo;

     

      public void Relatorio(){

            super.Relatorio();

            System.out.println("Capacidade: " + capacidade);

            System.out.println("Tipo: " + tipo);

      }

     

}

     Agora vamos implementar a classe que vai consumir as duas classe filhas anteriores, e por herança a classe pai também. Observe que criamos dois objetos diferentes e alimentamos cada um com os valores necessários.

     Após alimentar cada objeto chamamos o método que imprime os valores dos objetos.

/**

 * @author marco.bidoia@gmail.com

 *

 */

public class UsandoVeiculo {

     

      public static void main(String[] args){

           

            // Veículo de passeio

            Passeio Lancer = new Passeio();

            Lancer.ano = 2012;

            Lancer.cor = "Prata";

            Lancer.direcaohidraulica = true;

            Lancer.numPortas = 4;

            Lancer.placa = "ABC1234";

            Lancer.Relatorio();

           

            System.out.print("\n");

           

            // Veículo de transporte

            Transporte Onibus = new Transporte();

            Onibus.ano = 2010;

            Onibus.cor = "Verde";

            Onibus.tipo = "Urbano";

            Onibus.capacidade = 44;

            Onibus.placa = "QWE0987";

            Onibus.Relatorio();

           

      }

}

O resultado da nossa aplicação será este:

Placa: ABC1234

Cor: Prata

Ano: 2012

Número de portas: 4

Direção hidraulica: Sim

Placa: QWE0987

Cor: Verde

Ano: 2010

Capacidade: 44

Tipo: Urbano

Cast de Dados

Abaixo uma tabela com cast de tipos de dados.

Para:	byte	short	char	int	long	float	double
De:
byte	---	implícito	char	implícito	implícito	implícito	implícito
short	byte	---	char	implícito	implícito	implícito	implícito
char	byte	short	---	implícito	implícito	implícito	implícito
int	byte	short	char	---	implícito	implícito	implícito
long	byte	short	char	int	---	implícito	implícito
float	byte	short	char	int	long	---
double	byte	short	char	int	long	float	---

Espaços utilizado por cada tipo de dado

Aqui temos uma tabela com o espaço utilizado por alguns tipos de dados.

Tipo	Tamanho
boolean	1 bit
byte	1 byte
short	2 bytes
char	2 bytes
int	4 bytes
float	4 bytes
long	8 bytes
double	8 bytes

Usando While e if para obter a sequência de fibonacci

Abaixo um exemplo de uso de while e if, o objetivo é obtermos a sequência de Fibonacci que seja menor que 100.

/**

 * @author marco.bidoia@gmail.com

 */

public class Fibonacci {

      public static void main(String[] args) {

           

            int fibonacci = 0;

            int nmenos1 = 1;

            int nmenos2 = 0;

           

            while (true) {

            fibonacci = nmenos1 + nmenos2;

            if (fibonacci > 100) {

                  break;

            }

            nmenos2 = nmenos1;

            nmenos1 = fibonacci;

            System.out.println(fibonacci);

            }

      }

}

O resultado é o seguinte:

1

2

3

5

8

13

21

34

55

89

Continue & Break

   Neste exemplo vemos qual a aplicação do "continue;" neste caso vamos fazer um for de 0 até 20 e quando o valor do "i" for maior que 10 e menor que 15 ele interrompe o ciclo e segue para a próxima execução. Aqui vemos a diferença entre o "continue;" e o "break;".

   O " continue;" passa para a próxima execução do " for ", enquanto o "break;" interrompe a execução do mesmo.

Exemplo com continue

/**

 * @author marco.bidoia@gmail.com

 */

public class ForComContinue {

      public static void main(String[] args) {

           

            for (int i = 0; i <=20; i++){

                  if (i > 10 && i < 15){

                        continue;

                  }

                  System.out.print(i + "-");

            }

      }

}

Resultado da execução acima:

0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 15 - 16 - 17 - 18 - 19 - 20

  Vemos que a execução não nos trouxe os números 11, 12, 13, 14 que são maiores que 10 e menos que 15, o " continue;"  não interrompe a execução apenas passa para o próximo laço de execução do "for".

  O mesmo exemplo só que agora usamos o "break;" em vez do "continue;".

/**

 * @author marco.bidoia@gmail.com

 */

public class ForComBreak {

      public static void main(String[] args) {

           

            for (int i = 0; i <=20; i++){

                  if (i > 10 && i < 15){

                        break;

                  }

                  System.out.print(i + "-");

            }

      }

}

Resultado da execução acima:

0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10

  Neste caso vemos que quando ele encontrou um número que era maior que 10 e menor que 15 ele interrompe a execução imediatamente. 

  Com estes dois exemplos acima podemos ver a diferença entre o "continue;" e o "break;" que nos trouxeram resultados diferentes sendo utilizados em programas iguais.