Domine facilmente classes e interfaces abstratas

Um: classe abstrata

1.1 O conceito de classes abstratas

No conceito orientado a objetos, todos os objetos são descritos por classes, mas, por sua vez, nem todas as classes são usadas para descrever objetos, se uma classe não contém informações suficientes para descrever um objeto específico, tal classe é uma classe abstrata.
Para dar um exemplo simples: um
paralelogramo é um quadrilátero especial com lados opostos iguais e propriedades paralelas, um triângulo isósceles é um triângulo em que dois lados são iguais, essas descrições são todas razoáveis. Mas para objetos gráficos, a linguagem concreta não pode ser usada para descrevê-lo, ele tem várias arestas, e ninguém pode dizer que tipo de grafo é. Esse tipo de classe de grafo é chamado de classe abstrata em Java.
Na resolução de problemas práticos, a classe pai é geralmente definida como uma classe abstrata. classe precisa ser usada para herança e polimorfismo. No mecanismo de polimorfismo, não há necessidade de inicializar o objeto da classe pai, tudo o que precisamos é o objeto da subclasse, então a classe abstrata não pode ser instanciada em Java, porque a classe A classe graphics não pode abstrair um gráfico concreto, mas suas subclasses podem.

1.2 Sintaxe de classes abstratas.

Em Java, se uma classe for modificada por abstract, ela é chamada de classe abstrata, e o método modificado por abstract em uma classe abstrata é chamado de método abstrato, e o método abstrato não precisa fornecer um corpo de implementação específico.

//抽象类,被abstract修饰的类
public abstract class Shape{
    
    
	//抽象方法:被abstract修饰的方法,没有方法体.
	abstract public void draw();
	abstract void calcArea();
	protected double area;
	//抽象类也是类,也可以增加普通方法和属性,甚至是构造方法.
	public double getArea(){
    
    
		return area;
	}
}
注意:抽象方法没有方法体,这个方法本身没有任何的意义,
	 除非它被重写,而承载这个抽象方法的抽象类必须被继承,
	 实际上抽象类除了被继承之外没有任何的意义.
	只要类中有一个抽象方法,那这个类就要被定义为抽象类.

1.3 Recursos da classe abstrata.

1.3.1 Classes abstratas não podem instanciar objetos

//编译错误,抽象类不能直接实例化对象.
Shape s=new Shape();

1.3.2 Um método abstrato não pode ser privado.

Quando um método abstrato não tem modificador de acesso, o padrão é público.

//编译出错
abstract class Student{
    
    
	abstract private void exam();
}

1.3.3 Métodos abstratos não podem ser modificados por final e static, pois métodos abstratos devem ser substituídos por subclasses.

//编译出错.
public abstract class Shape {
    
    
 	abstract final void methodA();
 	abstract public static void methodB();
}

1.3.4 A classe abstrata deve ser herdada e a subclasse deve reescrever o método abstrato na classe pai após a herança, caso contrário a subclasse também é uma classe abstrata e deve ser modificada com abstract

public class Rect extends Shape{
    
    
	private double length;
	private double width;
	Rect(double length,double width){
    
    
		this.length=length;
		this.width=width;
	}
	public void draw(){
    
    
		System.out.println("矩形: length="+length+" width="+width);
	}
	public void calcArea(){
    
    
		area=length*width;
	}
}

3.5 Classes abstratas não contêm necessariamente métodos abstratos, mas classes com métodos abstratos devem ser classes abstratas.

2. Interface.

2.1 Introdução à interface

Uma interface é uma extensão de uma classe abstrata. Ela pode ser considerada como uma classe abstrata pura, e todos os métodos na boca não têm corpo de método. Em Java, uma interface é um padrão público de comportamento. Ao implementar, contanto que está em conformidade com o padrão, pode ser usado universalmente e é um tipo de dados de referência.

2.2 Regras gramaticais.

O formato de definição de uma interface é basicamente o mesmo de definir uma classe. Substitua a palavra-chave class pela palavra-chave interface para definir uma interface.
Ao criar uma interface, o nome da interface geralmente começa com a letra maiúscula 'I'

public interface 接口名称{
    
    
	//抽象方法
	/*
		在接口中,方法必须被定义为public或者abstract形式,
			其他修饰权限不被Java编译器认可.
	*/
}

pequeno exemplo simples

public interface IInterface {
    
    
    void method1();     //更推荐这种写法.
    abstract void method2();
    public abstract void method3();//public abstract是固定搭配,可以省略.
    public void method4();
}

2.3 Uso da interface

a. A interface não pode ser usada diretamente, deve haver uma "classe de implementação" para "implementar" a interface. Implemente todos os métodos abstratos na interface
. a classe e a interface Implementando relacionamentos
Vejamos um código simples.

public class InterfaceImp implements IInterface{
    
    

    public void method1() {
    
    

    }

    public void method2() {
    
    

    }

    public void method3() {
    
    

    }

    public void method4() {
    
    

    }

    public static void main(String[] args) {
    
    
        //接口并不是类，所以并不能实例化对象，
        //IInterface ii=new IInterface();
        InterfaceImp ii=new InterfaceImp();
    }
}

2.4. Resumo das características da interface

a. O tipo de interface é um tipo de referência, mas não pode ser uma instância da nova interface diretamente.
b. Cada método na interface é um método abstrato público, ou seja, o método na interface será implicitamente designado como abstrato público , que só pode ser public abstract, outros modificadores reportarão erros
c) A interface pode conter variáveis, mas as variáveis ​​na interface serão implicitamente designadas como variáveis ​​finais estáticas públicas.

public interface IShape{
    
    
	void draw();
	double PI=3.14;// 默认会加上 public static final 
}

d. Os métodos na interface não podem ser implementados na interface, mas podem ser implementados apenas pela classe que implementa a interface.

public interface IShape{
    
    
	void draw();
	//编译错误,接口中的抽象方法不能有主体.
	 double area(){
    
    
		return 0;
	}
}

e. Embora a interface não seja uma classe, o formato de sufixo do arquivo bytecode após a interface ser compilada também é .class
f. Ao reescrever os métodos na interface, a permissão de acesso padrão não pode ser usada para modificar

public interface IShape{
    
    
	void draw();
}
public class Rect implements IShape{
    
    
	//编译失败,重写方法时,不能使用default默认访问修饰符.
	void draw(){
    
    
		System.out.println("矩形");
	}
}

g. As interfaces não podem ter blocos de código estático e construtores.

2.5 Implemente várias interfaces.

Em Java, há herança única entre classes e classes, e uma subclasse pode ter apenas uma classe pai, ou seja, herança múltipla não é suportada em Java. Entretanto, existem múltiplas implementações entre uma classe e uma interface, ou seja, uma classe pode implementar várias interfaces.

//先定义一个动物类.
public class Animal{
    
    
	protected String name;
	public Animal(String name){
    
    
		this.name=name;
	}
}

Defina várias interfaces.

public interface IRunning {
    
    
 void run();
}

public interface ISwimming {
    
    
 void swim();
}

//Cria vários animais específicos
a. gatos

public class Cat extends Animal implements IRunning {
    
    
 	public Cat(String name) {
    
    
 		super(name);
 	}
 //重写方法
 	public void run() {
    
    
 		System.out.println(this.name + "正在用四条腿跑");
 	}
}

b. peixe

public class Fish extends Animal implements ISwimming {
    
    
 	public Fish(String name) {
    
    
 		super(name);
 	}
	//重写方法
 	public void swim() {
    
    
 	System.out.println(this.name + "正在用尾巴游泳");
 	}
}

c. Sapo

pubic class Frog extends Animal implements IRunning, ISwimming {
    
    
 	public Frog(String name) {
    
    
 		super(name);
 	}
 	public void run() {
    
    
 		System.out.println(this.name + "正在往前跳");
 	}
 	//重写方法
 	public void swim() {
    
    
 		System.out.println(this.name + "正在蹬腿游泳");
 	}
}

2.6 Herança em interfaces

Em Java, existe herança única entre classes e classes, ou seja, uma classe pode ter apenas uma classe pai, mas existem múltiplas implementações entre uma classe e uma interface, ou seja, uma classe pode implementar múltiplas interfaces, e entre interfaces e interfaces Herança múltipla é possível. Ou seja: o propósito da herança múltipla pode ser alcançado com interfaces.

interface IRunning {
    
    
 void run();
}

interface ISwimming {
    
    
 void swim();
}

Anfíbios que podem correr e nadar

interface IAmphibious extends IRunning, ISwimming {
    
    
		
}

Crie uma nova interface IAmphibious por meio de herança de interface, que significa "anfíbio". Neste momento, a classe Frog criada pela interface precisa continuar a implementar o método run e o método swim.
Herança entre interfaces é equivalente a mesclar várias interfaces .

public class Frog implements IAmphibious {
    
    
 	//...在这里就不实现了,大家自己完成一下.
}