Aula abstrata
Quando uma classe é decorada com abstrato, essa classe é uma classe abstrata; o método decorado com abstrato é chamado de método abstrato. Aqui estão alguns pontos a serem observados:
1. A classe que contém métodos abstratos deve ser declarada como classes abstratas (interfaces são abstrações profundas de classes abstratas), classes abstratas devem ser herdadas (caso contrário, não têm sentido) e métodos abstratos devem ser reescritos.
2. O método abstrato só precisa ser declarado, não implementado.
3. As classes abstratas não podem ser instanciadas, porque a maioria das classes abstratas possui métodos abstratos, os métodos abstratos não têm corpo de método e a instanciação relatará um erro. Além disso, também pode haver algumas classes abstratas sem métodos abstratos, mas não há diferença entre classes sem métodos abstratos e classes de entidade, portanto, classes abstratas sem métodos abstratos não têm sentido.
3. As classes abstratas podem conter métodos de entidade ou variáveis de membro.
A seguir está um exemplo da estrutura gramatical:
abstract class Animal{
//抽象类可以具有实体方法和成员变量
private String name;
Animal(String name){
this.name=name;
}
//抽象方法，权限只能是public或者protected
public abstract void enjoy();
}
class Cat extends Animal{
private String eyesColor;
Cat(String n,String c){
//调用父类构造函数
super(n);
eyesColor=c;
}
//重写抽象方法
public void enjoy(){
System.out.println("猫叫声....");
}
}Na verdade, também pode ser visto no exemplo acima que os métodos abstratos de classes abstratas são projetados para serem reescritos por outros para atingir o polimorfismo orientado a objetos. Se a subclasse não deseja implementar métodos abstratos, então a subclasse também deve adicionar a palavra-chave abstract para declarar a subclasse como uma classe abstrata.
interface
Use a interface para definir uma interface. A definição da interface é semelhante à definição da classe, dividida em declaração da interface e corpo da interface.O corpo da interface é composto por duas partes: definição de constante e definição de método. Preste atenção ao uso de interfaces:
1. As interfaces podem conter constantes (observe que não são variáveis) e métodos, e as constantes na interface serão designadas implicitamente como public static final (isso também pode explicar por que são constantes em vez de variáveis), os métodos serão designados implicitamente como um método abstrato público. Você pode verificar o link para razões específicas: Por que as variáveis de interface são public static final por padrão?
2. Interface é um tipo profundamente abstrato.
3. A interface não tem nenhuma implementação e é mais adequada como uma classe base.
O formato básico para definir a interface é o seguinte:
[修饰符] interface 接口名 [extends 父接口名列表]{
//可选参数public，如果省略，则为默认的访问权限；
[public] [static] [final] 常量;
[public] [abstract] 方法;
}Para implementar a interface, use a palavra-chave implements:
[修饰符] class <类名> [extends 父类名] [implements 接口列表]{
//重写接口方法
...
}Aqui está um exemplo:
//定义各功能接口
interface CanFight {
void fight();}
interface CanFly {
void fly();}
interface CanSwim {
void swim();}
//定义一个抽象
class ActionCharacter {
public void fight(){}}
class Hero extends ActionCharacter implements CanFight, CanFly, CanSwim {
@Override
public void swim() {}
@Override
public void fly() { }
}
public class Adventure {
public static void t(CanFight x){x.fight();}
public static void u(CanSwim x){x.swim();}
public static void v(CanFly x){x.fly();}
public static void w(ActionCharacter x){x.fight();}
public static void main(String[] args) {
Hero h = new Hero();
t(h);
u(h);
v(h);
w(h);
}
}Pelo exemplo, podemos ver:
1. Hero tem as funções de cada interface ao mesmo tempo
2. Hero pode ser convertido para essas interfaces implementadas por ele. Quando passamos o objeto herói como parâmetro para cada método da classe Adventure, Hero A classe foi transformada para cima. Pode-se perceber que os benefícios da interface podem atingir uma transformação ascendente, e várias classes com atributos comuns podem extrair seus pontos comuns e torná-los abstratos, de forma que a hierarquia seja clara e de gerenciamento unificado.
Aqui está um ponto adicional de conhecimento: a transformação para cima é transferível . Por exemplo, se o subtipo de A é B e o subtipo de B é C, então a seguinte declaração
A a0=new A();
A a1=new B();
A a2=new C();Todos atendem às condições corretamente.
A diferença e relação entre interface e classe abstrata
relação
Realize e melhore as funções de herança múltipla do Java combinando interfaces e classes abstratas.
a diferença
- Classes abstratas são classes e podem ter métodos de entidade.
- As classes abstratas não podem implementar herança múltipla, enquanto as interfaces podem.
- Se você precisar criar uma classe base sem quaisquer definições de método e variáveis de membro, use uma interface.Se a classe requer alguma implementação concreta, use uma classe abstrata.
- Se você deseja projetar uma classe como uma classe base com antecedência, a interface é preferida. == (Observe que c e d são os cenários de uso da interface) ==
- Uma classe abstrata é uma abstração de um tipo de coisa, ou seja, uma abstração de uma classe, e uma interface é mais uma abstração de comportamento.
Um exemplo de porta e alarme circula na Internet: a porta tem duas ações: abrir () e fechar (). Neste momento, podemos definir este conceito abstrato por meio de classes e interfaces abstratas:
abstract class Door {
public abstract void open();
public abstract void close();
}ou
interface Door {
public abstract void open();
public abstract void close();
}Mas agora, se precisamos que a porta tenha uma função alarm (), como fazer isso? Duas ideias são fornecidas abaixo:
1) Coloque essas três funções na classe abstrata, mas desta forma todas as subclasses herdadas dessa classe abstrata têm a função de alarme, mas algumas portas podem não ter a função de alarme;
2) Coloque essas três funções na interface, a classe que precisa da função de alarme precisa implementar open () e close () nesta interface, talvez esta classe não tenha open () e close () em todas as Duas funções, como alarme de incêndio.
Pode-se ver a partir disso que a porta aberta (), fechada () e alarme () pertencem basicamente a duas categorias diferentes de comportamento, abrir () e fechar () pertencem às características inerentes de comportamento da própria porta, e alarme ( ) pertence ao comportamento adicional estendido. Portanto, a melhor solução é projetar o alarme como uma interface separadamente, incluindo o comportamento de alarm () e a Porta como uma classe abstrata separada, incluindo os dois comportamentos de abrir e fechar. Em seguida, projete uma porta de alarme para herdar a classe Porta e implementar a interface de Alarme.
interface Alram {
void alarm();
}
abstract class Door {
void open();
void close();
}
class AlarmDoor extends Door implements Alarm {
void oepn() {
//....
}
void close() {
//....
}
void alarm() {
//....
}
}Materiais de referência:
https://www.cnblogs.com/xdp-gacl/p/3648398.html
https://blog.csdn.net/zhangerqing/article/details/8298603