接口

基本介绍：

接口就是给出一些没有实现的方法，封装到以一起，到某个类要使用的时候再根据具体情况把这些方法写出来。

语法：

interface 接口名 {
    //属性
    //方法(1.抽象方法		2.默认实现方法	3.静态方法)
}

class 类名 implements 接口{
    自己属性;
    自己方法;
    必须实现的接口的抽象方法;
}

小结：

在JDK7.0以前，接口中的方法都没有方法体，即都是抽象方法；；

JDK8以后接口可以右静态方法，默认方法，也就是说接口中可以有方法的具体实现；

package com.example.interface_.interface02;

/**
 * @author gaoqinghui
 * @date 2022/4/29 13:36
 */
public class Interface02 {
    public static void main(String[] args) {
        A a = new A();
        a.hi();
        a.ok();
        AInterface.cry();
    }
}

//1.如果一个类implements实现接口
//2.需要将该接口的所有抽象方法都实现
class A implements AInterface {
    @Override
    public void hi() {
        System.out.println("hi~~");
    }

}


    
//下面是在接口中的定义

package com.example.interface_.interface02;

/**
 * @author gaoqinghui
 * @date 2022/4/29 13:36
 */
public interface AInterface {

    //写属性；
    public int n1 = 10;

    //写方法
    //在接口中，抽象方法可以省略abstract关键字，写不写都是抽象方法
    public void hi();

    //在jdk8后可以有默认实现方法,需要使用default关键字修饰
    default public void ok(){
        System.out.println("ok~~");
    }

    //jdk8后可以有静态方法
    public static void cry(){
        System.out.println("cry");
    }
}

接口的注意事项和使用细节：

接口不能被实例化；

接口中所有的方法是public方法，接口中抽象方法，可以不用abstract来修饰，也就是说接口中的所有定义都是抽象的，默认会有public abstract；

一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用快捷键；

抽象类去实现接口时，可以不实现接口的抽象方法；

一个类同时可以实现多个接口；

接口中的属性只能是final的，而且是public static final 修饰符。

比如：int a = 1;实际上是public static final int a = 1;(必须初始化)

接口中属性的访问形式：接口名.属性名；

一个接口不能继承其他的类，但是可以继承多个别的接口,interface A extends B,C {};

接口的修饰符，只能是public和默认，这点和类的修饰符是一样的；

代码实例：

package com.example.interface_.InterfaceDetail;

public class InterfaceDetail01 {
    public static void main(String[] args) {
        
    }
}

interface IA {
     void say();
    void hi();
}

class Cat implements IA {
    @Override
    public void say() {
        
    }

    @Override
    public void hi() {

    }
}

abstract class Dog implements IA {
    
}

示例：

package com.example.interface_.interfacedetail02;

/**
 * @author gaoqinghui
 * @date 2022/4/29 23:49
 * 1. 一个类同时可以实现多个接口；
 * 2. 接口中的属性只能是final的，而且是public static final 修饰符。
 * 3. 接口中属性的访问形式：接口名.属性名；
 * 4. 一个接口不能继承其他的类，但是可以继承多个别的接口,interface A extends B,C {};
 * 5. 接口的修饰符，只能是public和默认，这点和类的修饰符是一样的；
 */
public class InterfaceDetail02 {
    public static void main(String[] args) {
        //接口中的属性只能是final的，而且是public static final 修饰符。
        System.out.println(IB.n1);
        //IB.n1 = 100;  错误，因为是final，不能赋值；
    }
}


interface IB {
    int n1 = 10;//接口中的属性只能是final的，而且是public static final 修饰符。
    void hi();
}
interface IC {
    void ok();
}
interface ID extends IC,IB{

}
class pig implements IC,IB { //一个类同时可以实现多个接口；
    @Override
    public void hi() {

    }

    @Override
    public void ok() {

    }
}

接口和继承的区别

接口和继承解决的问题不同

继承的价值主要在于：解决代码的复用性和可维护性；

接口的价值主要在于：设计，设计好各种规范(方法),让其他类去实现这些方法。即更加的灵活

接口比继承更加灵活
接口比继承更加灵活，继承需要满足is-a的关系，接口需要满足like-a的关系；

接口在一定程度上实现了代码解耦(即：接口规范性+动态绑定机制)

当子类继承父类，就自动拥有父类的功能
如果子类需要扩展功能，可以通过实现接口的方式扩展
可以理解：实现接口是对Java单继承机制的一种补充

抽象类和接口的异同

	抽象类(abstract class)	接口(interface)
定义	包含抽象方法的类	主要是抽象方法和静态常量的类
组成	构造器抽象方法普通成员方法、成员变量静态方法、静态变量常量	静态常量抽象方法 default方法、静态方法(java8) 私有方法(java9)
使用	子类继承抽象类(extends)	子类实现接口(implements)
关系	子类只能继承一个抽象类抽象类可以实现多个接口	子类可以实现多个接口接口不能继承类，但可以继承多个接口
选择	如果需要继承父类的成员变量，或者需要控制子类的实例化，就用抽象类	优先选择接口，避免单继承的局限

接口的多态特性

多态参数 interfacePolyParameter.java

接口引用可以指向实现了接口的类的对象

package com.example.interface_.interfacePolyParameter;

/**
 * @author gaoqinghui
 * @date 2022/4/30 18:45
 */
public class interfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量ia可以指向已经实现了IA接口类的对象示例
        IA ia = new AA();
        ia = new BB();

        //继承体现的多态
        //父类类型的变量aaa可以指向继承了AAA子类的对象实例
        AAA aaa = new BBB();
        aaa = new CCC();
    }
}

interface IA {}

class AA implements IA {}
class BB implements IA {}

class AAA {}
class BBB extends AAA{}
class CCC extends AAA{}

多态数组

package com.example.interface_.interfacePolyArr;



/**
 * @author gaoqinghui
 * @date 2022/4/30 18:57
 */
public class interfacePolyArr {
    public static void main(String[] args) {
        //多态数组 ->接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone();
        usbs[1] = new Camera();
        /**
         * 给Usb数组中存放Phone和Camera对象，Phone类还有一个特有的方法call()
         * 请遍历Usb数组，如果是Phone对象，除了调用Usb接口定义的方法外
         * 还需要调用Phone特有方法call
         */
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].working();  //动态绑定机制
            if(usbs[i] instanceof Phone){   //判断运行类型
                ((Phone) usbs[i]).call();   //向下转型
            }
        }
    }
    
    
    
}

interface Usb {
    public void working();
}

class Phone implements Usb{
    public void working(){
        System.out.println("手机正在使用中...");
    }
    public void call(){
        System.out.println("手机正在打电话");
    }
}

class Camera implements Usb{
    public void working(){
        System.out.println("相机正在使用中....");
    }
}

接口存在多态传递现象

package com.example.interface_.interfacePolyPass;

/**
 * @author gaoqinghui
 * @date 2022/4/30 19:15
 */
public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向实现了该接口的类的对象实例；
        IG ig = new Student();
        //如果IG继承了IH接口，而Student类也实现了IG接口
        //那么实际上就相当于Student类也实现了IH这个接口
        //这就是所谓的接口多态传递
        IH ih = new Student();
    }
}

interface IH {
    public void hi();
}
interface IG extends IH{}

class Student implements IG {
    @Override
    public void hi() {

    }
}

posted @ 2022-05-10 17:53 忧愁小松鼠阅读(72) 评论(0) 收藏举报

刷新页面返回顶部

忧愁小松鼠

接口

接口和继承的区别

抽象类和接口的异同

接口的多态特性

公告