继承

来源：互联网发布：河海大学人工智能编辑：程序博客网时间：2024/05/14 13:39

概念

继承是面向对象编程的三大特征之一，也是实现代码复用的重要手段。Java中继承具有单继承的特点，每一个类只可以直接继承一个父类，即直接父类，不可以同时继承多个类。但是继承是可以多层继承的，即：父类还有父类，顶级的父类为Object类。也就是说，任何类都是Object的子类，Object是任何类的父类。

如果编写的类没有直接继承其他类，默认继承的是Object类

子类了父类的一些特征。子辈从父辈那里可以继承一笔财富称为继承，子类从父类那里可以继承一些代码称为继承。

继承是如何实现代码的复用？

以已有的类作为父类（基类），从这个父类已有的功能和属性上，在新的类（子类）中，添加其他方法和属性，达到复用代码的目的，而不用再编写父类已存在的代码，这样就达到了代码的复用！

提示：

当我们描述一类事物时候，发现这些事物具备相同的属性，我们将这些共性属性进行抽取，用单独的类来描述共同的属性，让这类事物继承抽取出来的类描述的对象，实现的代码的复用。但是请注意，继承是一类事物共性的向上抽取，所以不能单纯的为了简写代码而使用继承。

JavaJDK中提供了大量的类，这些类通过一层一层的继承，形成一个庞大的继承树，最顶级为Object类，一定要注意，这个继承树的形成是N多个类的共性的抽取，一层一层抽取共性，直至抽取到Object类，而不是说：所有功能的类都是通过Object派生出去的！

//描述猫的时候，继承狗，虽然也具备了name属性，但是意义完全错误。

class Cat extends Dog

{

String id;

}

如果在描述对象时，只是为了简写代码，不可以使用继承的特性定义了一些和描述对象完全不相关的成员。

如果只是为了简写代码的编写，完全可以将这些不相关的代码编写一个单独的工具类来实现。

[java] view plain copy
 class Dog {  
    Stringname;  
    Stringage;  
    voidmethod1(){  
        System.out.println("今天星期一");  
    }  
    voidmethod2(){  
        System.out.println("天气晴");  
    }  
    voidmethod3(){  
        System.out.println("今天没雾霾");  
    }  
}    
class DaoMang extends Dog  
{  
    /*在这里编写代码时候，需要用到父类的方法，可以 
    直接调用，编写代码确实很爽，但是这和继承思想 
    完全没有任何关系！因为执行父类的那些方法和描述 
    对象没有任何关系！！*/  
    voidmethod(){  
            method1();  
    }  
     
}  
编写dog继承类代码。  
class Dog {  
    Stringname;  
    Stringage;  
    voidworking(){  
        System.out.println("看家！");  
    }  
}    
class DaoMang extends Dog  
{  
    String id;  
}  

特点：

java继承通过使用extends关键字来实现，实现继承的类被称为子类，被继承类称为父类。例如：动物是狗的父类，狗是哈士奇的父类。

定义格式：

修饰符 class 子类 extends 父类{

}

重写：Override：

子类继承父类后，在原有的基础上可以进行扩展，如新增属性、方法，但是有一种情况，例如：狗类具有工作方法搜救犬的工作是搜救，导盲犬的功能是导盲，那这个时候他们的工作方法内容就不一样了，我们需要将他们的工作方法进行单独的修改，那么这个修改的动作就是重写。

定义：子类继承父类后，如果子类的方法与父类的方法名称、参数个数及返回值类型完全一致时，就称为子类中的这个方法重写了父类中的方法。同理，如果子类中重复定义了父类中的已有的属性，则称此子类中的属性重写了父类中的属性。

子类重写了父类的方法或属性，那么该方法或属性便属于子类，而不属于父类，如果还想调用父类中的被重写的方法或属性，使用super.方法名/参数名的方式调用即可。

[java] view plain copy
class Test  
{  
    publicstatic void main(String[] args){  
        DaoMangdm = new DaoMang();  
        dm.working();  
        Soujiusj = new Soujiu();  
        sj.working();  
    }  
}  
   
   
class Dog {  
    Stringname;  
    Stringage;  
    void working(){  
        System.out.println("看家！");  
    }  
}    
class DaoMang extends Dog  
{  
    String id;  
    voidqita(){  
     
    }  
    voidworking(){  
        System.out.println("引路！");  
    }  
}  
class Soujiu extends Dog  
{  
    String id;  
    voidworking(){  
        System.out.println("搜救！");  
    }  
}  

spuer关键字

定义： super代表当前对象的父类对象。

当创建子类对象，最先拥有的应该是它的父类对象，那么可以使用super关键字代表父类对象，达到访问父类成员的目的！

父类对象都没有怎么可能创建子类对象？

子类覆盖了父类的方法后，子类对象无法直接调用被覆盖的父类中的方法，那么可以使用super关键字来实现调用父类的方法，或者也可以使用类名.方法名调用，但前提这个方法是静态方法（类方法）。

通过super找到该对象的父类对象：

[java] view plain copy
voidworking(){  
    super.working();  
    System.out.println("引路！");  
}  

通过Dao.静态方法执行代码：

[java] view plain copy
static void working(){  
   Dog.working();  
   System.out.println("引路！");  

之前的this关键字是代表当前对象本身。这个时候super代表的是父类对象本身。

同样，super和this不能出现在static关键字修饰的方法中。

因为：static修饰的是静态的，super、this关键字描述的是对象，静态成员是优先于对象存在的。用存在的东西访问不存在的东西是错误的。

验证：子类调用到父类的属性，该属性属于父类而不属于子类。

1、在父类中定义name属性，子类没有定义name属性。

2、在测试时候，调用子类的name属性。

3确定这个子类修改了的name属性其实是属于父类的！

证明：

1、父类对象被子类引用。

2、子类继承父类的属性，只是引用指向了父类，并没有将父类的属性进行单独的复制一份作为子类对象本身的属性。

导盲犬与搜救犬的父类对象是同一个吗？

每次创建子类对象，都会单独创建一个该子类的父类对象！他们的父类对象不是同一个，但是他们的父类是同一个！

调用父类构造器：

[java] view plain copy
class Dog {  
    publicDog(String message){  
        System.out.println(message);  
    }  
        Stringname;  
}    
class DaoMang extends Dog  
{  
     
    publicDaoMang(){  
        super("abc");  
    }  
    String id;  
     static void working(){  
        System.out.println("引路！");  
    }  
}  

创建一个子类对象，发生了什么未知的事情？

[java] view plain copy
class Test  
{  
    publicstatic void main(String[] args){  
        /* 
        创建子类对象发生了： 
        1、先执行父类静态代码块 
        2、执行子类静态代码块 
        3、执行父类的构造代码块 
        4、执行父类的构造方法 
        5、执行子类的构造代码块 
        6、执行子类的构造方法 
    */  
        DaoMangdm = new DaoMang();  
    }  
}  
class Dog {  
    static{  
        System.out.println("Dog类的静态代码块执行了！");  
    }  
    {  
        System.out.println("创建Dog对象时构造代码块");  
    }  
   
    publicDog(){  
        System.out.println("Dog的构造器执行了！");  
    }  
}    
class DaoMang extends Dog  
{  
    static{  
        System.out.println("DaoMang类的静态代码块执行了！");  
    }  
    {  
        System.out.println("创建DaoMang对象时构造代码块");  
    }  
    publicDaoMang(){  
        System.out.println(id  + "DaoMang的构造器执行了！");  
    }  
}  
   

设置父类与子类同名的成员属性

[java] view plain copy
class Test  
{  
    publicstatic void main(String[] args){  
        DaoMangdm = new DaoMang();  
        dm.setName("金毛");  
        dm.setSuperName("SuperName");  
        Stringname = dm.getName();  
        StringsuperName = dm.getSuperName();  
        System.out.println("子类对象的name:" + name +"\n 父类对象的name是：" + superName);  
    }  
}  
class Dog {  
    Stringname;  
}    
class DaoMang extends Dog  
{  
    Stringname;  
    publicvoid setName(String name){  
        this.name= name;  
    }  
    publicvoid setSuperName(String name){  
        super.name= name;  
    }  
    publicString getName(){  
        returnname;  
    }  
    publicString getSuperName(){  
        returnsuper.name;  
    }  
}  

0 0