黑马程序员技术交流社区

标题: 继承 [打印本页]

---

作者: 任有智双元    时间: 2015-8-3 23:25
标题: 继承
1. 回顾
        面向对象三大特性之封装
       
        隐藏对象的属性和具体的实现细节,对外提供公共的访问方式.
               
        private 私有化
       
        class Student
        {
                private String name;
                private int age;
               
                public Student(){}
               
                public Student(String name, int age)
                {
                        // 就近原则
                        this.name = name;
                        this.age = age;
                }
               
                // getters  setters
               
                public String getName()
                {
                        return name;
                }
               
                public void setName(String name)
                {
                        this.name = name;
                }
        }
       
        this关键字
                代表方法所属类的对象的引用. (理解: 谁调用的方法就代表谁)
               
        super
       
        static 关键字  -- 静态的
       
                1) 随着类的加载而加载,优先于对象存在.
                2) 被类的所有对象共享.
                3) 建议使用类名直接调用.
               
                注意事项:        静态方法只能调用静态的成员.
               
        Api的使用
       
        Math类 -- 数学类(提供了常用的算术运算)
                int abs(int i)
                double ceil(double d)
                double floor(double d)
                long round(double d)
                int round(float f)
                double random() -- [0.0, 1.0)
               
                -- 以后设计函数的时候,如果发现参数较多,建议大家去考虑数组或者集合.
               
        Random类
                nextInt() -- 返回int范围内的一个随机数
                nextInt(int n) -- 返回0到n的一个随机数
               
2. 继承
        概念:
                把多个类中相同的内容抽取出来,单独定义到一个类(父类)中,再定义其他类(子类)的时候,继承父类即可.
                子类就可以使用父类所有的非私有的属性和行为.
               
        格式:
                class 子类名 extends 父类名{}
               
        好处:
                1) 提高代码复用性,降低代码的重复率.
                2) 让类与类之间产生关系,是多态的前提.

        特点:
                java的继承只支持单继承,为了避免调用的不明确性.
                但是java支持多层(重)继承.
                       
                       
        几个名词:
                可维护性.
                内聚.
                耦合.
               
        什么时候定义继承:
                体现的是 is a 的关系.
                尽量不要为了使用部分功能而采用继承关系.
       
3. 子父类间成员变量的使用:
        同名的成员变量:
                局部 -- 成员 -- 父类 -- 报错
        局部位置输出局部:
                直接使用变量名即可
        局部位置输出成员:
                this.变量名
        局部位置输出父类:
                super.变量名
               
        class Fu
        {
                int num = 10;

                public void fun()
                {
                        //int num = 30;
                        System.out.println(num);       
                }
        }
       
        class Zi extends Fu
        {
                int num2 = 20;
               
                public void show()
                {
                        int num3 = 30;       
                }
        }
       
        class ZiTest
        {
                public static void main(String[] args)
                {
                        Zi zi = new Zi();
                        zi.fun();
                }
       
        }       

4. this 和 super
        this 代表当前运行类的对象的引用.
        super 代表父类内存空间的标识.(可以理解成父类对象的引用)
       
        应用:
                1) 成员变量
                        this.变量名 -- 本类成员变量
                        super.变量名 -- 父类成员变量
                2) 构造方法:
                        this(参数) -- 调用本类其他构造
                        super(参数) -- 调用父类构造
                        -- 都是通过参数进行匹配
                        注意: 必须放在构造方法的第一行.
                3) 成员方法
                        this.方法名(); -- 本类的方法
                        super.方法名(); -- 父类的方法
               
5. 成员方法
        重写: 子父类之间,出现方法完全一致(返回值类型, 方法名, 参数列表)的情况,称为方法的重写.
                @Override
        重载与重写的区别:
                重载: 一个类中,方法名相同,参数列表不同(参数的个数或者数据类型或者顺序),与返回值类型无关.
                重写:子父类之间,出现方法完全一致(返回值类型, 方法名, 参数列表)的情况,称为方法的重写.
               
        方法的重写注意问题:
                1) 父类的私有方法不能被重写.
                2) 子类重写父类的方法,不能缩小父类方法的访问权限.
                3) 静态方法只能被静态方法重写.
        应用:
                子类的方法既想继承父类方法的功能,又有自己特有的功能,就可以使用super.方法名()来调用父类的功能,并且添加自己的功能.
               
6. 继承中的构造方法执行顺序
       
        子类中的构造方法默认都去访问了父类中的无参构造,因为构造方法的第一行都有一句默认的super();
        目的是为了初始化父类的成员.
       
        如果父类没有无参构造,怎么办?
                1) 用super(参数) 去调用父类的带参构造.
                2) 用this(参数) 去调用本类的其他构造, 想调用的这个构造必须最终调用了父类的带参构造.
               
        构造方法没有重写.
                因为构造方法不被子类继承. 只不过子类创建对象的时候调用了父类的构造方法,去初始化了父类的成员.
       
        但构造方法可以存在重载关系.
       
7. 子父类间代码块执行顺序
       
        父静态代码块 -- 子的静态代码块 -- 父的构造代码块 -- 父的构造方法 -- 子的构造代码块 -- 子的构造方法
       
        特点:
                静态代码块, 随着类的加载而加载,但是只执行一次.
                构造代码块, 在构造方法的执行前会执行,并且每次创建对象都执行.
       
8. 任何类都直接或者间接继承自Object

9. 子类访问父类私有成员的方法
        1) 通过父类提供的公共的get和set方法.
        2) 子类通过调用父类的带参构造.
        基础思想都是一致的：
                对于私有的成员，除了在能所属类中使用之外，不能在其他任何地方直接使用。
                但是可以在所属类中定义公共的访问方式，然后外界通过这种公共的访问方式供其他类或者对象使用。
               
10. final关键字
        最终的意思.
        修饰
                成员变量 -- 其实是一个常量, 一旦被赋值,将不再发生改变.
                        注意: final修饰引用数据类型,指的是修饰的引用的指向不再发生改变.
                成员方法 -- 不能被子类重写.
                类 -- 不能被继承.
               
        finally 关键字
       
        finalize() 方法
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       
               
               

---

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

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