Java入门 第十节（二）接口

接口 1. 概述

• 首先，接口并不是类，但是可以把它看做 抽象类 的延伸，是一个纯粹的抽象类。
• 其次，接口属于一个规范，一旦定义不要轻易改动。{如：电脑接口各种各样插口}
• 最后，java不允许类多继承，所以如果要实现多个类的功能，则可以通过实现多个接口。

1.1 语法定义

• 定义接口的方式和类一样，也有关键字，但不是class ，而是关键字 interface；

interface 接口命名 {  
	// 主体代码 
	code...  
}

2. 接口特点

1. 类的定义是class，接口的定义interface。
2. 类是继承 extends，接口是实现 implement 。
3. 接口无法被实例化。只能由子类去实现。
4. 类和接口之间是可以多实现。 接口和接口之间可以多继承。
5. 接口中的方法都是抽象方法。（注：在Java8新特性之后，default 默认方法）。

2.1 创建接口

• 接口中的抽象方法，默认是abstract 修饰的，且所有权限都是public，也可以省略。

public interface Inter {

    // 1.接口中的定义和抽象类中定义抽象方法一样。方法都是public可以写或者不写
    abstract  void drink();
    //2.接口中的修饰符 abstract  关键字可以省略不写，默认就是abstract
    void eat();

    //3.接口中可以定义普通方法么？
    default public void method(){
        System.out.println("java1.8之后我可以写非抽象方法，但必须用defaul修饰");
    }
}

2.2 接口实现类和测试

• 关键字 implement 。实现类，必须重写接口中的抽象方法。

/**
 * 由子类实现接口，必须重写接口中的抽象方法，default默认方法可以不重写！
 */
public class Ziimpl implements Inter{
    @Override
    public void drink() {
        System.out.println("我很挑，只喝H₂O！");
    }

    @Override
    public void eat() {
        System.out.println("吃饭我随便");
    }
}

• InterFaceDemo 测试类，测试接口

/**
 * 接口测试类
 */
public class InterFaceDemo {
    public static void main(String[] args) {

      //提问： 接口可以实例化么？
      //new Inter();  报错因为接口和抽象类一样。不可以实例化。

        // 直接new实现类对象即可！
        Zi zi = new Zi();
        zi.drink();
        zi.eat();
        zi.method();
    }
}

3. 接口的用法 3.1 成员变量

• 接口中变量修饰 默认public static final 。

//定义接口
public interface Inter {
    /*
        接口中的定义 默认 public static final 修饰，可以省略。
            所以final用法？修饰的变量就是常量。
     */
    public static final String name ="I'M 常量";
    int num=10; // 默认public static final 修饰
}


//接口实现类
class Ziimpl implements Inter{

}

//测试接口中成员变量
class InterDemo{
    public static void main(String[] args) {
        /*
            1.接口中的变量，默认隐式修饰 public static final修饰。
            所以 static 静态可以直接，用类名获取！
            2. 也可以创建实现类的实例对象，来测试！
         */
        // Ziimpl.name="常量能改么！？";  //final 修饰的变量无法修改！

        System.out.println(Ziimpl.name);
    }
}

3.2 构造方法

• 构造方法，两个比较重要的作用 “给成员变量初始化值” 和 “创建对象”；

//定义接口
public interface Inter {
    /*
        1.接口中的定义 默认 public static final 修饰，可以省略。
            所以final用法？修饰的变量就是常量。
     */
    public static final String name ="I'M 常量";
    int num=10; // 默认public static final 修饰

    /**
     * 2.构造方法：与类名相同 无返回值的方法；
     */
     // public Inter(){ } // 小红线报错！？为什么
}


//接口实现类
class Ziimpl implements Inter{

    /**2.1 实现类构造函数调用的是谁的构造方法！？
     */
    public Ziimpl(){
        super(); //调用的是顶级 父类 Object 中的构造方法；
        System.out.println("我是接口的实现类");
    }
}

//测试接口中成员变量
class InterDemo{
    public static void main(String[] args) {
        /*
            接口中的变量，默认隐式修饰 public static final修饰。
            所以 static 静态可以直接，用类名获取！
         */
        // Ziimpl.name="常量能改么！？";  //final 修饰的变量无法修改！

        System.out.println(Ziimpl.name);


        //2.2 创建实现类对象
        new Ziimpl();
    }
}

输出结果：

I'M 常量
我是接口的实现类

总结： 说一说，你自己理解的， 为什么接口中没有构造方法！？

4. 案例： 面向接口编程案例–车

• 分析： 车有启动和停止的功能。 车的动力： 有人力，汽油，电。
• 如：两轮车，你给它汽油就是摩托车，你给它电，就是电动自行车，如果只有人力，就是自行车。

-思考： 如果后期有，喇叭这个功能。应该怎么去做！？

public class JiaoTongToolsDemo {
    public static void main(String[] args) {
        //测试一下摩托车
        MotorCycle m = new MotorCycle();
        m.setName("摩托车");

        System.out.println(m.getName());
        m.go();
        m.stop();
        m.oil();

        //测试一下新国标电动车
        Bicycle b = new Bicycle();
        b.setName("电动自行车");
        System.out.println(b.getName());
        b.go();
        b.power();
        b.electric();
        b.stop();
    }
}

/**
 * 定义车为抽象类
 */
abstract class Che{
    private String name; //车的名字

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //启动
    abstract public void go();
    //停止
    abstract public void stop();
}

//定义动力接口
interface Power1{
    void oil();
}
interface Power2{
    void electric();
}
interface Power3{
    void power();
}

/**
 * 后期有新加装的功能，设计成动作接口，这样谁来都可以使用！
 */
interface  rings{
    void sound();
}

/**
 * 摩托车
 */
class MotorCycle extends Che implements Power1{

    @Override
    public void oil() {
        System.out.println("加92汽油");
    }
    @Override
    public void go() {
        System.out.println("一键启动");
    }
    @Override
    public void stop() {
        System.out.println("手刹");
    }
}

/**
 * 2021年10月1日 新国标开始 需要电动自行车加脚蹬子。
 */
class Bicycle extends Che implements Power2,Power3{
    @Override
    public void electric() {
        System.out.println("我可以充电跑");
    }

    @Override
    public void power() {
        System.out.println("我可以用脚蹬");
    }

    @Override
    public void go() {
        System.out.println("脚蹬和一键启动");
    }

    @Override
    public void stop() {
        System.out.println("手刹，脚刹");
    }
}

输出结果：

摩托车
一键启动
手刹
加92汽油
电动自行车
脚蹬和一键启动
我可以用脚蹬
我可以充电跑
手刹，脚刹

5. 知识点扩展 5.1 接口和类的关系

1. 类与类：继承关系，一个类只能继承一个父类，支持多重继承
   class A ; class A extends B{} ; class B extends C{}
2. 类和接口：只有实现关系，一个类可以实现多个接口。
   class A implement B,C,D{}
3. 接口和接口： 只有继承关系，一个接口可以继承多个接口。
   interface A extends B ,C ,D{}

5.2 接口和抽象类的区别（面试题）

1. 定义类型：
   a.接口定义类型 interface
   b.抽象类定义类型 class

2. 成员变量：
   a.接口中默认修饰public static final 就是常量；
   b.抽象类中，可以有成员变量，也可以有常量。

3. 方法：
   a.接口中的方法都是抽象方法 {有默认方法default修饰。也有静态方法（静态方法必须有方法体）}
   b. 抽象类中没有限制。

4. 构造方法：
   a. 接口中没有构造方法；不可以实例化。
   b. 抽象类中有构造方法（用于子类实例化使用）；不可以实例化。

5. 设计思想：
   a.抽象类，这对的这个对象是什么？（强调对象本身）
   b.接口，这个能干什么（强调动作）。

5.3 老吴浅谈：什么时候用接口？什么时候用抽象类？

1. 首先二者都是设计思想，都是不可以被实例化，且都属于 “抽象层面” ，抽象类更倾向于说明对象的本质，具有相同的属性和行为，如人类，动物类，一系列。而接口更偏向于动作规范 ，如：USB接口， 删除，增加，修改，查询等。
2. 如果设计时，包含的公共代码很多，关系比较密切，可以优先考虑抽象类。如果要考虑后期代码的扩展性和维护性时，可以优先考虑使用接口。
   例如：
     A:大鱼，后来发现海参可以吃，男足也吃海参，就可以把“吃海参” 设计成一个接口。便于扩展。最后狗也可以吃海参，直接实现就可以！ 三个对象没有任何联系，只是有吃海参这样的事情。
     B:谷爱凌喜欢吃馅饼，中国女足喜欢吃面条，可以抽取共同 属性和行为 形成抽象类，二者联系紧密，都是中国人，都喜欢吃中国美食，都为国家争光。
3. 原则：如果要设计小而简练的功能块，则使用接口。如果要设计大的功能单元，则使用抽象类。