自学java （day22）：接口

/**
 *  接口在开发中的作用：
 *      接口在开发中的作用类似于多态的作用
 *          多态的作用：面向抽象编程，降低程序的耦合度，提高程序的扩展力，，多态的实现是在继承的基础上的
 *
 *          接口在开发中的作用：
 *              接口是完全抽象的
 *              我们以后正好面向抽象编程
 *              面向抽象编程这句话可以修改为面向接口编程
 *              有了接口就有了可插拔，可插拔表示扩展力很强，不是死的，比较活，
 *              主板和内存条之间有插槽，插槽就是接口，内存条坏了可以买一个换下来，这叫做高扩展性，低耦合度
 *         接口的使用离不开多态。。。。。。。。。。
 *     接口可以解耦合，解的是谁和谁的耦合？？？、
 *          任何一个接口都有调用者和实现者
 *          接口可以将调用者和实现者解耦合
 *          调用者面向接口调用
 *          实现者面向接口实现
 *         */

/**
 * 抽象类和接口的区别？
 *      语法上的区别：
     *      抽象类是半抽象的
     *      接口是完全抽象的
     *
     *      抽象类中有构造方法
     *      接口中没有构造方法
     *
     *      接口和接口之间支持多继承
     *      类和类之间只支持单继承
     *
     *      一个抽象类只能继承一个类（单继承）
     *      一个类可以同时实现多个接口
     *
     *      接口中只允许出现常量和抽象方法
     *
     *      以后接口使用的比抽象类多，一般抽象类使用的少
     *      接口一般都是对“行为”的抽象
 */

public class Test01 {
    public static void main(String[] args){
        //创建厨师对象
        FoodMeun cooker1=new ChinaCooker();
        FoodMeun cooker2=new AmericCooker();

        //创建顾客对象
        Customer customer1=new Customer(cooker1);
        Customer customer2=new Customer(cooker2);

        //顾客点菜
        customer1.order();
        customer2.order();
    }
}
/**---------------------------------------------------菜单接口-----------------------------------------------------*/
//菜单接口
interface FoodMeun{
    //西红柿炒鸡蛋
    void  shizichaojidan();
    //鱼香肉丝
    void  yvxiangrousi();
}
/**----------------------------------------------------顾客类------------------------------------------------------*/
//顾客类
class Customer{
    //顾客手里有一个菜单
    //实例变量，属性
    private FoodMeun foodMeun;//要养成封装的好习惯

    //构造方法
    public Customer() {
    }

    public Customer(FoodMeun foodMeun) {
        this.foodMeun = foodMeun;
    }

    public FoodMeun getFoodMeun() {
        return foodMeun;
    }

    public void setFoodMeun(FoodMeun foodMeun) {
        this.foodMeun = foodMeun;
    }

    //提供一个点菜的方法
    public void order(){
        foodMeun.shizichaojidan();
        foodMeun.yvxiangrousi();
    }
}

/**------------------------------------------------------厨师类----------------------------------------------------*/

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

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

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

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

/**
 *  接口：
 *      1、接口也是一种"引用数据类型"
 *      2、接口是完全抽象的，（接口类是半抽象的），或者说接口是特殊的抽象类
 *      3、接口怎么定义呢？语法是什么？
 *          接口：
 *          【修饰符列表】 interface 接口名{
 *          }
 *          定义类：
 *          【修饰符列表】 class 类名{
 *          }
 *          定义抽象类：
 *          【修饰符列表】 abstract class 抽象类名{
 *          }
 *      4、接口支持多继承，一个接口可以继承多个接口
 *      5、接口中只包含两部分内容，一部分是：常量，一部分是：抽象方法。接口中没有其他内容了，只有这两部分
 *      6、接口中所有的元素都是“public”修饰的。（都是公开的）
 *      7、接口中抽象方法定义时：public abstract修饰符可以省略
 *      8、接口中的方法都说抽象方法，所以接口中的方法不能有方法体，，，，，抽象方法没有方法体
 *      9、接口中：常量前的public static final也是可以省略的，如果不写，系统会自己给你默认加上
 */

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

        //访问接口的常量
        System.out.println(MyMath.PI);

        //常量能修改吗？能重新赋值吗？
        /**
         MyMath.PI=3.14;//答案是不可以修改的，不能重新赋值
         */

    }
}

//定义接口
interface A{

}

//定义接口
interface B{

}

//定义接口：一个接口可以继承多个接口，支持多继承
interface C extends A,B{

}

//定义我的数学接口
interface MyMath{

    //常量
    //public static final double PI=3.1415926;

    double PI=3.1415926;//抽象方法前的public abstract可以省略，常量前的public static final也是可以省略的

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

    //接口中既然都是抽象方法，那么public abstract可以省略吗？
    int sum(int a,int b);//答案是没有问题

    //接口中的方法可以带有方法体吗？
    /**
    void doSome(){  }//答案是：不可以的
     */

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

/**
 *  接口的基础语法：
 *      1、类和类之间叫做继承，类和接口之间叫实现（也可以叫继承）
 *          --继承使用extends关键字完成
 *          --实现使用implements关键字完成
 *      2、当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现/覆盖/重写
 */

public class QuBie {
    public static void main(String[] args){
        //使用多态
        //父类型的引用指向子类型的对象
        MyMath mm=new MyMathImp();
        //调用接口里的方法（面向接口编程）
        System.out.println(mm.sum(9,6));
        System.out.println(mm.sub(9,6));
    }
}

//我的数学接口
//特殊的抽象类，完全抽象的，叫接口
interface MyMath{
    double PI=3.1415926;
    int sum(int a,int b);
    //相减的抽象方法
    int sub(int a,int b);
}

//这样写是没有问题的
/*
abstract class MyMathImp implements MyMath{

}
 */

//编写一个类（这个类是非抽象的类）

//class MyMathImp implements MyMath{  }//错误：MyMathImp不是抽象的, 并且未覆盖Test02.MyMath中的抽象方法sub(int,int)

//修正
class MyMathImp implements MyMath{

    double PI=3.1415926;

    //重写/覆盖/实现接口中的方法
    //相加的抽象方法
    public int sum(int a,int b){
        return a+b;
    }
    //相减的抽象方法
    public int sub(int a,int b){
        return a-b;
    }
}

/**
 *  接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？
 *
 *  重点：******：：一个类可以实现多个接口
 *  这种机制弥补了java中的那个缺陷？？
 *      --java中的类和类之间只支持单继承，实际上单继承是为了简单而出现的，现实世界中存在多继承，java中的多继承弥补了单继承带来的缺陷
 *
 */

public class JieKou {
    public static void main(String[] args){
        //使用多态
        //父类型的引用指向子类型的对象
        A a=new D();
        B b=new D();
        C c=new D();
        a.m1();
        //向下转型（强制转换）
        B b2=(B)a;
        b2.m2();
    }
}

//接口
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(){

    }

}

---------------------------------------------------------------------------------------------------------------------------------

/**
 *  继承（extends）和实现（implements）都存在的话，代码应该怎么写？？
 *      extends关键字在前，implements关键字在后
 */
public class extendsANDimplements {
    public static void main(String[] args){
        //创建对象
        Cat c=new Cat();
        c.fly();
        Flyable f=new Cat();//多态
        f.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{

}