1.接口
        跟接口相关的两个角色。
                接口本身。 (接口)
                使用接口的使用者。(实现类)
       
        概述：
                针对于接口来讲，我就是对外提供了一种规则，谁实现了我，就必须要遵守我的规则。
               
                针对于实现类来讲，我实现了一个接口，就相当于额外拥有了一种功能。



2.接口格式
        a,接口的定义格式
                        interface 接口名
        b,接口的使用格式
                        class 实现类 implements 接口名{
                        }

        c,注意点
                实现类去实现一个接口，需要实现里面"所有"的抽象方法。



3.接口的成员特点
        Object 类：是Java中所有类的根类。
                                如果一个类没有写继承关系，默认认为他继承于Object类。
                                Object类是所有类直接或者间接父类。所有的类都可以使用Object类中的方法。

       
        接口中的成员的特点
                构造方法       
                        接口中是没有构造方法

                成员变量
                        默认使用 public static final 修饰。
                        就算不写，虚拟机也默认帮你加上。

                成员方法
                        在JDK7(包括)以前，接口里面只能有抽象方法。
                        默认用 public abstract 修饰，
                        就算不写，虚拟机也默认帮你加上。


4，接口在实际使用中的方式。

        针对于接口来讲，我就是对外提供了一种规则，谁实现了我，就必须要遵守我的规则。
        针对于实现类来讲，我实现了一个接口，就相当于额外拥有了一种功能。


案例：
        需求：
                现在找了个女朋友，会撒娇，每个女朋友撒娇的方式是不一样的。
                //林志玲   //韩红

                子类特有的功能
                        掰手腕的功能
                       


        class 女朋友{
                public abstract void 撒娇();

                //public abstract void 掰手腕();
                //不能写在父类中，因为如果写在了父类中，子类会强制拥有这个功能。现在的这个业务逻辑中是不合理的。
        }


        //此时如果把掰手腕作为一个特有的功能写在子类中，但是会有一个小弊端
        //无法控制子类一定是按照某种要求进行书写。(方法名，返回值，参数列表)

        interface 掰手腕{
                //你想要让哪个类拥有掰手腕的功能，就让这个类实现对应的接口就可以了。
                //接口更加的灵活。
                public abstract void 掰手腕();
        }       

       
        class 林志玲 extends 女朋友{

                @Override
                public void 撒娇(){
                        System.out.println("嘤嘤嘤的撒娇");
                }
        }

        class 韩红 extends 女朋友 implements 掰手腕{

                @Override
                public void 撒娇(){
                        System.out.println("嘎哈样的撒娇");
                }

                @Override
                public void 掰手腕(){
                        System.out.println("正在掰手腕");
                }
        }

        class 贾玲 extends 女朋友 implements 掰手腕{
               
                @Override
                public void 撒娇(){
                        System.out.println("别逼逼的撒娇");
                }

                @Override
                public void 掰手腕(){
                        System.out.println("正在掰手腕");
                }
        }

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


英雄联盟

class 英雄{

        //因为每一个英雄都有QWER这样的技能，但是每一个技能都是不一样的。
        public abstract void Q();
        public abstract void W();
        public abstract void E();
        public abstract void R();

        //public abstract void 真实伤害();
        //如果把真实伤害写在父类中，那么每一个子类都拥有这样的功能。
        //而我们想要的是：部分英雄拥有这样的功能。
}


interface 真实伤害{
        //我想要谁拥有真实伤害的功能，我就让谁实现这个接口就可以了。
        //而且我还能保证，每一个实现类书写的格式完全一致。
        public abstract void 真实伤害();
}



class Gay伦 extends 英雄 implements 真实伤害{
       
        @Override
        public void Q(){
                System.out.println("闭嘴");
        }

        @Override
        public void W(){
                System.out.println("...");
        }

        @Override
        public void E(){
                System.out.println("...");
        }

        @Override
        public void R(){
                System.out.println("大宝剑");
        }

        @Override
        public void 真实伤害(){
                System.out.println("真实伤害");
        }
}


class 快乐风男 extends 英雄{
       
        @Override
        public void Q(){
                System.out.println("...");
        }

        @Override
        public void W(){
                System.out.println("...");
        }

        @Override
        public void E(){
                System.out.println("...");
        }

        @Override
        public void R(){
                System.out.println("...");
        }
}

总结：
        继承：所有子类的共性。
        接口：额外的功能。而且拥有这样功能的子类有多个，我们想要让这些子类都按照同样的规则进行书写。




5.类和接口的关系
        相同的之间是继承关系。
                        //类跟类之间  接口跟接口

        不同的之前是实现关系。
                        //类可以实现接口。

        引申：
                a,类跟类之间的继承只能单继承，不能多继承。但是可以多层继承。

                class 爹1{
                        public void eat(){"米饭"}
                }

                class 爹2{
                        public void eat(){"面条"}
                }
               
                class 儿子 extends 爹1,爹2{
                }
               
                创建儿子的对象，去调用eat方法，不知道是调用爹1的还是调用爹2的，所以虚拟机就懵逼了
                那么这种写法是错误的。



                b,接口跟接口之间可以单继承，也可以多继承。
                原因：接口里面的方法都是抽象方法，没有方法体。



                c,类跟接口之间
                        一个类可以实现多个接口。
                        在这个类中需要把多个接口中"所有"的抽象方法全部实现(重写)。

1.接口
        跟接口相关的两个角色。
                接口本身。 (接口)
                使用接口的使用者。(实现类)
       
        概述：
                针对于接口来讲，我就是对外提供了一种规则，谁实现了我，就必须要遵守我的规则。
               
                针对于实现类来讲，我实现了一个接口，就相当于额外拥有了一种功能。



2.接口格式
        a,接口的定义格式
                        interface 接口名
        b,接口的使用格式
                        class 实现类 implements 接口名{
                        }

        c,注意点
                实现类去实现一个接口，需要实现里面"所有"的抽象方法。



3.接口的成员特点
        Object 类：是Java中所有类的根类。
                                如果一个类没有写继承关系，默认认为他继承于Object类。
                                Object类是所有类直接或者间接父类。所有的类都可以使用Object类中的方法。

       
        接口中的成员的特点
                构造方法       
                        接口中是没有构造方法

                成员变量
                        默认使用 public static final 修饰。
                        就算不写，虚拟机也默认帮你加上。

                成员方法
                        在JDK7(包括)以前，接口里面只能有抽象方法。
                        默认用 public abstract 修饰，
                        就算不写，虚拟机也默认帮你加上。


4，接口在实际使用中的方式。

        针对于接口来讲，我就是对外提供了一种规则，谁实现了我，就必须要遵守我的规则。
        针对于实现类来讲，我实现了一个接口，就相当于额外拥有了一种功能。


案例：
        需求：
                现在找了个女朋友，会撒娇，每个女朋友撒娇的方式是不一样的。
                //林志玲   //韩红

                子类特有的功能
                        掰手腕的功能
                       


        class 女朋友{
                public abstract void 撒娇();

                //public abstract void 掰手腕();
                //不能写在父类中，因为如果写在了父类中，子类会强制拥有这个功能。现在的这个业务逻辑中是不合理的。
        }


        //此时如果把掰手腕作为一个特有的功能写在子类中，但是会有一个小弊端
        //无法控制子类一定是按照某种要求进行书写。(方法名，返回值，参数列表)

        interface 掰手腕{
                //你想要让哪个类拥有掰手腕的功能，就让这个类实现对应的接口就可以了。
                //接口更加的灵活。
                public abstract void 掰手腕();
        }       

       
        class 林志玲 extends 女朋友{

                @Override
                public void 撒娇(){
                        System.out.println("嘤嘤嘤的撒娇");
                }
        }

        class 韩红 extends 女朋友 implements 掰手腕{

                @Override
                public void 撒娇(){
                        System.out.println("嘎哈样的撒娇");
                }

                @Override
                public void 掰手腕(){
                        System.out.println("正在掰手腕");
                }
        }

        class 贾玲 extends 女朋友 implements 掰手腕{
               
                @Override
                public void 撒娇(){
                        System.out.println("别逼逼的撒娇");
                }

                @Override
                public void 掰手腕(){
                        System.out.println("正在掰手腕");
                }
        }

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


英雄联盟

class 英雄{

        //因为每一个英雄都有QWER这样的技能，但是每一个技能都是不一样的。
        public abstract void Q();
        public abstract void W();
        public abstract void E();
        public abstract void R();

        //public abstract void 真实伤害();
        //如果把真实伤害写在父类中，那么每一个子类都拥有这样的功能。
        //而我们想要的是：部分英雄拥有这样的功能。
}


interface 真实伤害{
        //我想要谁拥有真实伤害的功能，我就让谁实现这个接口就可以了。
        //而且我还能保证，每一个实现类书写的格式完全一致。
        public abstract void 真实伤害();
}



class Gay伦 extends 英雄 implements 真实伤害{
       
        @Override
        public void Q(){
                System.out.println("闭嘴");
        }

        @Override
        public void W(){
                System.out.println("...");
        }

        @Override
        public void E(){
                System.out.println("...");
        }

        @Override
        public void R(){
                System.out.println("大宝剑");
        }

        @Override
        public void 真实伤害(){
                System.out.println("真实伤害");
        }
}


class 快乐风男 extends 英雄{
       
        @Override
        public void Q(){
                System.out.println("...");
        }

        @Override
        public void W(){
                System.out.println("...");
        }

        @Override
        public void E(){
                System.out.println("...");
        }

        @Override
        public void R(){
                System.out.println("...");
        }
}

总结：
        继承：所有子类的共性。
        接口：额外的功能。而且拥有这样功能的子类有多个，我们想要让这些子类都按照同样的规则进行书写。




5.类和接口的关系
        相同的之间是继承关系。
                        //类跟类之间  接口跟接口

        不同的之前是实现关系。
                        //类可以实现接口。

        引申：
                a,类跟类之间的继承只能单继承，不能多继承。但是可以多层继承。

                class 爹1{
                        public void eat(){"米饭"}
                }

                class 爹2{
                        public void eat(){"面条"}
                }
               
                class 儿子 extends 爹1,爹2{
                }
               
                创建儿子的对象，去调用eat方法，不知道是调用爹1的还是调用爹2的，所以虚拟机就懵逼了
                那么这种写法是错误的。



                b,接口跟接口之间可以单继承，也可以多继承。
                原因：接口里面的方法都是抽象方法，没有方法体。



                c,类跟接口之间
                        一个类可以实现多个接口。
                        在这个类中需要把多个接口中"所有"的抽象方法全部实现(重写)。