Uma classe abstrata
Uma classe abstrata, para ser franco, é uma abstração de uma classe. Então sabemos que uma classe também é uma abstração de uma classe de coisas. Como entender uma classe abstrata? Acho que devemos usar alguns exemplos para ilustrar o que é uma classe abstrata. classe abstrata faz.
Primeiro precisamos conhecer o formato de definição de uma classe abstrata: nome da classe da classe abstrata pública
Então, o que escrevemos dentro da classe abstrata?
Podemos definir alguns métodos em uma classe abstrata. Os métodos que definimos são abstratos públicos por padrão. Uma coisa a lembrar aqui é que métodos abstratos devem existir em classes abstratas, mas classes abstratas não precisam necessariamente ser abstratas. Alguns métodos comuns também podem ser definidos. Então, quando definimos um método abstrato, não podemos escrever nada nesse método abstrato, ou seja, não podemos implementar esse método abstrato. Conforme mostrado na figura abaixo, o programa se tornará popular diretamente, nos alertando que métodos abstratos não podem ter corpos de métodos:
Como definimos um método abstrato, o programa não permite escrever uma implementação específica, então qual é a utilidade de definir esse método abstrato? Aqui isso implica para nós que a classe abstrata deve ser herdada por outras classes e, em seguida, a classe que herda-o Este método abstrato é implementado em detalhes. Vamos experimentá-lo, definir um método abstrato na classe abstrata Person class, e deixar que a classe Student Student o herde. código mostrar como abaixo:
Reescrevemos o método abstrato na classe Person na classe Student e, em seguida, implementamos a implementação concreta. O que precisamos lembrar aqui é que os métodos abstratos na classe abstrata devem ser completamente substituídos na classe que o herda. Os programas acima podem ser executados normalmente, e também podemos escrever alguns métodos comuns em classes abstratas, e métodos comuns podem ser implementados concretamente sem a necessidade de implementações concretas em outras classes. Isso reduz a duplicação de código. Por exemplo, escrevemos um método comum eat() para a classe Person, o código é o seguinte:
O método comum na classe abstrata não precisa ser reescrito em sua subclasse, é claro que, se você quiser reescrevê-lo, ainda é possível.
Então, qual é a utilidade de definir uma classe abstrata, na minha opinião (se houver um entendimento melhor do que eu, por favor, deixe uma mensagem): Depois de definirmos uma classe abstrata, podemos colocar os comportamentos públicos e as propriedades de outras classes em Isso é implementado aqui. Por exemplo, no exemplo acima, defina uma classe Aluno e uma classe Professor. O método público de suas classes é que todos vão comer, então eu posso implementar o método de comer na classe Pessoa. Mas para o método do sono, apenas os alunos podem ter intervalos para o almoço, mas os professores não podem ter intervalos para o almoço, ou seja, eles têm formas diferentes para o método do sono, então podemos definir esse método abstrato em uma aula abstrata sem explicar esse método. fazer, o que esse método faz especificamente, pode ser implementado na classe que o herda.
2. Interface
Interface é uma abstração da abstração.Eu acredito que depois de ouvir essa frase, é como ouvir essa frase, e eu não entendo, e não sei o que isso significa. Na interface, os métodos que definimos são apenas métodos sem implementações específicas, você deve se sentir assim. Vamos mais longe: em nosso exemplo anterior, um método abstrato sleep é definido em Person. Embora não exista uma implementação específica, sabemos que esse método deve estar relacionado a pessoas. Então definimos um método abstrato na interface como sleep (sleep) neste momento, o sleep aqui, não sabemos se está relacionado a pessoas, talvez esteja relacionado a animais. Porque os animais também dormem. Neste ponto, todos devem ter um entendimento semelhante . Apenas métodos abstratos são declarados na interface, e os métodos declarados devem ser abstratos, geralmente a abstração de um determinado comportamento. Quem vai usar este método pode acessar esta interface. .
O formato de declaração da interface é o seguinte. Quando definimos um método nela, não precisamos escrever public e abstract. Isso nos lembra que essas duas modificações são redundantes, pois os métodos na interface são métodos públicos abstratos por padrão , como mostrado abaixo:
Na interface, também podemos declarar uma variável (as variáveis são constantes aqui), que são decoradas com public static final na frente. Estes são todos os padrões. Ao declarar, não há necessidade de escrevê-los, eles são todos redundantes, como mostrado na figura a seguir:
Após declararmos uma interface, se quisermos usar essa interface em outras classes, podemos usar a palavra-chave implement para acessar essa interface. O que devemos prestar atenção aqui é que uma classe pode herdar várias interfaces, o que supera java A desvantagem de apenas herança única entre classes e classes chinesas, herança múltipla pode ser alcançada na interface .
Vamos definir uma interface IF, definir uma classe abstrata Person, definir duas classes comuns Student, Animal, para escrever um exemplo, primeiro observe o efeito da implementação:
O código específico é o seguinte:
public class Main {
public static void main(String[] args) {
Person person=new Student();//实例化类Student的一个对象person，作为Person类的引用。
IF f=new Animal();//实例化类Animal的一个对象f，作为接口IF类的引用。
f.run();
IF f1=(IF) person;//实例化类Student的一个对象person，作为Person类的引用，然后强制转换为IF接口的引用
f1.run();
}
}//声明一个接口
public interface IF {
public abstract void run();//这里写不写public abstract都行
}
//定义一个抽象类
public abstract class Person {
public abstract void sleep();//定义的抽象方法
void eat(){
System.out.println("人们大多数都是一日三餐");
}
}//定义一个普通的类
public class Student extends Person implements IF{
//这个是对继承的Person抽象类中的方法进行重写，然后进行具体的实现。
@Override
public void sleep() {
System.out.println("学生们都会有午休");
}
//当我们继承一个接口时，我们需要对这个接口中的所有抽象方法都进行重写。
//重写接口中的方法run
@Override
public void run() {
System.out.println("学生们跑的很快");
}
}//定义一个普通类Animal
public class Animal implements IF {
//因为该类继承了接口IF，所以要重写IF中的全部抽象的方法
@Override
public void run() {
System.out.println("有些动物跑的比人快");
}
}Resumo: Abstração e interface são duas coisas que só podemos entender melhor quando as aplicamos na prática concreta, basta lembrar as regras para defini-las e suas características.