黑马程序员技术交流社区

标题: 面向对象——继承 [打印本页]

---

作者: 鲁枝权双元    时间: 2015-7-13 21:17
标题: 面向对象——继承
        面向对象的继承
1.什么是继承：
        把多个类中相同的内容抽取出来，单独定义到一个类（父类）中，在定义其他类（子类）的时候，继承父类即可。
        子类可以直接使用父类非私有的的属性和行为

        格式：
                class 子类名 extends 父类名（）{}

        作用：继承提高代码的复用性，降低代码的重复率
                让类与类之间产生了一个关系，是多态的前提

        特点：java只支持单继承，不支持多继承（为什呢?如果可以多继承就会出现调用不明确的情况）
                java支持多层继承(继承体系）

2.继承关系的子父类的成员：
        成员变量：通过子类访问一个成员变量的时候寻找的方式：局部，成员，父类
                父类的变量就是用super.变量名访问。

                this代表当前运行类的对象的引用
                 super关键字：代表父类的内存空间的标识
       
        构造方法：
                this（参数）---表示本类的其他构造方法
                super（参数）----父类的构造方法

                注意：必须放在第一行
        成员的方法：
                this.方法名（）----本类的方法
                super.方法名（）----父类的方法

关于super的使用代码案例（父类的父类）：

class ExtendsDemo
{
        public static void main (String[] args){
                Zi zi = new  Zi();
                zi.show();
                System.out.println("------");
                Fu fu = new Fu();//创建父类的对象
                fu.showFu();
               
        }
}
class FuFu
{
        int num=2;
}
class Fu extends FuFu
{
        int num=10;
        public void showFu(){
                System.out.println(super.num);//第一种方式
        }
}
class Zi extends Fu
{
        int num=20;
        public void show(){
                int num=30;
                System.out.println(num);//30
                System.out.println(this.num);//20
                System.out.println(super.num);//10
                FuFu fufu=new  FuFu();
                int fufunum=fufu.num;//第二种方式
                System.out.println(fufunum);
        }       
}

3.重写或者覆盖（override）：
        子类中出现与父类一模一样的方法时，会出现覆盖的操作
        重写和重载的区别？
                返回值，方法名，参数列表都不一样
                重写中和返回值类型有关

                重载就是返回值类型不一样
        注意事项：
                父类中私有方法不能被重写
                子类方法访问权限一定要大于等于父类方法的访问权限
                静态方法只能被静态方法重写
        覆盖的应用；子类的方法既想继续父类方法的功能又有自己特有的功能，就可以使用super.方法名使用父类的功能，
                    在写子类自己特有打方法
                       


4.继承中的构造关系：
        子类中的构造方法默认会去访问父类的无参构造方法即子类构造方法都有一个super()
        为什么呢？因为子类会自动具备父类中非私有化数据，只有父类具备这样的功能，构造方法就是初始化父类的成员

        注意事项：如果父类没有无参构造方法？两种方式

                1）用super（参数）去调用父类的带参构造

                2）用this（参数）去调用本类的其他构造，想调用这个构造必须最终调用父类的带参数构造

        构造方法没有重写

                因为构造方法不被子类继承，只不过子类创建对象的时候调用了父类的构造方法，去初始化父类的成员

        构造方法存在重载关系       

代码案例：
class Fu
{
       
        public Fu()
        {       
                System.out.println("fu gouzao");//无参构造打印fu gouzao
        }
       
       
        public Fu(String s)
        {
                System.out.println("fu s = " + s);
                System.out.println("--------------");
        }


}

class Zi extends Fu
{
        public Zi()
        {
                super("abc");//有参数就找父类的带参数的构造方法打印fu s=abc
                System.out.println("Zi gouzao");//直接打印  Zi gouzao
        }

        public Zi(String s)
        {
                //super("abc");
                //this();
                System.out.println("Zi s = " + s);//输出Zi s=abc
                System.out.println("************");               
        }

        public Zi(String s, int a)
        {
                this(s);//找本类中的带一个参数的构造
                System.out.println("Zi s = " + s);//最后执行这句打印 Zi s=abc
                System.out.println("00000000000000");
        }
}

class ExtendsDemo2
{
        public static void main(String[] args)
        {
                Zi zi = new Zi("abc", 10);//第一步先找子类无参构造...........再找子类中带参数的构造
                Fu f = new Fu();//招到无参的构造方法

        }
}


                       
5.代码块的执行顺序：
        静态代码块———构造代码块---构造方法

        父静态代码块--子静态代码块--父构造代码块--父构造方法--子构造代码块--子构造方法

        注意：静态代码块只执行一次，静态代码块随着类的加载而加载，
                构造代码块在构造方法的执行前而执行。               

6.子类如何访问父类的私有成员:
        子类通过父类的set方法给父类的成员变量赋值
        通过子类调用父类的带参构造方法即super（带参）

6.final关键字：
        final被修饰的方法是不可以被子类重写的
        修饰的类不可以被继承
        修饰的成员变量是一个常量（字面值的常量，定义常量）
       
        注意事项：final修饰引用数据类型，指的是修饰的引用数据类型的地址值不发生改变（内部可以发生改变）
/*
final 在对象的引用
*/
class Teacher
{
        private String name;
        public Teacher(){}
        public Teacher(String name){
                this.name=name;
        }
        public void setName(String name){
                this.name=name;
        }
        public String getName(){
                return name;
        }
}
class FinalDemo
{
        public static void main(String[] args)
        {
                //体现了final在修饰对象时候是可以改变的
                 final Teacher t=new Teacher("王志超");
                System.out.println(t.getName());
                t.setName("鲁枝权");
                System.out.println(t.getName());
        }
}

---

作者: 为明天而奋斗    时间: 2015-7-13 21:22
必须得赞一个

---

作者: dajiaoya    时间: 2015-7-13 22:12
赞一个,666

---

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

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