Os programas Java usam classes abstratas para implementar conceitos abstratos na natureza. A função de uma classe abstrata é organizar muitas classes relacionadas juntas para fornecer uma classe comum, ou seja, uma classe abstrata, e as classes específicas organizadas por ela serão derivadas dela como suas subclasses. Uma classe abstrata caracteriza o comportamento público e o transfere para suas classes derivadas através do mecanismo de herança. Os métodos definidos em classes abstratas são chamados de métodos abstratos. Esses métodos possuem apenas a declaração do cabeçalho do método e utilizam ponto e vírgula para substituir a definição do corpo do método, ou seja, apenas a forma da interface do método membro é definida sem operações específicas. . Somente a redefinição de métodos de membros abstratos por uma classe derivada realmente implementa operações relacionadas à classe derivada.
Depois que cada subclasse herda o método abstrato da classe pai, ela o redefine com diferentes instruções e corpos de método, formando várias subclasses com o mesmo nome, o mesmo valor de retorno e a mesma lista de parâmetros, com o mesmo propósito, mas com certas diferenças específicas. método de implementações. O objetivo de definir um método abstrato em uma classe abstrata é implementar uma interface, ou seja, todas as subclasses apresentam um método com o mesmo nome para o mundo exterior. Uma classe abstrata é uma coleção de atributos públicos de todas as suas subclasses e uma classe que contém um ou mais métodos abstratos. Uma das vantagens de usar classes abstratas é que você pode aproveitar ao máximo essas propriedades públicas para melhorar a eficiência do desenvolvimento e manutenção de programas. As restrições sobre classes abstratas e métodos abstratos são as seguintes:
(1) Qualquer classe modificada com o modificador abstrato é chamada de classe abstrata. Qualquer método membro modificado com o modificador abstrato é chamado de método abstrato.
(2) Uma classe abstrata pode ter zero ou mais métodos abstratos ou também pode conter métodos não abstratos.
(3) Não há necessidade de métodos abstratos em classes abstratas, mas as classes com métodos abstratos devem ser classes abstratas.
(4) Para métodos abstratos, apenas o nome do método e seu tipo são especificados na classe abstrata, sem escrever seu código de implementação.
(5) Uma classe abstrata pode derivar subclasses, e todos os métodos abstratos definidos na classe abstrata devem ser implementados nas subclasses derivadas da classe abstrata.
(6) Classes abstratas não podem criar objetos. O trabalho de criação de objetos é implementado por subclasses derivadas de classes abstratas.
(7) Se houver um método abstrato com o mesmo nome na classe pai, não pode haver outro método abstrato com o mesmo nome na subclasse.
(8) abstract não pode modificar a mesma classe em paralelo com final.
(9) abstrato não pode ser usado para modificar o mesmo método em paralelo com privado, estático, final ou nativo.
A linguagem Java estipula que quando uma classe possui um método abstrato, a classe deve ser declarada como uma classe abstrata.
Quando uma subclasse herda uma classe pai, se houver métodos abstratos na classe pai, e a subclasse sentir que pode implementar todos os métodos abstratos da classe pai, então a subclasse deve implementar todos os métodos abstratos da classe pai, tal como:
/** * A subclasse Dog herda a classe abstrata Animal e implementa o método abstrato Enjoy * @author gacl * */class Dog extends Animal { /** * A classe Dog adiciona seus próprios atributos exclusivos*/ public String public Dog; ( String n, String c) { super(n);//Chama o construtor da classe pai Animal this.furColor = c } @Override public void Enjoy() { System.out.println("O cachorro late.. .."); }} Se a subclasse achar que o método abstrato na classe pai não pode ser implementado, declare a subclasse como uma classe abstrata, como:
/** * A subclasse Cat aqui herda da classe abstrata Animal e naturalmente herda o método abstrato Enjoy() declarado na classe Animal * No entanto, a subclasse Cat sente que não é apropriado implementar este método Enjoy() por. em si, então ele se declara como uma classe abstrata, * Então, quem implementa esse método abstrato de diversão e quem herda a subclasse, então implementa esse método abstrato de desfrutar (). * @author gacl * */abstract class Cat extends Animal { /** * Cat adiciona seus próprios atributos exclusivos*/ public String eyeColor; public Cat(String n, String c) { super(n);//Chama a classe pai; Método de construção do animal this.eyeColor = c }} A subclasse Cat aqui herda da classe abstrata Animal e naturalmente herda o método abstrato Enjoy() declarado na classe Animal. No entanto, a subclasse Cat sente que não é apropriado implementar este método Enjoy() por conta própria, então é. chama a si mesmo Declarado como uma classe abstrata, então quem implementa o método abstrato Enjoy e quem herda a subclasse implementa o método abstrato Enjoy(). como:
/** * A subclasse BlueCat herda a classe abstrata Cat e implementa o método abstrato like herdado da classe pai Cat * @author gacl * */class BlueCat extends Cat { public BlueCat(String n, String c) { super(n , c); } /** * Implementa o método abstrato Enjoy */ @Override public void Enjoy() { System.out.println("O gato azul mia..."); O código de teste completo é o seguinte:
package javastudy.summary;/** * Classe pai Animal * Adicione abstract na frente da classe, ou seja, declare-o assim: abstract class Animal * Desta forma, a classe Animal se torna uma classe abstrata */abstract class Animal { public String name; public Animal(String name) { this.name = name } /** * Método abstrato * Existe apenas a definição do método, mas nenhuma implementação. */ public abstract void Enjoy(); }/** * A subclasse Cat aqui herda da classe abstrata Animal e naturalmente herda o método abstrato Enjoy() declarado na classe Animal, * mas a subclasse Cat sente que deve ser implementado por si só Este método Enjoy() também é inadequado, então ele se declara como uma classe abstrata * Então, quem implementa este método abstrato Enjoy, e quem herda uma subclasse, então quem implementa este método abstrato Enjoy(). * @author gacl * */abstract class Cat extends Animal { /** * Cat adiciona seus próprios atributos exclusivos*/ public String eyeColor; public Cat(String n, String c) { super(n);//Chama a classe pai; Método de construção do Animal this.eyeColor = c; }}/** * A subclasse BlueCat herda a classe abstrata Cat e implementa o método abstrato like herdado da classe pai Cat * @author gacl * */class BlueCat extends Cat { public BlueCat(String n, String c) { super(n, c } /** * Implementa o método abstrato Enjoy */ @Override public void Enjoy() { System.out.println("Blue Cat mia. .."); } }/** * A subclasse Dog herda a classe abstrata Animal e implementa o método abstrato Enjoy * @author gacl * */class Dog extends Animal { /** * A classe Dog adiciona seus próprios atributos exclusivos * /string pública furColor; public Dog(String n, String c) { super(n);//Chama o construtor da classe pai Animal this.furColor = c } @Override public void Enjoy() { System.out.println("Dog" late ...."); }} public class TestAbstract { /** * @param args */ public static void main(String[] args) { /** * Depois que a classe Cat é declarada como uma classe abstrata, a classe Cat não pode ser instanciada. * Como a classe abstrata está incompleta e faltando braços e pernas, a classe abstrata não pode ser instanciada. */ //Cat c = new Cat("Catname","blue"); Dog d = new Dog("dogname","black"); d.enjoy();//Chame o método Enjoy BlueCat que você implementou c. = new BlueCat("BlueCatname","blue"); c.enjoy();//Chame o método Enjoy que você implementou}}