interfaz de notas javaSE

　　Las interfaces no pueden crear objetos, pero pueden implementarse (`implements`, similar a ser heredado). Una clase que implementa una interfaz (puede considerarse como una subclase de la interfaz) necesita implementar todos los métodos abstractos en la interfaz, crear un objeto de esta clase y luego llamar al método, de lo contrario debe ser una clase abstracta.

 

Interfaz: es una colección de funciones (todos los métodos definidos en la interfaz)

El archivo .java también se usa para definir la interfaz; el archivo .class también se genera por compilación

Definir la interfaz usando la interfaz de palabras clave

Nombre de la interfaz de la interfaz del modificador {

 　　Método abstracto;

 　　Método predeterminado; (recién agregado después de JDK8)

　　 Método estático; (recién agregado después de JDK8)

}

 

Uso de la interfaz:

　  1. La interfaz no puede crear objetos para usar

　　2. Puede definir una clase de implementación, implementar (heredar) la interfaz, reescribir los métodos abstractos en la interfaz, crear un objeto de clase de implementación para usar

 

Método abstracto: sin cuerpo del método, método modificado por resumen

　　El modificador predeterminado resumen público puede omitirse

 　　nombre de método (parámetro) de valor de retorno de resumen público;

 

　　　　Nota:
　　　　　　El modificador de método abstracto en la interfaz puede omitirse y no escribirse, y el valor predeterminado también es resumen público

　　　　　　Sugerir escritura para mejorar la legibilidad

public  interface MyInter {
     // define el método abstracto 
    public  abstract  void show01 (); 

    public  abstract  int show02 (); 

    void show03 (String s); 
}

 

　　Definir la clase de implementación de la interfaz.

　　　　Usar formato: use la clase para implementar la interfaz y reescribir el método abstracto en la interfaz

　　　　　　La clase pública implementa el nombre de la clase implementa la interfaz {

　　　　　　　　Reescribir métodos abstractos en la interfaz;

　　　　　　}

　　　　Nota:

　　　　　　La implementación es similar a la herencia. Las clases implementan interfaces y pueden heredar todos los miembros no privados de la interfaz

public  class MyInterImpl implementa MyInter { 
    @Override 
    public  void show01 () { 
        System.out.println ( "¡La clase de implementación anula el método abstracto show01 en la interfaz!" ); 
    } 

    @Override 
    public  int show02 () { 
        System.out.println ( "¡Implemente el método abstracto show02 en la interfaz de reescritura de interfaz!" );
         Devuelva 0 ; 
    } 

    @Override 
    public  void show03 (String s) { 
        System.out.println ( "¡Implemente la clase reescriba el método abstracto show03 en la interfaz!" + S ); 
    } 
}

 

 

public class Demo01MyInter {
    public static void main(String[] args) {
        //接口不能创建对象使用 'MyInter' is abstract; cannot be instantiated
        //MyInter mi = new MyInter();

        //创建接口的实现类对象
        MyInterImpl my = new MyInterImpl();
        my.show01();
        my.show02();
        my.show03("赵四");
    }
}

 

 

默认方法

　　　　定义格式:

　　　　　　修饰符 default 返回值类型 方法名(参数){

　　　　　　　　方法体;

　　　　　　}

 

　　　　　　注意:

　　　　　　　　默认方法的修饰符default不能省略

public interface MyInter {
    public default void show01(){
        System.out.println("MyInter接口中的默认show01方法");
    }

    public default  void show02(){
        System.out.println("MyInter接口中的默认show02方法");
    }
}

 

 

1. 1. 含有默认方法的接口的使用:定义实现类,实现接口,选择性的重写默认方法,创建实现类对象使用
   2. 重写了默认方法:使用实现类重写后的方法
   3. 没有重写默认方法:使用继承自接口中的默认方法

　　　　注意:

　　　　　　实现类重写接口中的默认方法,去掉default修饰符

 

public class MyInterImpl implements MyInter{
    @Override
    public void show01() {
        System.out.println("实现类重写了MyInter接口中的show01默认方法");
    }
}

 

 

public class Demo01MyInter {
    public static void main(String[] args) {
       //创建接口的实现类对象
        MyInterImpl my = new MyInterImpl();
        my.show01();//实现类重写的
        my.show02();//继承自接口的
    }
}

 

 

静态方法

　　　　定义格式:

　　　　　　修饰符 static 返回值类型 方法名(参数){

　　　　　　　　方法体

　　　　　　}

　　　　　　注意:

• • • • 定义静态方法不能省略static关键字
      • 定义含有静态方法的接口使用:
      • 静态成员属于类(接口),所以可以通过接口名.方法名(参数)直接使用

 

public interface MyInter {
    public static void show01(){
        System.out.println("MyInter接口的静态show01方法");
    }

    public static String show02(int a){
        System.out.println("MyInter接口的静态show01方法"+a);
        return "哈哈";
    }
}

 

 

public class MyInterImpl implements MyInter{
    //@Override//Method does not override method from its superclass
    public static void show01(){
        System.out.println("MyInterImpl类的静态show01方法");
    }
}

 

 

　　　　静态方法只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用

　　　　静态方法是不能重写的,属于类|接口本身,也不能被实现类继承使用。在实现类中定义了静态方法,属于实现类本身

public class Demo01MyInter {
    public static void main(String[] args) {
        //通过接口名.方法名(参数)调用接口中的静态方法
        MyInter.show01();
        String s = MyInter.show02(10);
        System.out.println(s);

        MyInterImpl.show01();
    }
}

 

 

接口的多实现

　　语法

　　　　class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {

　　　　　　// 重写接口中抽象方法【必须】

　　　　　　// 重写接口中默认方法【不重名时可选】

　　　　}

 

　　抽象方法

　　　　接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果多个接口中抽象方法有重名的，只需要重写一次。

 

　　默认方法

　　　　接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

 

　　静态方法

　　　　接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

 

　　优先级的问题

　　　　当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

 

接口的多继承

• 接口的继承使用 `extends` 关键字，子接口继承父接口的方法。如果多个父接口中的默认方法有重名的，那么子接口需要重写一次
• 子接口重写默认方法时，default关键字可以保留。
• 子类重写默认方法时，default关键字不可以保留。

 

其他成员的特点

　　- 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。

　　- 接口中，没有构造方法，不能创建对象。

　　- 接口中，没有静态代码块。

 

抽象类和接口

• 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口, 接口弥补了Java的单继承
• ​抽象类为继承体系中的共性内容, 接口为继承体系中的扩展功能