黑马程序员技术交流社区

标题: 继承多态小总结 [打印本页]
作者: Anlai    时间: 2015-8-24 13:05
标题: 继承多态小总结
代码块
                概述: 在java中使用{}括起来的内容
                分类:        局部代码块 , 构造代码块 , 静态代码块 , 同步代码块(多线程)
               
                局部代码块:        位置在方法定义中
                构造代码块: 位置在类中方法外 , 特点: 每创建一次对象都调用一次 , 并且优先于构造方法执行
                静态代码块:        位置在类中方法外 , 前面添加一个static        特点: 随着类的加载而加载,只执行一次 ,优先于构造代码块
        继承

                格式:        class 子类名 extends 父类名 {}
                好处:
                        (1): 提高了代码的复用性
                        (2): 提高了代码的维护性
                        (3): 让类与类产生了关系,是多态的前提
                弊端:
                        让类与类产生了关系,增强了耦合性
               
                特点:
                        (1): 只能是单继承 ,不能是多继承
                        (2): 可以使用多层继承
                注意事项:
                        (1): 父类中私有的成员不能被子类继承
                        (2): 父类中的构造方法不能被子类继承,但是可以通过super去访问
                        (3): 不能为了部分功能去使用继承
               
                继承中成员变量的访问特点:
                        变量在访问的时候遵循一个"就近原则"
                        查找顺序:
                                (1): 在子类的局部位置
                                (2): 在子类成员位置
                                (3): 在父类的成员位置找
                                (4): 报错

                this和super的区别:
                        this: 表示是本类对象的一个引用,谁调用我this就代表谁
                        super:表示的是父类存储空间的一个标识(理解: 父类对象的运用)
                成员访问格式:
                        成员变量
                                this.变量名                本类的成员变量
                                super.变量名        父类的成员变量
                        构造方法
                                this(...)                本类的构造方法
                                super(...)                父类的构造方法
                        成员方法
                                this.方法名(...) 本类的成员方法
                                super.方法名(...)父类的成员方法
               
                继承中构造方法的访问特点:
                        子类在初始化的时候,默认去调用父类的无参的构造方法

                        所有的构造方法的第一句都是super()

                注意事项:
                        this(...) 和 super(...)必须是构造方法第一行
                       
                Object:        所有的类都是直接的或者间接的继承自该类

                继承中成员方法的访问特点:
                        查找顺序:
                                (1): 在子类中查找
                                (2): 在父类中查找
                                (3): 报错
        方法重写与方法重载的区别
                        方法重写:  子类中出现了和父类中一模一样的方法(方法名, 返回值类型 , 参数列表)
                        方法重载:        在同一个类中,允许同时存在一个以上的同名方法只要它们的参数列表不同, 与返回值无关
        final关键字

                特点:
                        final(最终的)
                        修饰类                                被修饰的类不能被继承
                        修饰变量                        被修饰的变量其实是一个常量

                                                                引用类型                指的是地址值不能被改变
                                                                基本类型                指定是值不能被改变
                        修饰方法                        被修饰的方法不能被子类重写
               
                final的初始化时机问题:
                        a: 只能被赋值一次
                        b: 在构造方法结束前赋上值就OK了(非静态的)


多态
                前提:
                        (1): 需要有继承
                        (2): 需要有方法重写,没有方法重写也是可以的,但是没有意义
                        (3): 父类的引用指向子类对象
                                Fu f = new Zi();
                多态中成员的访问特点:
                        成员变量:        编译看左边, 运行看左边
                        成员方法:        编译看左边 , 运行看右边
                        静态成员方法:        编译看左边 , 运行看左边
                好处:
                        (1): 提供了代码的维护性(继承)
                        (2): 提供了代码的扩展性(多态)
                弊端:
                        不能访问子类特有的功能
                       
                向下转型:        就是把父类的引用强制转换成子类的引用                Zi zi = (Zi)f ;
                向上转型:        父类的引用指向子类对象                                                Fu f = new Zi();
        抽象类
                特点:
                        (1): 抽象类格式:                abstract class 类名 {}
                                 抽象方法的格式:        public abstract 返回值类型 方法名(...);
                        (2): 抽象类中可以有非抽象方法,也可以有抽象方法,如果一个类中存在抽象方法,那么就需要将该类定义为抽象类
                        (3): 构造方法
                                        有, 用于子类在访问数据的时候初始化
                        (4): 抽象类不能对其进行直接实例化,但是可以对其进行间接的实例化(多态的形式)
                        (5): 抽象类的子类
                                 a: 可以是抽象类
                                 b: 可以是具体的类,但是这个具体的类需要重写抽象类中的抽象方法
                成员特点:
                        (1): 成员变量                可以是变量,也可以是常量
                        (2): 构造方法                有 , 用于子类在访问数据的时候初始化
                        (3): 成员方法                可以是抽象方法,可以是非抽象方法

                面试题:
                        abstract不能和那些关键字进行共存?
                        private                冲突
                        final                冲突
                        static                无意义
        接口

                特点:
                        (1): 定义接口的格式                        interface 接口名{}
                        (2): 类实现接口的格式                class 类名 implements 接口名{}
                        (3): 接口不能对其进行直接的实例化,但是可以通过多态的形式对其进行间接的实例化
                        (4): 接口的子类
                                        a: 可以是抽象类
                                        b: 可以是非抽象类,该类必须重写接口中的抽象方法
                        (5): 接口中没有构造方法,并且接口中的方法都是抽象方法


                成员特点:
                        成员变量        只能常量,存在默认的修饰符                public static final
                        构造方法        没有
                        成员方法        只能是抽象方法,存在默认的修饰符        public abstract

                类与类 , 类与接口, 接口和接口的关系
                       
                        类与类:                        继承关系(extends),只支持单继承,不支持多继承 , 但是可以多层继承
                        类与接口:                实现关系(implements) , 可以是单实现,也可以是多实现,并且一个类可以在继承一个类的同时,实现多个接口
                        接口和接口:                继承关系(extends),可以是单继承,也可以是多继承

                抽象类和接口的区别:
                        a: 成员区别       
                                        抽象类
                                                成员变量        可以是变量,也可以是常量
                                                构造方法        有
                                                成员方法        可以是抽象方法,也可以非抽象方法
                                        接口
                                                成员变量        只能是常量                        public static final
                                                构造方法        没有
                                                成员方法        只能是抽象方法                public abstract
                        b: 关系区别
                                类与类:                        继承关系(extends),只支持单继承,不支持多继承 , 但是可以多层继承
                                类与接口:                实现关系(implements) , 可以是单实现,也可以是多实现,并且一个类可以在继承一个类的同时,实现多个接口
                                接口和接口:                继承关系(extends),可以是单继承,也可以是多继承
                        c: 设计理念
                                抽象类                体现的是"is a"关系                                定义的都是该继承体系中共性的内容
                                接口                体现的是"like a"关系                        定义的都是该继承体系中扩展性的东西



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