Artigo Diretório
1. Aula abstrata
conceito
Em Java, um método sem um corpo de método deve ser definido como um método abstrato e, se houver um método abstrato em uma classe, a classe deve ser definida como uma classe abstrata.
Características das classes abstratas
- Classes abstratas e métodos abstratos devem ser usadosabstratoModificação de palavra-chave
- Formato da classe abstrata:
classe abstrata nome da classe {}
- Formato do método abstrato:
nome do método void abstrato público ();
- Classes abstratas não têm necessariamente métodos abstratos, classes com métodos abstratos devem ser classes abstratas
- A classe abstrata não pode ser instanciada, mas pode haver um método de construção na classe abstrata, o objetivo é inicializar quando a subclasse acessa os dados da classe pai
- Classes abstratas não podem ser instanciadas diretamente, elas são instanciadas por subclasses concretas de maneira polimórfica.
- Subclasse de classe abstrata
- Ou uma classe abstrata
- Ou você deve substituir todos os métodos abstratos na classe abstrata
Exemplo: definição simples de classe abstrata
//抽象类的定义
public abstract class Animals {
String name;
int age;
//共性功能定义为抽象的，抽象类只需给出共性的声明即可
// 具体的实现细节由子类根据自身的差异性，具体去重写
public abstract void eat();
public abstract void sleep();
public void show(){
System.out.println("抽象类内可以有非抽象方法");
}
}
//子类继承该抽象类，必须重写抽象类中的抽象方法
public class Cat extends Animals {
//抽象方法的重写，由子类依据自身特性具体实现
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫睡沙发");
}
}
public class Dog extends Animals {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void sleep() {
System.out.println("狗睡地上");
}
}
Características dos membros de classes abstratas
- Variável de membro: variável ou constante
- Método de construção: Sim, usado para a inicialização da subclasse para acessar os dados da classe pai.
- Método de membro: pode ser abstrato ou não abstrato.
Nota
As características do método membro de classes abstratas:
- Métodos abstratos forçam as subclasses a fazer coisas
- Herança de subclasse de método não abstrato, melhora a capacidade de reutilização do código
Exemplo: como instanciar uma classe abstrata
public class Mytest {
public static void main(String[] args) {
//采用多态的形式创建父类引用，间接实例化父类
Fu fu=new Zi();
//多态中成员变量的访问特点：编译看左，运行看左
System.out.println(fu.num);
//多态中成员方法的访问特点：编译看左，运行看右
fu.show();
//向下转型，将父类引用强制转化成子类引用
Zi zi=(Zi)fu;
System.out.println(zi.num);
zi.show();
}
}
abstract class Fu{
int num=10;
//抽象类不能直接实例化，但是有构造方法
public Fu(){
System.out.println("父类构造方法执行");
}
public abstract void show();
}
class Zi extends Fu{
int num=20;
public Zi(){
System.out.println("子类构造方法执行");
}
@Override
public void show() {
System.out.println("子类show方法执行");
}
}
resultado da operação:
Pensando
-
Se uma classe não possui métodos abstratos, ela pode ser definida como uma classe abstrata?
Sim, o mundo exterior não pode criar tais objetos, o que equivale ao método de construção de classes privatizadas.
-
Com quais palavras-chave não podem coexistir ?
- final: contraditório, a subclasse abstrata obrigatória deve ser reescrita, final não permite a reescrita da subclasse
- privado: contraditório, abstrato força as subclasses a serem reescritas, as subclasses privadas não podem ser herdadas e não podem ser reescritas
- static: o método estático pertence à classe, portanto, não participa da reescrita, sem sentido
Exercício
Requisitos: Se precisarmos projetar a classe de funcionário (Funcionário) ao desenvolver um sistema, o funcionário contém 3 atributos: nome, número do trabalho e salário (salário).
O gerente também é funcionário, além dos atributos do funcionário, existe o atributo bônus. Em seguida, defina o método de trabalho.
Use a ideia de herança para projetar a classe de funcionário e a classe de gerente.
//定义一个抽象类，将员工和经理的共性抽取出来，并声明一个抽象方法。
public abstract class person {
public String name;
public int num;
public double salary;
public abstract void workshow();
}
//员工类继承该抽象类，并依据自身的特性，实现抽象类中的抽象方法
public class Employee extends person {
@Override
public void workshow() {
System.out.println("员工一周工作七天");
}
}
//经理继承该抽象类，并重写抽象方法。声明额外属性bouns
public class Manager extends person{
public double bouns;
@Override
public void workshow() {
System.out.println("经理一周工作5天");
}
}
//测试类
public class Mytest {
public static void main(String[] args) {
//使用多态的方式，创建对象
person p=new Employee();
p.name="小明";
p.num=224075;
p.salary=3500;
System.out.println("员工名字:"+p.name+";职工号："+p.num+";月薪："+p.salary);
//多态中成员方法的访问特点：编译看左，运行看右
p.workshow();
System.out.println("====================================================");
person p1=new Manager();
p1.name="赵建国";
p1.num=1;
p1.salary=7500;
//向下转型，才能调用子类中的特有属性
((Manager) p1).bouns=800;
System.out.println("经理名字：" + p1.name + ";职工号：" + p1.num + ";月薪：" + p1.salary+";奖金："+((Manager) p1).bouns);
p1.workshow();
}
}
resultado da operação:
2. Interface
conceito
Para refletir a extensibilidade das coisas, Java fornece interfaces para definir essas funções adicionais, e não fornece implementações específicas.É suficiente entregar essas funções adicionais para alguns objetos específicos.
Recursos da interface
- Palavra-chave para interface interface formato:
nome da interface da interface {}
- A interface de implementação da classe usa o formato implements:
classe nome da classe implementa nome da interface {}
- A interface não pode ser instanciada diretamente, ela precisa ser instanciada de maneira polimórfica
- Subclasse de interface
- Pode ser uma classe abstrata, mas tem pouco significado
- Pode ser uma aula concreta. Para reescrever todos os métodos abstratos na interface.
Características dos membros da interface
- Variáveis de membro: só podem ser constantes e estáticas. Modificador padrão: public static final (é recomendado fornecê-lo manualmente)
- Método de construção: a interface não tem método de construção
- Método membro: apenas método abstrato, modificador padrão: resumo público (é recomendado fornecê-lo manualmente)
Exemplo: definição e implementação simples de interface
//定义一个接口，接口中定义的都是一些扩展功能，哪类事物需要具备该扩展功能，就需要实现该接口。
public interface Myinterface {
public static final int num=1000;//默认修饰符：public static final
public abstract void calc();//默认修饰符：public abstract
}
//子类实现父接口，必须重写接口中的所有抽象方法
public class person implements Myinterface {
@Override
public void calc() {
System.out.println("人会算数");
}
public void love(){
System.out.println("人有情感");
}
}
public class dog implements Myinterface {
@Override
public void calc() {
System.out.println("狗经过后天训练，也会算数");
}
public void watchdoor(){
System.out.println("狗会看家");
}
}
//使用多态的形式，创建对象。
public class mytest {
public static void main(String[] args) {
//接口不能创建对象，子类和接口之间是实现关系，可以叫父接口，子类
//采用多态的形式
Myinterface myinterface=new person();
myinterface.calc();
System.out.println(myinterface.num);
//想要调用子类中独有的方法，需向下转型
person p=(person)myinterface;
p.love();
System.out.println(p.num);
System.out.println("=====================================");
Myinterface myinterface1 = new dog();
myinterface1.calc();
System.out.println(myinterface1.num);
dog d=(dog)myinterface1;
d.watchdoor();
System.out.println(d.num);
}
}
3. A diferença entre classe abstrata e interface
-
Diferença de membros
-
Aula abstrata
- Variável membro: pode ser uma variável ou uma constante
- Método de construção: Sim
- Método de membro: pode ser abstrato ou não abstrato
-
interface
- Variáveis de membro: devem ser constantes públicas estáticas modificadas por padrão public static final
- Métodos membros: apenas métodos abstratos podem ser definidos após JDK1.8. Métodos de modificação padrão podem ser definidos. A implementação específica da função pode ser fornecida. Subclasses podem herdar e usar. Após JDK1.8, métodos estáticos também podem ser definidos no interface.
-
-
Diferença de relacionamento
-
Aula e aula
- Herança, herança única, herança múltipla
-
Classe e interface
- Realização, realização única, realização múltipla
-
Interface e interface
- Herança, herança única, herança múltipla
-
-
Diferença de conceito de design
- Classe abstrata, herdada reflete a relação de "é um", e o que é definido na classe abstrata é a função comum do sistema de herança
- A interface é implementada para refletir o relacionamento de "como um", e o que é definido na interface é a função estendida do sistema de herança.