public abstract class Animal {

public abstract void fazerBarulho();

}

////

public class Cachorro extends Animal {

public void fazerBarulho() {
System.out.println("AuAu!");
}
}

////

public class Gato extends Animal {

public void fazerBarulho() {
System.out.println("Miau!");
}
}
O exemplo acima cria a classe Animal e duas classes derivadas de Animal. É importante
observar que nas classes derivadas temos a redefinição do método fazerBarulho(). Esta
redefinição é classificada como uma sobreposição (override) de métodos. O conceito de
sobreposição somente pode ser identificado e utilizado quando temos classes dispostas
em um relacionamento de herança.

1. package listasjavaejavafx.view;
2.
3. import listasjavaejavafx.model.Carro;
4. import javafx.scene.layout.HBox;
5. import javafx.scene.control.ListView;
6. import javafx.scene.layout.VBox;
7. import javafx.scene.control.Label;
8. import javafx.scene.layout.LayoutInfo;
9.
10./**
11. * @author Administrador
12. */
13.public class CarrosView {
14. //Aham, uma sequência de carros
15. public var carros: Carro[];
16.
17. //Um carro que será visto: Ele está amarrado ao item selecionado d
a lista!
18. //Observer o Casting do JavaFX, que elegante :-)
19. var carroAtual: Carro = bind listaCarros.selectedItem as Carro;
20.
21. //A lista com os carros para você escolher um e ver mais sobre
22. var listaCarros: ListView;
23. //Nossa caixa horizontal que terá a exibição do carro escolhido
24. var mostraCarroAtual: VBox;
25.
26. //Nosso construtor
27. init {
28. //A nossa lista terá seu comportamento determinado pela lista d
e carros
29. listaCarros = ListView {
30. //Vai exibir o nome do carro, pois o método toString do carro r
etorna
31. //o nome do mesmo
32. items: bind carros
33. layoutInfo: LayoutInfo{width: 200 height: 100}
34. }
35.
36. //O nosso mostra carro atual terá somente alguns labels que mo
straram
37. //os detalhes do carro
38. mostraCarroAtual = VBox{
39. spacing: 10;
40. //Se tivermos algum carro selecionado mostramos essa lista
41. visible: bind not (carroAtual == null);
42. content:[
43. Label{text: bind "Nome: {carroAtual.getNome()}" }
44. Label{text: bind "Cor: {carroAtual.getCor()}" }
45. Label{text: bind "Placa: {carroAtual.getPlaca()}" }
46. ]
47. }
48. }
49.
50. public function getCarrosView(): HBox {
51. HBox{
52. spacing: 20;
53. content: [listaCarros, mostraCarroAtual]
54. }
55. }
56.
57.}
1. package listasjavaejavafx;
2.
3. import javafx.stage.Stage;
4. import javafx.scene.Scene;
5. import listasjavaejavafx.view.CarrosView;
6. import listasjavaejavafx.control.CarroControl;
7. import javafx.scene.layout.HBox;
8. import javafx.scene.control.TextBox;
9. import javafx.scene.layout.VBox;
10.import javafx.scene.control.Label;
11.
12./**
13. * @author Administrador
14. */
15.//Olha, instanciamos como se fosse Java
16.var carroControl:CarroControl = new CarroControl();
17.//O for retorna uma lista em JavaFX. Todo bloco em JavaFX retorna alg
o :- )
18.var carros = for ( carro in carroControl.getCarros()) carro;
19.
20.//Nosso carro view; Por enquanto não há carros
21.var carrosView:CarrosView = CarrosView{
22. carros: carros;
23.};
24.
25.//O campo que o usuário entra com a busca
26.var txtBusca:TextBox;
27.//Vamos fazer uma busca nos carros, para isso usaremos essa barra h
orizontal com alguns controls
28.var barraBusca:HBox = HBox{
29. spacing: 10;
30. content:[
31. Label{
32. text: "Buscar:";
33. }
34. txtBusca = TextBox{ action: busca;}
35. ]
 36.}
37.
38.Stage {
39. title: "Nossos carros!"
40. scene: Scene {
41. width: 400
42. height: 200
43. content: [
44. VBox{
45. translateX:10 translateY:10 spacing: 10
46. content: [
47. barraBusca,
48. carrosView.getCarrosView()
49. ]
50. }
51. ]
52. }
53.}
54.
55.function busca():Void{
56. //Muito fácil, para a busca usamos um slice
57. carrosView.carros = carros[n| n.getNome().contains(txtBusca.text)]

58.}
Visualizar Codigo Fonte

01.package classeAbstrata;

02.

03.public abstract class Eletrodomestico {

04. private boolean ligado;

05. private int voltagem;

06.

07. // métodos abstratos //

08. /*

09. * não possuem corpo, da mesma forma que

10. * as assinaturas de método de uma interface

11. */

12. public abstract void ligar();

13. public abstract void desligar();

14.

15. // método construtor //

16. /*

17. * Classes Abstratas também podem ter métodos construtores,

18. * porém, não podem ser usados para instanciar um objeto

diretamente

19. */

20. public Eletrodomestico(boolean ligado, int voltagem) {

21. this.ligado = ligado;

22. this.voltagem = voltagem;

23. }

24.

25. // métodos concretos

26. /*

27. * Uma classe abstrata pode possuir métodos não abstratos

28. */

29. public void setVoltagem(int voltagem) {

30. this.voltagem = voltagem;

31. }

32.

33. public int getVoltagem() {

34. return this.voltagem;

35. }

36.

37. public void setLigado(boolean ligado) {

38. this.ligado = ligado;

39. }
40.

41. public boolean isLigado() {

42. return ligado;

43. }

44.}

Visualizar Codigo Fonte

01.package classeAbstrata;

02.

03.public class TV extends Eletrodomestico {

04. private int tamanho;

05. private int canal;

06. private int volume;

07.

08. public TV(int tamanho, int voltagem) {

09. super (false, voltagem); // construtor classe abstrata

10. this.tamanho = tamanho;

11. this.canal = 0;

12. this.volume = 0;

13. }

14.

15. /* implementação dos métodos abstratos */

16. public void desligar() {

17. super.setLigado(false);

18. setCanal(0);

19. setVolume(0);

20. }

21.

22. public void ligar() {

23. super.setLigado(true);
24. setCanal(3);

25. setVolume(25);

26. }

27.

28. // abaixo teríamos todos os métodos construtores get e set...

29.

30.}

E essa é a classe Radio.

Visualizar Codigo Fonte

01.package classeAbstrata;

02.

03.public class Radio extends Eletrodomestico {

04. public static final short AM = 1;

05. public static final short FM = 2;

06. private int banda;

07. private float sintonia;

08. private int volume;

09.

10. public Radio(int voltagem) {

11. super(false, voltagem);

12. setBanda(Radio.FM);

13. setSintonia(0);

14. setVolume(0);

15. }

16.

17. /* implementação dos métodos abstratos */

18. public void desligar() {

19. super.setLigado(false);

20. setSintonia(0);
21. setVolume(0);

22. }

23.

24. public void ligar() {

25. super.setLigado(true);

26. setSintonia(88.1f);

27. setVolume(25);

28. }

29.

30. // abaixo teríamos todos os métodos construtores get e set...

31.

32.}

Visualizar Codigo Fonte

01.package classeAbstrata;

02.

03.public class Main {

04.

05. public static void main(String[] args) {

06. TV tv1 = new TV(29, 110);

07. Radio radio1 = new Radio(110);

08.

09. /*

10. * chamando os métodos abstratos implementados

11. * dentro de cada classe (TV e Radio)

12. */

13. tv1.ligar();

14. radio1.ligar();

15.

16. System.out.print("Neste momento a TV está ");

17. System.out.println(tv1.isLigado() ? "ligada" : "desligada");

18. System.out.print("e o Rádio está ");

19. System.out.println(radio1.isLigado() ? "ligado." :

"desligado.");

20. }

21.}