Java第十四天

一. 接口的基础语法：
1.接口也是一种"引用数据类型"。
2.接口是完全抽象的。（抽象类是半抽象的。）或者也可以说接口是特殊的抽象类。
3.接口怎么定义：

[修饰符列表] interface 接口名{}

4.接口支持多继承，一个接口可以继承多个接口。
5.接口中只有常量+抽象方法。
6.接口中所有的元素都是public修饰的。
7.接口中抽象方法的public abstract可以省略。
8.接口中常量的public static final可以省略。
9.接口中方法不能有方法体。
10.一个非抽象的类，实现接口的时候，必须将接口中所有的方法加以实现。
11.一个类可以实现多个接口。
12.extends和implements可以共存，extends在前，implements在后
13.使用接口，写代码的时候，可以使用多态（父类型引用指向子类型的对象）
样例1：接口中只有常量+抽象方法

public class Main {
    public static void main(String[] args) {
        //访问接口的常量
        //System.out.println(MyMath.PI);//3.1415926

        //常量能重新赋值么？
        //错误：无法为最终变量PI分配值
        //MyMath.PI=3.1415928;
    }
}
//定义接口
interface A{

}
//接口支持继承
interface B extends A{

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

}
//我的数学接口
interface MyMath{
    //常量
    //public static final double PI=3.1415926;
    double PI=3.1415926;

    //抽象方法
    //public abstract int sum(int a,int b);

    //接口当中既然都是抽象方法，那么在编写代码的时候，public abstract可以省略吗？可以
    int sum(int a,int b);

    //接口中的方法可以带有方法体吗？不可以
    //错误：接口抽象方法不能带有主体
    /*
    void doSome(){

    }
    */

    //相减的抽象方法
    int sub(int a,int b);
}

样例2：当一个非抽象的类实现接口的话，必须将抽象方法全部实现（覆盖、重写）

public class Main {
    public static void main(String[] args) {
        //错误：MyMath是抽象的; 无法实例化
        //new MyMath();

        //能使用多态吗？
        //Animal anm=new Cat();

        //父类型的引用指向子类型的对象
        MyMath a=new MyMathImpl();
        //调用接口里面的方法(面向接口编程)
        //编译时，静态绑定接口内的抽象方法
        //运行时，动态绑定子类的方法
        System.out.println(a.sum(2,1));//3
        System.out.println(a.sub(2,1));//1
    }
}
/*
接口的基础语法：
    1.类和类之间叫做继承，类和接口之间叫做实现。
    但是：仍然可以将实现看作"继承"。
    继承使用extends关键词完成。
    实现使用implements关键字完成。
    2.当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（重写/覆盖）。
*/
//特殊的抽象类，完全抽象的，叫做接口。
interface MyMath{
    //常量
    //public static final已省略
    double PI=3.1415926;

    //抽象方法
    //public abstract已省略
    int sum(int a,int b);
    int sub(int a,int b);
}

//这样没问题
/*
abstract class MyMathImpl implements MyMath{
}
*/

//编写一个类（这个类是一个非抽象的类）
//错误：MyMathImpl不是抽象的, 并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class MyMathImpl implements MyMath{
}
*/

//修正
class MyMathImpl implements MyMath{

    //错误：正在尝试分配更低的访问权限; 以前为public
    //访问权限只能更高，不能更低：private<无参
    /*
    int sum(int a,int b){
        return a+b;
    }
    */

    //重写/覆盖/实现 接口中的方法（通常叫做实现。）
    public int sum(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
}

样例3：类可以实现多个接口

/*
    1.接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？
        对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，
        一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....

    2.重点：一个类可以同时实现多个接口。
    这种机制弥补了Java中的哪个缺陷？
        Java中类和类只支持单继承，实际上单继承是为了简单而出现的，现实世界中
        存在多继承，Java中的接口弥补了单继承带来的缺陷。

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

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

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

        //直接向下转型为D可以吗？可以
        D d=(D)a;
        d.m2();//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 X{
}
interface Y{
}
interface Z extends X,Y{//接口和接口支持多继承
}

//-----------------------------------------------------

interface A{
    void m1();
}
interface B{
    void m2();
}
interface C{
    void m3();
}
//实现多个接口，其实就类似于多继承。
class D implements A,B,C{
    //实现A接口的m1()
    public void m1(){

    }
    //实现B接口的m2()
    public void m2(){
        System.out.println("m2....");
    }
    //实现C接口的m3()
    public void m3(){

    }
}

样例4：extends和implements可以共存，extends在前，implements在后

/*
    继承和实现都存在的话，代码应该怎么写？
    extends 关键字在前
    implements 关键词在后
*/
public class Main {
    public static void main(String[] args) {
        //创建对象
        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 Snack 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("努力的飞鱼");
    }
}

二.接口在开发中的作用：
1.注意：接口在开发中的作用，类似于多态在开发中的作用
2.多态：面向对象编程，不要面向具体编程。降低程序的耦合度，提高程序的扩展力。

/*
public class Master{
	public void feed(Dog d){
	
	}
	public void feed(Cat c){
	
	}
	//假设又要养其他的宠物，那么这个时候需要再加1个方法。
	//这样扩展力太差了，违背了OCP原则（对扩展开发，对修改关闭。）
}
*/
public class Master{
    public void feed(Animal a){
        //面向Animal父类编程，父类比子类更抽象。
        //所以我们叫做面向抽象编程，不要面向具体编程
        //这样程序的扩展力就强
    }
}

3.接口在开发中的作用？
接口是不是完全的？是。
而我们以后正好要求，面向抽象编程。
面向抽象编程这句话以后可以修改为：面向接口编程。
有了接口就有了可插拔。可插拔表示扩展里很强。不是焊接死的。
主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新
买一个换下来。这叫做高扩展性。（低耦合度。）
接口在现实世界中是不是到处都是呢？
usb接口
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的规范）
接口有什么用?
扩展性好，可插拔。
接口是一个抽象的概念。

分析：
中午要去饭馆吃饭，这个过程有接口吗？
接口是抽象的。
菜单是一个接口（菜单上有一个抽象的照片：西红柿炒鸡蛋）
谁面向接口调用。（顾客面向菜单点菜，调用接口。）
谁负责实现这个接口。（后台厨师负责把西红柿炒鸡蛋做好！是接口的实现者）
这个接口有什么用呢？
这个饭馆的菜单，让"顾客"和"后厨"解耦合了。
顾客不用找后厨，后厨不用找顾客，他们之间完全依靠这个抽象的菜单沟通。
总结一句话：三个字"解耦合"
1）面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP的开发原则。
2）接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）
3）接口可以解耦合，解开的是谁和谁的耦合？
任何一个接口都由调用者和实现者。（顾客、厨师）
接口可以将调用者和实现者解耦合。
调用者面向接口调用。
实现者面向接口编写实现。
例子：顾客与厨师之间通过接口"解耦合"
Main:

public class Main {
    public static void main(String[] args) {
        //创建厨师对象
        //FoodMenu cooker1=new ChinaCooker();
        FoodMenu cooker1=new AmericCooker();
        //创建顾客对象
        Customer customer=new Customer(cooker1);
        //顾客点菜
        customer.order();
    }
}

FoodMenu:

/*
    接口:菜单，抽象的
*/
public interface FoodMenu {

    //西红柿炒鸡蛋
    void shiZiChaoJiDan();

    //鱼香肉丝
    void yuXiangRouSi();

}

Customer:

//顾客
//调用菜单上的菜
//顾客是接口的调用者
public class Customer {
    //顾客手里有一个菜单
    //Customer has a FoodMenu!（意思:顾客有一个菜单）
    //记住：以后凡是能够使用 has a 来描述的，统一以属性的方式存在。
    //实例变量，属性
    //面向抽象编程，面向接口编程。降低程序的耦合性，提高程序的扩展力。
    private FoodMenu foodMenu;//都要养成封装的好习惯

   //如果以下这样写，就表示写死了（焊接了---没有可插拔了）
   //中餐厨师
   //ChinaCooker ac;
   //西餐厨师
   //AmericCooker ac;

   //构造方法
    public Customer(){
    }
    public Customer(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

   //setter and getter
    public FoodMenu getFoodMenu() {
        return foodMenu;
    }
    public void setFoodMenu(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

   //提供一个点菜的方法
    public void order(){
        //先拿到菜单才能点菜
        //调用get方法拿菜单
        //FoodMenu fm=this.getFoodMenu();
        //也可以不调用get方法拿菜单，因为在本类中私有的属性可以访问
        foodMenu.shiZiChaoJiDan();
        foodMenu.yuXiangRouSi();
    }
}
/*
    Cat is a Animal, 但凡满足 is a 的都表示可以设置为继承
    Customer has a FoodMenu, 但凡满足 has a 的都表示以属性的形式存在

*/

ChinaCooker:

//中餐厨师
//实现菜单上的菜
//厨师是接口的实现者
public class ChinaCooker implements FoodMenu{
    //西红柿炒鸡蛋
    public void shiZiChaoJiDan(){
        System.out.println("中餐厨师做的西红柿炒鸡蛋！");
    }

   //鱼香肉丝
    public void yuXiangRouSi(){
        System.out.println("中餐厨师做的鱼香肉丝！");
    }
}

AmericCooker:

//西餐厨师
//实现菜单上的菜
//厨师是接口的实现者
public class AmericCooker implements FoodMenu{
    //西红柿炒鸡蛋
    public void shiZiChaoJiDan(){
        System.out.println("西餐厨师做的西红柿炒鸡蛋！");
    }

    //鱼香肉丝
    public void yuXiangRouSi(){
        System.out.println("西餐厨师做的鱼香肉丝！");
    }
}

三. 类型和类型之间的关系：
is a（继承）、has a（关联）、 like a（实现）
1）is a：
Cat is a Animal（猫是一个动物）
凡是能够满足is a关系的表示"继承关系"

A extends B

2）has a：
I has a Pen（我有一支笔）
凡是能够满足has a关系的表示"关联关系"
关联关系通常以"属性"的形式存在。

A{
	B b;
}

3）like a：
Coker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示"实现关系"
实现关系通常是：类实现接口。

A implements B

四. 抽象类和接口有什么区别？
在这里我们只说一下抽象类和接口在语法上的区别。
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。

1)抽象类是半抽象的。
接口是完全抽象的。

2)抽象类中有构造方法。
接口中没有构造方法。

3)类和类直间只能单继承。
接口和接口之间支持多继承。

4)一个类可以同时实现多个接口。
一个抽象类只能继承一个类。（单继承）

5)接口中只允许出现常量和抽象方法。

小道消息：
以后接口使用的比抽象类多。一般抽象类使用的还是少。
接口一般都是对"行为"的抽象。

老杜！动力节点！