【java基础】第十条总结-->重要

class Study{/*传智播客的老师有基础班的，也有就业班的。 共性属性：姓名，年龄功能：讲课。  现在又要针对日语这种小语种单独开班，需要部分基础班老师和部分就业班老师会说日语。  请用所学知识把上面的内容用代码体现。*/public static void main(String []args){BaseTeacher t = new BaseTeacher();t.sexName("李三");System.out.println(t.gexName());t.teark();t.speak();BaseTeacher t1 = new BaseTeacher("程思思",18);System.out.println(t1.gexName());}}abstract class Teacher//抽象类{public abstract void teark();//父类的抽象方法}class BaseTeacher extends Teacher implements Japan//这里先创建一个基础班的老师，继承Teacher类实现Japan接口{private String name;//私有化，提供封装private int age; public BaseTeacher(String name,int age)//有参构造{this.name = name;this.age = age;}public BaseTeacher(){}//无参构造public void teark() {//有参构造System.out.println("上课了");}//对象的封装 public void sexName(String name) { this.name = name; } public String gexName() { return name; } public void sexAge(int age) { this.age = age; } public int gexAge() { return age; }public void speak(){System.out.println("上日语课了");}}interface Japan//这里是说日语的接口{public void speak();} 

                                                                                                      总结

掌握形，而不是神。

形似不用神似。

理解多态概念

1:多态(掌握)
    (1)同一个对象在不同时刻表现出来的不同状态。
        另外的表达方式：针对同一个对象，编译期类型和运行期类型不一致。
        举例：
            狗(狗是狗,狗是动物)
            水(水，水蒸气，冰)
    (2)前提：
        A:有继承或者实现关系。
        B:有方法重写。
        C:有父类或者接口引用指向子类或者实现类对象。
    (3)好处和弊端：
        A:好处
            扩展性和维护性(是由继承和实现保证)。
        B:弊端
            不能使用子类的特有功能。
    (4)向上转型和向下转型
        A:向上转型
            把子类对象赋值给父类或者接口引用
            子类转型成父类（通常为自动转换）
            方法参数父类类型，直接给子类实例对象
            方法返回值类型为父类类型，可以返回其子类对象
        B:向下转型
            把父类或者父接口引用强制转换为子类
            出现多态后，这个对象new的本身是子类，在向下转型时，可以强制转换。
    (5)多态中的使用成员特点
        A:成员变量
            编译运行都看左边
        B:成员方法
            编译看左边，运行看右边。

        全部看使用的变量类型，只是在调用该方法时，检查子类是否重写。

        
    (6)多态的体现形式
        A:具体类多态(几乎不用)
        B:抽象类多态
        C:接口多态



    多态：
        某一类事物的多种存在形态。

        前提：有类似继承这样的类与类之间的关系

        代码体现：
            Zi extends Fu
            Fu fu = new Zi();

        成员访问特点：
            成员变量：
                编译时，看父类
                运行时，看父类
            成员方法：
                编译时，看父类
                运行时，看子类
        
        当出现多态时，一切均看父类引用的数据类型
        只有在调用方法时，才看子类有没有重写，如果子类重写，就调用重写后的方法

        多态体现：父类的引用指向子类的实例对象
        多态好处：多态的存在提高了程序的扩展性和后期可维护性
        多态缺点：父类本身的方法无法被调用
                  子类的成员变量以及子类的特有方法无法被访问或者调用

2:抽象类(掌握)
    (1)多个具体的事物具备相同的方法声明，而方法体不同，我们就只抽取方法声明，然后定义到一个类中。
       而一个没有方法体的方法是一个抽象方法，一个类中有抽象方法，该类必须定义为抽象类。
    (2)抽象类的特点：
        A:抽象类或者抽象方法用abstract修饰。
        B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
        C:抽象类不能被实例化。
        D:子类继承抽象类，要么是抽象类，要么重写所有父类抽象方法。
    (3)抽象类的几个小问题
        A:不能被实例化，要构造方法干啥?//必须实现抽象的功能，否则不让其实例化。必须具备一定的功能。
        B:一个类中没有抽象方法，居然定义抽象类，有什么意义?
        C:抽象关键字不能和哪些关键字共存
            a:private
            b:final
            c:static
    (4)抽象类的成员：
        A:成员变量 有变量，也有常量
        B:构造方法 有构造方法，用于子类访问父类数据的初始化
        C:成员方法 有抽象方法，也有非抽象的方法


    抽象类：
        包含抽象方法的类一定是抽象类
        抽象类不一定有抽象方法

    抽象方法：
        Java中可以定义没有方法体的方法，这样的方法就是抽象方法。抽象方法没有大括号，但是后边有;
    
    抽象类与抽象方法必须使用abstract修饰

    抽象类特点：
        抽象类不可以被实例化,只能通过其子类实例化。
        抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。
        抽象类强制子类必须实现抽象方法。
    
    注意事项：
        没有抽象方法的类，可以是抽象类.
        没有方法的类，可以是抽象类.

    多态一般出现在抽象类的继承以及接口的实现

    抽象类包含构造方法，用来给属性初始化的

3:接口(掌握)
    (1)当一个抽象类中的方法都是抽象的时候，java就提供了一种更抽象的表达方式，叫接口。
    (2)接口的成员特点：
        A:成员变量 是常量 默认修饰符 public static final
        B:成员方法 抽象方法 默认修饰符 public abstract
    (3)接口的特点：
        A:接口用interface定义
        B:实现类实现接口用implements标识
        C:接口不能被实例化
        D:子类实现接口的时候，要么是抽象类，要么全部实现接口方法
    (4)接口和类的关系
        A:类与类的关系
            继承关系,只能单继承，可以多层继承。
        B:类与接口的关系
            实现关系，可以单实现，也可以多实现。
            还可以在继承一个类的同时，实现多个接口。
        class A extends B implements C，D

        C:接口与接口的关系
            继承关系，可以单继承，也可以多继承。
    (5)接口的思想特点(理解)
        A:对外暴露的规则
        B:程序的扩展功能(多态)
        C:降低程序的耦合性(多态)
        D:让类可以多实现
        数据交换的规则
        比抽象类更抽象，全部为抽象方法
        格式：
            定义接口：interface XX {}
        使用接口：class YY implements XX{}

    接口中的成员有固定修饰符：
        成员常量：public static final 数据类型 常量名(AAA_BBB) = 值;
        成员方法：public abstract methodName(参数列表);
        特点：
        类单继承类
        类多实现接口
        接口多继承接口
            
    (6)接口和抽象类的区别
        共性：都是不断抽取出来的抽象的内容。

        A:成员特点
            抽象类：
                成员变量 可以变量，也可以常量
                成员方法 可以抽象，也可以非抽象
                构造方法 有
            接口：
                成员变量 只能是常量
                成员方法 只能是抽象
                构造方法 无
        B:继承或者实现关系特点
            a:类与类的关系
                继承关系,只能单继承，可以多层继承。
            b:类与接口的关系
                实现关系，可以单实现，也可以多实现。
                还可以在继承一个类的同时，实现多个接口。
            c:接口与接口的关系
                继承关系，可以单继承，也可以多继承。
        C:设计区别
            抽象类中定义的是体系的共性内容。表达的是：is a的关系。
            接口中定义的是体系的扩展功能。表达的是：like a的关系。

        
    (7)如何实现一个继承体系
        分析：由具体到抽象
        实现：由抽象到具体
        学习：抽象的内容,因为它定义的是共性内容。

        使用：具体的内容,因为它才是具体实现，才具体更多的功能。

文章中所牵扯的一切均来自传智播客。欢迎交流。。。QQ：904198612