Uso de interfaz
-
La interfaz se define mediante interfaz.
-
Cómo definir la interfaz, definir los miembros en la interfaz
2.1 jdk7 y antes, solo se pueden definir constantes globales y métodos abstractos
Constantes globales: public static final ... se pueden omitir
Métodos abstractos: public abstract ... se pueden omitir2.2 jdk8: además de definir constantes globales y métodos abstractos, también puede definir métodos estáticos y métodos predeterminados
-
El constructor no se puede definir en la interfaz, lo que significa que no se puede crear una instancia de la interfaz. (Una clase abstracta puede definir un constructor, pero no puede instanciarse)
-
En el desarrollo de Java, las interfaces se implementan a través de clases (implementos).
Si la clase de implementación implementa todos los métodos en la interfaz, entonces esta clase de implementación se puede instanciar; de lo contrario, la clase sigue siendo una clase abstracta. -
Las clases Java pueden implementar múltiples interfaces -> para compensar las limitaciones de la herencia única de la clase Java
Formato: la clase A extiende B implementa C, D -
Las interfaces y las interfaces se pueden heredar directamente y es posible la herencia múltiple.
-
El uso específico de la interfaz refleja polimorfismo
-
Interfaz, en realidad se puede considerar como una especie de especificación
-
Experiencia en el desarrollo de programación orientada a interfaces
10. Crear una clase de implementación anónima de la interfaz
package com.example;
public class InterfaceTest {
public static void main(String[] args) {
Plane p = new Plane();
p.fly();
}
}
interface Flyable {
//全局常量
public static final int MAX_SPEED = 7900;//第一宇宙速度
int MIN_SPEED = 1;
//抽象方法
public abstract void fly();
void stop();
}
interface Attackable {
void attack();
}
class Plane implements Flyable {
@Override
public void fly() {
}
@Override
public void stop() {
}
}
abstract class Rocket implements Flyable, Attackable {
@Override
public void fly() {
}
}
interface AA{
}
interface BB{
}
interface CC extends AA, BB{
}
Polimorfismo, norma
package com.example;
public class USBTest {
public static void main(String[] args) {
Computer c = new Computer();
//1. 创建接口的非匿名实现类的非匿名对象
Flash f = new Flash();
c.transferData(f);
//2. 创建接口的非匿名实现类的匿名对象
c.transferData(new Printer());
//3. 创建接口的匿名实现类的非匿名对象
USB p = new USB() {
@Override
public void start() {
System.out.println("p start");
}
@Override
public void stop() {
System.out.println("p stop");
}
};
c.transferData(p);
//创建接口的匿名实现类的匿名对象
c.transferData(new USB() {
@Override
public void start() {
System.out.println("start");
}
@Override
public void stop() {
System.out.println("stop");
}
});
}
}
interface USB {
void start();
void stop();
}
class Flash implements USB {
@Override
public void start() {
System.out.println("Flash start");
}
@Override
public void stop() {
System.out.println("Flash stop");
}
}
class Printer implements USB {
@Override
public void start() {
System.out.println("Printer start");
}
@Override
public void stop() {
System.out.println("Print stop");
}
}
class Computer{
public void transferData(USB usb){
usb.start();
System.out.println("transfer data");
usb.stop();
}
}
Nuevas características de la interfaz en jdk8, métodos estáticos, métodos predeterminados.
public interface CompareA {
//静态方法，public可省
public static void method1(){
System.out.println("compareA:北京");
}
//默认方法，public可省
public default void method2(){
System.out.println("compareB:上海");
}
default void method3(){
System.out.println("compareB:上海");
}
}
public class SubClassTest {
public static void main(String[] args) {
SubClass s = new SubClass();
//s.method1();
//1.接口中定义的静态方法，只能通过接口来调用。（为了消灭工具类）
CompareA.method1();
//2.通过实现类的对象，可以调用接口中的默认方法。
//如果实现类重写了接口中的默认方法，调用时，调用的是重写以后的方法。
s.method2();
s.method3();
//3. 如果子类（或实现类）继承了父类和实现的接口中声明的同名同参的方法。--> 类优先原则
//4. 如果实现类实现了多个接口，而这些接口中定义了同名同参的默认方法。
//那么在实现类中没有重写此方法的情况下，报错。-->接口冲突。
}
}
class SubClass implements CompareA {
@Override
public void method2() {
System.out.println("SubClass:上海");
}
//5. 如何在子类中调用接口中被重写的方法
public void myMethod(){
CompareA.super.method2();
}
}