黑马程序员技术交流社区

标题: 和大家分享下多态.抽象类和接口的一些笔记， [打印本页]

---

作者: yuguoqing    时间: 2015-7-1 22:36
标题: 和大家分享下多态.抽象类和接口的一些笔记，
1. 回顾
        1：继承是什么?继承的好处是什么?
                把多个类中的共性内容抽取出来,定义到一个父类中,
                其他的类继承自这个类,就可以使用这些共性的内容了.
                减少了代码的重复性, 提高了代码的可复用性.
                使类与类之间产生了一个关系,是多态的前提.
               
        2：Java中的继承特点是什么?
                子类不能使用父类私有的成员.
                只能单继承,但是支持多层继承.是为了避免多继承出现的调用不明确.

        3：看程序写结论。最好自己分析,先不要运行看结果。

        4：this和super分别是什么，他们各自的应用场景是什么?
                this是本类对象的引用 -- 在创建对象的同时,就会有一个this产生了.
                super是父类内存空间的标识(可以理解成父类对象的引用)
               
                变量:
                        this.变量名 -- 使用本类成员变量
                        super.变量名 -- 使用父类的成员变量
                成员方法:
                        this.方法名() -- 使用本类的方法
                        super.方法名() -- 使用父类的方法(经常用来在方法的重写中,
                        使用被覆盖掉的父类功能)
                构造方法:
                        this(具体参数) -- 根据参数匹配调用本类其他的构造
                        super(具体参数) -- 根据参数匹配调用父类的某个构造方法
                -- 子类对象的构造方法内部默认第一行都有一个语句: super();
                默认去调用了父类的无参构造.
                        作用: 为了初始化父类中的数据.
               
        5：什么是方法重写?需要注意哪些问题?
                子父类之间,出现子类的方法声明(返回值类型 \ 方法名 \ 参数列表)
                完全一致的情况.
                注意:
                        子类的方法访问权限必须大于等于父类的.
                        父类的私有方法不能被重写.
                        静态的方法只能被静态方法重写
                        final修饰的方法不能被重写.

        6：方法重写和重载有什么区别?
                方法重载：在同一个类中（这个是重点），出现方法名相同，
                参数列表不同的多个方法。与返回值类型无关。
                方法重写：在子父类间，
                出现方法声明完全相同（返回值类型、方法名、参数列表等）
                都相同的两个方法，称为重写。

        7：子父类中构造方法的执行有什么特点?为什么要这样?

        8：静态代码块，构造代码块，构造方法的执行顺序是什么?
                静态 -- 构造代码块 -- 构造方法
                静态代码块 只执行一次,
                但构造代码块和构造方法每次创建对象都会执行.

        9：final关键字是什么，可以干什么?分别是哪些特点?
                final
                修饰类 -- 不能被继承
                修饰方法 -- 不能被重写.
                修饰成员变量 -- 其实一个常量
               
        10. 介绍一个概念
                实例变量:
                        不加static修饰的成员变量
                类变量:
                        加了static修饰的成员变量
               
       
        11：分析如下需求，写出你分析的类有哪些，以及功能。
                最后写一个测试类，针对每个类的功能进行测试。

                动物园里有很多种动物：
                比如说，狗，猫等。
                狗有姓名和年龄，猫也有姓名和年龄。
                狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。
                狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。
                请用所学知识，对这个问题进行解决。
               
2. 多态
        概念: 对象在不同时刻表现出来的不同状态.
                java中的多态可以简单的记成: 父类子对象
        前提:
                1) 要有继承或者实现关系
                2) 要有方法的重写或者实现.
                3) 要有父类的引用指向子类的对象.
               
        多态间的成员特点：
        A:成员变量
                编译看左边,运行看左边。
        B:成员方法
                编译看左边,运行看右边。
                产生这种现象（运行时看的地方不一样）的原因就是：方法有重写。而变量没有。
                在多态中，父类引用其实指向的是一个子类对象，
                也就是说，真正干活或者说完成指定功能的子类对象，
                子类重写了该功能，对于该功能来说，他有区别于父类的实现，
                所以运行看右边（子类）。但是成员变量没有重写或者覆盖，也就是子类没有自己具体的实现，所以运行时还是看左边。
        多态的弊端:
                父类引用不能使用子类特有的功能.
               
                解决:
                        通过类型转换
                        向上转型 -- 隐式进行的
                        向下转型 -- 强制类型转换 -- 必须显示写明,
                        格式就是前面加一个括号,表示你想转成的类型.
               
                类型转换的时候会遇到一个异常:
                        ClassCastException -- 类型转换异常
                       
                        class Animal...
                        class Cat extends Animal ...
                        class Dog extends Animal ...
                       
                        Animal a = new Cat(); // 多态
                       
                        a = new Dog(); // 重新赋值
                       
                        Cat c = (Cat) a; // 类型转换异常
                       
                        向下转型必须转换成对象原本的类型.
               
               
                Animal a1 = new Cat(); // 多态
               
                Animal a2 = new Dog(); // 多态
               
                public void show(Animal a) { // 这接收Animal的任何一个子类都可以了.
                        a.show(); // 重写 -- 具体的方法调用的又是子类的.
                        a.eat();
                }
               
                多态的好处: 提高代码的扩展性和可维护性.
               
3. 抽象类
        概念:
                抽象方法:
                        只有方法声明，没有方法体的方法称为抽象方法。
                        用abstract关键字修饰。
                抽象类:
                        如果一个类中含有抽象方法，这个类就可以被称为抽象类。
                        该类也需要被abstract修饰。

        抽象类的特点:
                1) 抽象方法和抽象类,必须用abstract关键字修饰
                2) 抽象类中不一定有抽象方法,但是有抽象方法的类就必须是抽象类.
                3) 抽象类不可以被实例化. 要想实例化,必须使用具体的实现子类的对象.
                4) 子类继承自抽象类,要么子类继续抽象,
                要么就必须重写(实现)抽象类中的抽象方法.
               
                抽象类是要求子类必须实现某些功能.
               
        抽象类的成员特点:
                1:成员变量 可以有成员变量，也可以有常量。
                2:构造方法 有构造方法的。
                        既然不能被实例化，那么有构造方法有什么用?
                        可以用于子类访问父类数据前，对父类数据进行初始化。
                3:成员方法
                        可以有抽象方法，也可以有非抽象方法。
                        抽象方法是为了要求子类做某些事情。
                        非抽象方法是为了提高代码复用性，被子类继承。

        抽象关键字abstract不可以和哪些关键字共存？并说出为什么？
                不能和abstract共存的关键字都有：
                1.final：因为被final修饰的类不能被继承，被final修饰的方法不能被重写。
                2.private：因为被private修饰的方法不能重写，但是abstract方法要求重写。
                3.static：因为一个方法要是同时被static 和abstract修饰，
                那么这个方法就可以类名.方法名 调用. 但是此方法是抽象的,
                调用也无意义,所以就导致static 和abstract不能共存.

4. 接口:
        定义格式:
        interface 接口名
        {
       
        }
       
        实现类实现接口的格式:
        class 类名 implements 接口名
        {
                // 重写接口中的抽象方法
        }
       
        接口的基本特点:
       
                其实接口的基本特点可以仿照这抽象类的基本特点来总结，
        1). 接口不能被实例化
        2). 接口中的方法，要么在子类中被实现，要么子类中方法也是抽象类。

        接口的成员特点:
                接口中没有构造方法.
                接口中成员变量默认修饰符都是public static final ，所以只有成员常量
                接口中成员方法默认修饰符都是public abstract，所以只有抽象方法

        类与接口的关系:
                类与类:
                        继承关系, 单继承, 可以多层继承.
                类与接口:
                        实现关系, 可以单实现, 也可以多实现.
                        还可以在继承一个类的同时,实现多个接口.
                接口与接口的关系:
                        继承关系. 可以单继承, 也可以多继承.
               
        所有类都直接或者间接的继承自Object类，而且Object类只提供了无参构造。
                情况一：如果其他类直接继承Object类
                并且假设构造方法默认调用父类的带参构造的话，
                会因为Object类没有带参构造而出错。
                情况二：如果A类继承于B类，如果B类没有手动定义构造方法，
                系统会默认提供一个无参构造，
                假设构造方法默认调用父类的带参构造的话，
                A类调用B类的带参构造，B类没有，也是会报错的
                但是调用B的无参构造就没有问题。
                       
        接口的思想特点:
                对外暴露的规则
                程序的功能扩展
                降低耦合性
                多实现
       
        抽象类与接口的区别:
                成员特点:
                        抽象类:
        1:成员变量 可以有成员变量，也可以有常量。
        2:构造方法 有构造方法的。
                        既然不能被实例化，那么有构造方法有什么用?
                        可以用于子类访问父类数据前，对父类数据进行初始化。
                        3:成员方法
                                可以有抽象方法，也可以有非抽象方法。
                                抽象方法是为了要求子类做某些事情。
                                非抽象方法是为了提高代码复用性，被子类继承。
                接口:
                        接口中没有构造方法.
                        接口中成员变量默认修饰符都是public static final
                        所以只有成员常量
                        接口中成员方法默认修饰符都是public abstract，
                        所以只有抽象方法
                               
        关系特点:
                类与类:
                        继承关系, 单继承, 可以多层继承.
                类与接口:
                        实现关系, 可以单实现, 也可以多实现.
                        还可以在继承一个类的同时,实现多个接口.
                接口与接口的关系:
                        继承关系. 可以单继承, 也可以多继承.
               
        思想区别:
                抽象类是体系的共性内容的向上抽取, 体现的是 is a 的关系.
                接口体现的是体系的扩展功能, 体现的是 like a 的关系.
                       

---

作者: zhou330667146    时间: 2015-7-1 22:37
写的很详细，学习了，赞一个

---

作者: yuguoqing    时间: 2015-7-1 22:38
哈哈哈，活到老学到老:lol

---

作者: jiatengde    时间: 2015-7-1 22:41
顶，楼主写的不错，总结的很详细和清楚，谢谢了！

---

作者: yuguoqing    时间: 2015-7-1 22:43

jiatengde 发表于 2015-7-1 22:41
顶，楼主写的不错，总结的很详细和清楚，谢谢了！

有帮助就好

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2