18天Java学习---13.面向对象编程08-Java中继承的概念,子类实例化过程,super()及方法复写

来源：互联网发布：软件怎开发的编辑：程序博客网时间：2024/04/30 07:34

继承是OOP的三大特点之一. 这一节主要做一下继承的笔记.

1. 继承的概念及使用

在Java中,通过继承可以简化类的定义,扩展类的功能. Java中支持类的单继承和多层继承,但是不支持多继承,即: 一个类只能继承一个类而不能继承多个类.

实现继承的格式为: class 子类名 extends 父类

Java中继承只能直接继承父类中的公有属性和公有方法,而隐含地(不可见地)继承了私有属性. 继承的内容如下图:

2. 子类对象的实例化过程

子类对象在实例化时,需要注意的是: 子类对象实例化会默认先调用父类中的无参构造函数,然后再调用子类构造方法. 例如下面的实例代码:

　　这里有一点挺有意思的,如果父类没有无参构造函数,则子类的实例化就会报错~~

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
class Person   
{   
    privateString name;  
    privateintage;   
        
    //父类的无参构造方法  
    publicPerson()  
    {  
        System.out.println("========父类中的构造方法========");  
    }  
    //getter和setter方法  
    publicString getName()  
    {  
        returnthis.name;  
    }  
    publicvoidsetName(String name)  
    {  
        this.name = name;  
    }  
    publicintgetAge()   
    {  
        returnthis.age;  
    }  
    publicvoidsetAge(intage)  
    {  
        this.age = age;  
    }  
    //返回信息方法  
    publicString getInfo()  
    {  
        return"姓名是: "+name+",年龄是: "+age;  
    }  
}   
class Student extends Person   
{   
    privateString school ="软件学院";  
    //子类的无参构造方法  
    publicStudent()  
    {  
        setName("newsainton");  
        setAge(23);  
        System.out.println("========子类中的构造方法========");  
    }  
    publicvoidprint()   
    {  
        System.out.println(getInfo()+",学校是:"+school);  
    }     
}   
public class Demo01   
{   
    publicstaticvoid main(String args[])  
    {  
        // 使用子类对象  
        Student s =newStudent() ;  
        s.print();  
    }  
}

3. super()方法和类方法复写机制

3.1 super()方法

在上面的实例中, 实际上在子类Student的构造方法中隐含了一个super()的方法. 该方法表示调用父类(即超类)的构造方法. 需要注意的是,我们也可以使用super(参数类型参数名, 参数类型参数名, ...)这样的格式来调用父类重载后的含参构造方法. 下面的例子中用到了这种super方法.

3.2 子类对父类方法的复写

子类可以继承父类的方法,也可以复写父类的方法. 但复写父类的方法有一个基本的前提: 所复写的方法不能有比父类方法更严格的访问权限. (访问权限 public > default > private)

这里举一个程序的例子,在该例子中, 子类Student以super(name,age)的形式调用父类的构造方法,同时子类以不变的权限复写了父类的getInfo()方法:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
class Person   
{   
    privateString name ;  
    privateintage ;   
    // 希望在调用Person类的构造方法的时候可以直接为属性初始化  
    publicPerson(String name,intage)  
    {  
        this.setName(name) ;  
        this.setAge(age) ;  
    }  
    // 私有属性要加入setter和getter操作就可以访问了  
    publicvoidsetName(String name)  
    {  
        this.name = name ;  
    }  
    publicvoidsetAge(intage)  
    {  
        this.age = age ;  
    }  
    publicString getName()  
    {  
        returnthis.name ;  
    }  
    publicintgetAge()   
    {  
        returnthis.age ;  
    }  
    publicString getInfo()  
    {  
        return"姓名 = "+this.name+"，年龄 = "+this.age ;  
    }  
}   
// 与Person类相比是扩充了Person类的功能，所以此处继承即可  
class Student extends Person   
{   
    privateString school ;  
        
    publicStudent(String name,intage,String school)  
    {  
        //super() ; //--> 隐含的代码  
        // 此时最好可以明确的指出要调用父类中的有两个参数的构造方法  
        // 直接指明调用父类中有两个参数的构造方法。  
        super(name,age) ;  
        this.setSchool(school) ;  
    }  
    publicvoidsetSchool(String school)  
    {  
        this.school = school ;  
    }  
    publicString getSchool()  
    {  
        returnthis.school ;  
    }  
    // 子类覆写了父类中的getInfo()方法  
    publicString getInfo()  
    {  
        // 调用父类中的getInfo()方法,使用super.方法名()的格式  
        returnsuper.getInfo()+"，学校 = "+this.school ;  
    }  
}   
public class Demo02{   
    publicstaticvoid main(String args[])  
    {  
        // 使用子类对象  
        Student s =newStudent("newsainton",23,"软件学院") ;  
        System.out.println(s.getInfo()) ;  
    }  
}