A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© A等待着 中级黑马   /  2015-7-13 21:10  /  578 人查看  /  5 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

1.继承:
        把多个类中相同的内容抽取出来,单独定义到一个类(父类)中,在定义其他类(子类)的时候,继承父类即可
        子类就可以使用符类的非私有的属性和行为
       
注意:只能访问父类的非私有属性和行为

格式:
        class 子类名 extends 父类名
       
        好处:
                1)提高代码的复用性,降低代码的重复率.
                2)让类与类之间产生一个关系,是多态的前提.
               
        特点:
                1)java的继承只支持单继承,不支持多继承,为了避免调用的不明确性.
                2)java支持多层继承.(继承体制)
               
       
       
                重复--可维护性.
                内聚.某个类单独完成一个程序.
                耦合:类与类之间的关系.
               
               
        什么时候定义继承:
                体现的是 is a 的关系,尽量不要为了使用部分功能而采用继承关系.
               
2.子父类成员变量的使用顺序:
        局部        --        成员        --        父类        --        报错
        局部变量输出局部:
                                        直接输出
        局部变量输出成员:
                                        this.变量
        局部变量输出父类:
                                        super.变量
                                       
                                       
3.this 和 super
        this 代表当前运行类的对象的引用.
        super 代表父类内存空间的标识.
        都可以调用成员变量,成员方法和构造方法.
       
        应用:
                1)成员变量
                        this.变量名 -- 本类成员变量
                        super.变量名 -- 父类成员变量
                2)构造方法:
                        this(参数) -- 调用本类构造
                        super(参数) -- 调用父类构造
                       
                        必须放在构造方法的第一行...
                       
                3)成员方法
                        this.方法(); -- 本类的方法
                        super.方法名(); -- 父类的方法
                       
                       
4.成员方法
        重写:子父类之间,出现方法完全一致(返回值类型,方法名,参数列表)
       
        重写和重载区别:
                重载:一个类中,方法名相同,参数列表不同(参数个数或者数据类型或者顺序),与返回值无关
                重写:子父类中,方法名相同,参数列表相同(返回值类型,方法名,参数列表)
               
                &&注意事项:
                        1)父类的私有方法不能被重写.
                        2)子类重写父类的方法,不能缩小父类方法的访问权限
                        3)静态方法只能被静态方法重写.
                应用:
                        子类的方法既想继承父类方法的功能,又有定义了子类特有的内容.
                       
                       
5.继承中的构造方法执行顺序
        子类中的构造方法默认去访问了父类中的无参构造,因为构造飞的第一行都有一句super();
        母的是为初始化父类的成员
       
        如果父类没有无参构造,怎么办?
                1)用super(参数)去调用父类的带参构造
                2)用this(参数)去调用本类的其他构造,想调用的这个构造必须最终调用父类的带参构造
               
        构造方法没有重写!
                原因:因为构造方法不被子类继承,只不过子类创建对象的时候调用的构造方法,
                去初始化了父类的成员.构造方法存在重载关系
               
6.子父间代码块执行顺序
        父类静态代码块 -子的静态 -父的构造代码块 - 父的构造方法 -子的构造代码块 - 子的构造方法
       
        特点:
                静态代码块,随着类的加载而加载,但是只执行一次
                构造代码块,在构造方法的执行前会执行,并且每次创建对象都执行.
               
               
7.任何类都直接或者间接的继承Object类

8.子类昂文父类私有成员的方法
        1)通过set和get方法可以给父类的成员变量赋值
        2)通过子类调用父类的带参构造方法.
       
       
9.final关键字:
        最终的意思
        修饰
        成员变量 -- 其实是一个变量,一旦被赋值,将不再发生改变.
                注意:final修饰引用数据类型,指的是修饰的引用的指向不会发生改变
        成员方法 -- 不能被子类重写
        类 -- 不能被继承
       
        finally关键字
       
        finalize()方法
                       
                class Fu
        {
                public int num = 10;

                public Fu()
                {
                        System.out.println("fu");
                }
        }

        class Zi extends Fu//子类继承了父类
        {
                public int num = 20;

                public Zi()
                {
                       
                        System.out.println("zi");
                }

                public void show()
                {
                        int num = 30;
                        System.out.println(num);       
                        System.out.println(this.num);       
                        System.out.println(super.num);       
                }
        }

        class Test
        {
                public static void main(String[] args)
                {
                        Zi z = new Zi();//fu zi
                        z.show();
                }
        }       
        zi z是先访问Test 类,然后在访问静态的main方法,于是就加载了父类静态的方法,然后加载了子类静态的方法,
        然后new Zi()是在堆里面开辟了一个内存,把地址值给了Zi z,然后访问无参Zi()的构造方法,但是默认的super();
        于是访问了无参的父类构造方法..z.show ();子类调用show()方法,然后输出!               
                       
       
       

5 个回复

倒序浏览
加油,,,看见你几次了
回复 使用道具 举报
不错 顶一个。,,,希望还能发多点类似的帖子 长知识,,,,,
回复 使用道具 举报

不错 顶一个
回复 使用道具 举报

不错 顶一个。
回复 使用道具 举报
不错   定一个
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马