黑马程序员--面向对象（day06）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1:final关键字(掌握)
           (1)是最终的意思，可以修饰类，方法，变量。
           (2)特点：
                   A:它修饰的类，不能被继承。
                   B:它修饰的方法，不能被重写。
                   C:它修饰的变量，是一个常量。
           (3)面试相关：
                    A:局部变量
                            a:基本类型 值不能发生改变
                            b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
                    B:初始化时机
                            a:只能初始化一次。
                            b:常见的给值
                                   定义的时候。(推荐)
                                   构造方法中。

2:多态(掌握)
           (1)同一个对象在不同时刻体现出来的不同状态。
           (2)多态的前提：
                   A:有继承或者实现关系。
                   B:有方法重写。
                   C:有父类或者父接口引用指向子类对象。

          多态的分类：
                   a:具体类多态
                          class Fu {}
                          class Zi extends Fu {}

                          Fu f = new Zi();
                   b:抽象类多态
                          abstract class Fu {}
                          class Zi extends Fu {}

                          Fu f = new Zi();
                   c:接口多态
                          interface Fu {}
                          class Zi implements Fu {}

                          Fu f = new Zi();
           (3)多态中的成员访问特点
                   A:成员变量
                          编译看左边，运行看左边
                   B:构造方法
                          子类的构造都会默认访问父类构造
                   C:成员方法
                          编译看左边，运行看右边
                   D:静态方法
                          编译看左边，运行看左边
                  为什么?
                          因为成员方法有重写。
          (4)多态的好处：
                   A:提高代码的维护性(继承体现)
                   B:提高代码的扩展性(多态体现)
          (5)多态的弊端：
                  父不能使用子的特有功能。
          现象：
                  子可以当作父使用，父不能当作子使用。
         (6)多态中的转型
                  A:向上转型
                         从子到父
                  B:向下转型
                         从父到子
         (7)孔子装爹的案例帮助理解多态
         (8)多态的练习
                 A:猫狗案例
                 B:老师和学生案例


3:抽象类(掌握)
        (1)把多个共性的东西提取到一个类中，这是继承的做法。
        但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
        也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
        所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
        而一个没有具体的方法体的方法是抽象的方法。
        在一个类中如果有抽象方法，该类必须定义为抽象类。
        (2)抽象类的特点
                 A:抽象类和抽象方法必须用关键字abstract修饰
                 B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
                 C:抽象类不能实例化
                 D:抽象类的子类
                         a:是一个抽象类。
                         b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
       (3)抽象类的成员特点：
                 A:成员变量
                        有变量，有常量
                 B:构造方法
                         有构造方法
                 C:成员方法
                         有抽象，有非抽象
       (4)抽象类的练习
                 A:猫狗案例练习
                 B:老师案例练习
                 C:学生案例练习
                 D:员工案例练习
        (5)抽象类的几个小问题
                 A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
                          用于子类访问父类数据的初始化
                 B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
                          为了不让创建对象
                 C:abstract不能和哪些关键字共存
                           a:final冲突
                           b:private 冲突
                           c:static 无意义


4:接口(掌握)
         (1)回顾猫狗案例，它们仅仅提供一些基本功能。
                  比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
                  是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
         (2)接口的特点：
                   A:接口用关键字interface修饰
                            interface 接口名 {}
                   B:类实现接口用implements修饰
                            class 类名 implements 接口名 {}
                   C:接口不能实例化
                   D:接口的实现类
                            a:是一个抽象类。
                            b:是一个具体类，这个类必须重写接口中的所有抽象方法。
          (3)接口的成员特点：
                   A:成员变量
                           只能是常量
                           默认修饰符：public static final
                   B:构造方法
                            没有构造方法
                   C:成员方法
                            只能是抽象的
                            默认修饰符：public abstract
          (4)类与类,类与接口,接口与接口
                    A:类与类
                            继承关系，只能单继承，可以多层继承
                    B:类与接口
                            实现关系，可以单实现，也可以多实现。
                            还可以在继承一个类的同时，实现多个接口
                   C:接口与接口
                            继承关系，可以单继承，也可以多继承
           (5)抽象类和接口的区别 
                    A:成员区别

           (1)是最终的意思，可以修饰类，方法，变量。
           (2)特点：
                   A:它修饰的类，不能被继承。
                   B:它修饰的方法，不能被重写。
                   C:它修饰的变量，是一个常量。
           (3)面试相关：
                    A:局部变量
                            a:基本类型 值不能发生改变
                            b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
                    B:初始化时机
                            a:只能初始化一次。
                            b:常见的给值
                                   定义的时候。(推荐)
                                   构造方法中。

2:多态(掌握)
           (1)同一个对象在不同时刻体现出来的不同状态。
           (2)多态的前提：
                   A:有继承或者实现关系。
                   B:有方法重写。
                   C:有父类或者父接口引用指向子类对象。

          多态的分类：
                   a:具体类多态
                          class Fu {}
                          class Zi extends Fu {}

                          Fu f = new Zi();
                   b:抽象类多态
                          abstract class Fu {}
                          class Zi extends Fu {}

                          Fu f = new Zi();
                   c:接口多态
                          interface Fu {}
                          class Zi implements Fu {}

                          Fu f = new Zi();
           (3)多态中的成员访问特点
                   A:成员变量
                          编译看左边，运行看左边
                   B:构造方法
                          子类的构造都会默认访问父类构造
                   C:成员方法
                          编译看左边，运行看右边
                   D:静态方法
                          编译看左边，运行看左边
                  为什么?
                          因为成员方法有重写。
          (4)多态的好处：
                   A:提高代码的维护性(继承体现)
                   B:提高代码的扩展性(多态体现)
          (5)多态的弊端：
                  父不能使用子的特有功能。
          现象：
                  子可以当作父使用，父不能当作子使用。
         (6)多态中的转型
                  A:向上转型
                         从子到父
                  B:向下转型
                         从父到子
         (7)孔子装爹的案例帮助理解多态
         (8)多态的练习
                 A:猫狗案例
                 B:老师和学生案例


3:抽象类(掌握)
        (1)把多个共性的东西提取到一个类中，这是继承的做法。
        但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
        也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
        所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
        而一个没有具体的方法体的方法是抽象的方法。
        在一个类中如果有抽象方法，该类必须定义为抽象类。
        (2)抽象类的特点
                 A:抽象类和抽象方法必须用关键字abstract修饰
                 B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
                 C:抽象类不能实例化
                 D:抽象类的子类
                         a:是一个抽象类。
                         b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
       (3)抽象类的成员特点：
                 A:成员变量
                        有变量，有常量
                 B:构造方法
                         有构造方法
                 C:成员方法
                         有抽象，有非抽象
       (4)抽象类的练习
                 A:猫狗案例练习
                 B:老师案例练习
                 C:学生案例练习
                 D:员工案例练习
        (5)抽象类的几个小问题
                 A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
                          用于子类访问父类数据的初始化
                 B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
                          为了不让创建对象
                 C:abstract不能和哪些关键字共存
                           a:final冲突
                           b:private 冲突
                           c:static 无意义


4:接口(掌握)
         (1)回顾猫狗案例，它们仅仅提供一些基本功能。
                  比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
                  是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
         (2)接口的特点：
                   A:接口用关键字interface修饰
                            interface 接口名 {}
                   B:类实现接口用implements修饰
                            class 类名 implements 接口名 {}
                   C:接口不能实例化
                   D:接口的实现类
                            a:是一个抽象类。
                            b:是一个具体类，这个类必须重写接口中的所有抽象方法。
          (3)接口的成员特点：
                   A:成员变量
                           只能是常量
                           默认修饰符：public static final
                   B:构造方法
                            没有构造方法
                   C:成员方法
                            只能是抽象的
                            默认修饰符：public abstract
          (4)类与类,类与接口,接口与接口
                    A:类与类
                            继承关系，只能单继承，可以多层继承
                    B:类与接口
                            实现关系，可以单实现，也可以多实现。
                            还可以在继承一个类的同时，实现多个接口
                   C:接口与接口
                            继承关系，可以单继承，也可以多继承
           (5)抽象类和接口的区别 
                    A:成员区别

                           抽象类：

                                  成员变量：可以是常量也可以是变量

                                                         构造方法：有构造方法

                                  成员方法：有抽象，有非抽象

                            接口：

                                  成员变量：只能是常量

                                  构造方法：没有构造方法

                                  成员方法：只能是抽象的

                    B:关系区别:
                             类与类：继承关系 单继承 可以多继承
                             类与接口：实现关系 可以单实现 也可以多实现 也可在继承某个类的时候实现多继承
                             接口与接口：继承关系 单继承 可以
                     C:设计理念不同
                             抽象类：is a，抽象类中定义的是共性功能。
                              接口：like a，接口中定义的是扩展功能。
           (6)练习：
                     A:猫狗案例，加入跳高功能
                     B:老师和学生案例，加入抽烟功能0