6.12、面向对象接口

生活中大家每天都在用 USB 接口，那么 USB 接口与我们今天要学习的接口有什
么相同点呢？

在Java程序设计中的接口

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须
能…”的思想。继承是一个"是不是"的 is-a 关系，而接口实现则是 "能不能"的
has-a 关系

引用数据类型：数组，类，枚举，接口，注解。

2 接口格式

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编
译成.class 文件，但一定要明确它并不是类，而是另外一种引用数据类型。

3 接口的特点:

通过interface关键字来定义接口
通过implements让子类来实现接口
接口中的方法全部都是抽象方法(JAVA8)
可以把接口理解成一个特殊的抽象类(但接口不是类!!!)，接口不能被实例化；
类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
接口突破了java单继承的局限性
接口和类之间可以多实现,接口与接口之间可以多继承
接口是对外暴露的规则,是一套开发规范
接口提高了程序的功能拓展,降低了耦合性

注意：类是可以实现多个接口的，这叫做接口的多实现。并且，一个类只能继承一个父类，但是可以实现多个接口。

1.【修饰符】 class 实现类 implements 接口 1，接口 2，接口 3。。。{ }

一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法

【修饰符】 class 实现类 extends 父类 implements 接口{
// 重写接口中抽象方法【必须】，
当然如果实现类是抽象类，那么可以不重写
// 重写接口中默认方法【可选】
}

4.1 练习-1:创建接口（抽象方法）

创建包: cn.tedu.inter
创建接口:Inter.java

package cn.tedu.inter;
/*本接口用于创建接口测试*/
/*1.我们通过interface关键字来定义接口*/
public interface Inter {
    /*2.接口中可以定义普通方法吗？--不可以！*/
    //public void eat(){}
    /*3.接口中可以定义抽象方法吗？--可以，接口中的方法都是抽象方法！*/
    public abstract void eat();
    public abstract void play();
}

4.2 练习-2:创建接口实现类

创建包: cn.tedu.inter
创建接口实现类:InterImpl.java

package cn.tedu.inter;
/*本类作为Inter接口的实现类*/
/*1.实现类如果想要实现接口定义的功能，需要与接口建立实现关系
* 通过关键字implements来建立实现类 实现 接口的关系*/
/*2.1 方案一：如果实现类与接口建立实现关系以后
可以选择不实现接口中的抽象方法，把自己变成一个抽象类*/
//abstract public class InterImpl implements Inter{//方案一
/*2.2方法二：如果实现类与接口建立实现关系以后
* 还可以选择实现接口中的所有抽象方法，把自己变成一个普通子类*/
public class InterImpl implements Inter{
    @Override
    public void eat() {
        System.out.println("吃火锅");
    }
    @Override
    public void play() {
        System.out.println("玩代码");
    }
}

4.3 练习-3:创建接口测试类

创建包: cn.tedu.inter
创建接口测试类:InterTests.java

package cn.tedu.inter;
/*本类用于运行测试接口实现类*/
public class InterTests {
    public static void main(String[] args) {
        /*接口可以实例化吗？--不可以！！！*/
        //Inter i = new Inter();

        //创建多态对象进行测试--不常用
        Inter i = new InterImpl();
        i.eat();
        i.play();

        //创建纯纯的接口实现类对象进行测试--推荐使用
        InterImpl i2 = new InterImpl();
        i2.eat();
        i2.play();
    }
}

5.2 练习: 接口之成员变量

package cn.tedu.inter2;
/*本类用于进一步测试接口的使用*/
public class TestUserInter {
    public static void main(String[] args) {
        //6.测试接口中的静态常量
        System.out.println(UserInter.age);//静态，因为可以被接口名直接调用
        //UserInter.age = 37;//final,因为值不可以被修改
    }
}
//1.创建接口
interface UserInter{
    //5.测试接口中是否可以定义成员变量
    /*4.接口中的是静态常量，实际上的写法是public static final int age = 20;
    * 只不过接口中可以省略不写，会默认拼接，所以写成 int age = 20;也可以*/
    public static final int age = 20;
}
//3.创建接口的实现类
class UserInterImpl implements UserInter{
  
}

总结:接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final

5.3 练习: 接口之成员方法

package cn.tedu.inter2;
/*本类用于进一步测试接口的使用*/
public class TestUserInter {
    public static void main(String[] args) {
       UserInterImpl u = new UserInterImpl();
        u.eat();
        u.play();
    }
}
//1.创建接口
interface UserInter{
    //7.测试接口中有抽象方法吗？
    /*5.接口中抽象方法的定义可以简写，会自动给方法拼接public abstract*/
    public abstract void eat();
    void play();
}
//3.创建接口的实现类
class UserInterImpl implements UserInter{
    @Override
    public void eat() {
		System.out.println("实现接口中的抽象方法1");	
    }
    @Override
    public void play() {
		System.out.println("实现接口中的抽象方法2");
    }
}

7 接口的多继承多实现

创建包: cn.tedu.inter2
创建类:TestRelation.java

package cn.tedu.inner2;

import cn.tedu.inter.Inter;

/*本类用于测试接口与类之间的复杂关系*/
public class TestRelation {
    public static void main(String[] args) {
        //创建对象进行功能测试
        Inter3Impl i = new Inter3Impl();
        i.save();
        i.delete();
        i.update();
        i.find();
    }
}

//1.创建接口1
interface Inter1{
    void save();//保存功能
    void delete();//删除功能
}
//2.创建接口22
interface Inter22{
    void update();//更新功能
    void find();//查询功能
}
//3.创建接口1的实现类
class Inter1Impl implements Inter1{
    @Override
    public void save() { }
    @Override
    public void delete() { }
}

//4.创建接口3,同时继承两个接口
/*1.接口可以继承接口，并且可以多继承，多个接口之间用逗号隔开*/
interface Inter3 extends Inter1,Inter22{ }

//5.创建接口3的实现类
/*2.接口与实现类是实现的关系，并且可以多实现，多个接口之间用逗号隔开
* 对于Java中的类而言，遵循：单继承 多实现
* 一个类只能有一个父类，但是一个类可以实现多个接口*/
//class Inter3Impl implements Inter3{//写法1
class Inter3Impl implements Inter1,Inter22{//写法2
    @Override
    public void save() {
        System.out.println("稍等...正在努力保存中...");
    }
    @Override
    public void delete() {
        System.out.println("删除成功！");
    }
    @Override
    public void update() {
        System.out.println("小二正在马不停蹄的更新~");
    }
    @Override
    public void find() {
        System.out.println("客官，马上就查询好啦，稍等一丢丢~");
    }
}

接口冲突（左右为难）

• 当一个类同时实现了多个父接口，而多个父接口中包含方法签名相同的默认方法时，
怎么办呢？

2.1、如果想要选择保留其中一个，通过“接口名.super.方法名"的方法选择保留哪个接口的默认方法。
2、也可以选择两个同时保留；

代码案例实现

创建friend接口

package com.cy;

public class TestGirl {
    public static void main(String[] args) {
        Girl girl=new Girl();
        girl.date();
    }
}

创建BoyFriend接口

package com.cy;

public interface BoyFriend {

    default void date() {//约会
        System.out.println("神秘约会");
    }
}

1、如果想要选择保留其中一个，通过“接口名.super.方法名"的方法选择保留哪个接口的默认方法。
2、也可以选择两个同时保留；

创建实现类

package com.cy;

public class Girl implements Friend,BoyFriend{
    
    @Override
    public void date() {
 
     /**
         如果选择一个就只写一个方法即可
         如果选择两个则就写两个方法
    */
        Friend.super.date();
        BoyFriend.super.date();

         //还可以进行重写
        System.out.println("这是重写后的方法");
    }
}

创建测试类

package com.cy;
public class TestGirl {
    public static void main(String[] args) {
        Girl girl=new Girl();
        girl.date();
    }
}

面试题：接口和抽象类的区别