第一章：面向对象03

第一章：面向对象

接口

接口的注意事项：

• 在 java 中接口采用 interface 声明
• 接口中的方法默认都是 public abstract 的，不能更改
• 接口中的变量默认都是 public static final 类型的，不能更改，所以必须显示的初始化
• 接口不能被实例化，接口中没有构造函数的概念
• 接口之间可以继承，但接口之间不能实现
• 接口中的方法只能通过类来实现，通过implements 关键字
• 如果一个类实现了接口，那么接口中所有的方法必须实现
• 一个类可以实现多个接口

1. 接口的定义和实现

/*
	接口：
		1、接口也是一种“引用数据类型”。编译之后也是一个class字节码文件。
		2、接口是完全抽象的。（抽象类是半抽象。）或者也可以说接口是特殊的抽象类。
		3、接口怎么定义，语法是什么？
			[修饰符列表] interface 接口名{}
		4、接口支持多继承，一个接口可以继承多个接口。
		5、接口中只包含两部分内容，一部分是：常量。一部分是：抽象方法。接口中没有其它内容了。只有以上两部分。
		6、接口中所有的元素都是public修饰的。（都是公开的。）
		7、接口中的抽象方法定义时：public abstract修饰符可以省略。
		8、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。
		9、接口中的常量的public static final可以省略。
*/
public class Test01 {
    public static void main(String[] args) {

    }
}
//定义接口
interface A{}
//定义接口
interface B{}
//一个接口可以继承多个接口
interface C extends A,B{}

//我的数学接口
interface MyMath{
    //抽象方法
    //接口中的抽象方法定义时：public abstract修饰符可以省略。
    public abstract int sum(int a,int b);
    int sub(int a,int b);

    //接口中的常量的public static final可以省略。
    public static final double PI = 3.1415926523;
}

2. 当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现。

public class Test02 {
    public static void main(String[] args) {
        //错误: MyMath是抽象的; 无法实例化
        //new MyMath();
        MyMath1 mm = new MyMathImpl();
        // 调用接口里面的方法（面向接口编程。）
        int result1 = mm.sum(10, 20);
        System.out.println(result1);

        int result2 = mm.sub(20, 10);
        System.out.println(result2);
    }
}
interface MyMath1{
    double PI = 3.0141592653;
    int sum(int a,int b);
    int sub (int a ,int b);
}
class MyMathImpl implements MyMath1{

    @Override
    public int sum(int a, int b) {
        return a +b;
    }
    @Override
    public int sub(int a, int b) {
        return a - b;
    }
}

3. 一个类可以同时实现多个接口。

/*
	接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？

		对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，
		一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....


	重点（五颗星*****）：一个类可以同时实现多个接口。

	这种机制弥补了java中的哪个缺陷？
		java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中
		存在多继承，java中的接口弥补了单继承带来的缺陷。

	接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。
	编译器没意见。但是运行时可能出现：ClassCastException

	之前有一个结论：
		无论向上转型还是向下转型，两种类型之间必须要有继承关系，
		没有继承关系编译器会报错。（这句话不适用在接口方面。）
		最终实际上和之前还是一样，需要加：instanceof运算符进行判断。
		向下转型养成好习惯。转型之前先if+instanceof进行判断。
*/
public class Test03 {
    public static void main(String[] args) {
        // 多态该怎么用呢？
        // 都是父类型引用指向子类型对象
        AA a = new DD();
        //a.m2(); // 编译报错。A接口中没有m2()方法。
        BB b = new DD();
        CC c = new DD();

        // 这个编译没问题，运行也没问题。
        // 调用其他接口中的方法，你需要转型（接口转型。）
        BB b2 = (BB)a;
        b2.m2();

        // 直接向下转型为D可以吗？可以
        DD d = (DD)a;
        d.m2();

        M m = new E();
        // 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
        // 但是一定要注意，运行时可能会出现ClassCastException异常。
        // 编译没问题，运行有问题。
        //K k = (K)m;
        if(m instanceof K){
            K k = (K)m;
        }

    }

}
interface K{
}

interface M{
}

class E implements M{
}

// 特殊的抽象类，完全抽象的，叫做接口。
interface AA{
    void m1();
}
interface BB{
    void m2();
}
interface CC{
    void m3();
}

// 实现多个接口，其实就类似于多继承。
class DD implements AA,BB,CC{//接口和接口支持多继承。

    // 实现A接口的m1()
    public void m1(){

    }
    // 实现B接口中的m2()
    public void m2(){
    }
    // 实现接口C中的m3()
    public void m3(){
    }
}

4.继承和实现都存在的话，代码应该怎么写？

/*
	继承和实现都存在的话，代码应该怎么写？
		extends 关键字在前。
		implements 关键字在后。
*/

public class Test04 {
    public static void main(String[] args) {
        // 创建对象（表面看Animal类没起作用！）
        Flyable f = new Cat(); //多态。
        f.fly();

        // 同一个接口
        Flyable f2 = new Pig();
        // 调用同一个fly()方法，最后的执行效果不同。
        f2.fly();

        Flyable f3 = new Fish();
        f3.fly();
    }
}

// 动物类：父类
class Animal{
}

// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
    void fly();
}

// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
    public void fly(){
        System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
    }
}

// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class Snake extends Animal{
}

// 想飞就插翅膀这个接口。
class Pig extends Animal implements Flyable{
    public void fly(){
        System.out.println("我是一只会飞的猪！！！");
    }
}

// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{ //没写extends，也是有的，默认继承Object。
    public void fly(){
        System.out.println("我是六眼飞鱼（流言蜚语）！！！");
    }
}