关于继承——extends_extends 声明 隐式扩散

写在前面：

类的加载：
1.类的加载发生在运行期间；
2.是从磁盘上把*.class文件(类字节码文件)载入到内存中的过程；<类加载器(ClassLoader)>
3.类被加载到内存的方法区；
4.加载的是类的方法语句数据，静态属性，元信息；
5.类加载的时机是：需要的时候才加载；
6.new对象，访问静态属性/方法，反射的时候会用到类；
7.静态属性的初始化顺序：按照书写的顺序执行。
编译期间：
是将源文件(.java)转化为类字节码文件(.class),编译期间运行的不是源代码，而是javac程序，源代码只是作为别人程序的一个输入而已。
运行期间：
运行的是源程序，java会启动JVM虚拟机。

一、继承
1.子类在一些书中也被称为派生类，父类也被称为超类(Super Class)。
2.子类可进行代码的扩充（扩充属性和方法）。
3.继承的主要作用是对类进行扩充以及代码的重用

class 子类 extends 父类

4.若父类里没有提供无参构造，那么这个时候必须使用super()指明你要调用的父类构造方法
5.Java只允许单继承，不允许多重继承，但可以多层继承。即一个子类只能继承一个父类。
6.显式继承与隐式继承

class Person{
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
}
class Student extends Person{
    public void fun(){
        System.out.println(getName());
    }
}
public class Excipise1109{
    public static void main(String[] args){
        Student s=new Student();
        s.setName("steven");
        System.out.println(s.getName());
        s.fun();
    }
}
//父类中的属性的确被子类继承了，但是子类继承的是所有非private操作，而所有的private操作无法被直接使用，即为隐式继承。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

二、继承的限制

子类对象在进行实例化之前一定会首先实例化父亲对象。默认调用父类的构造方法后再调用子类构造方法进行子类对象初始化。

class Person{
    public Person(){
        System.out.println("Person类对象产生");
    }
}
class Student extends Person{
    public Student(){
        super();  //此语句在无参时写与不写一样
        System.out.println("Studnt类对象产生");
    }
}
public class Excipise1109{
    public static void main(String[] args){
        Student s=new Student();
        new Student();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

例：

class Person{
    private String name;
    private int age;
    public String getName(){
        return name;
    }
    public void setNmae(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}
class Student{
    private String name;
    private int age;
    private String school;

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getSchool(){
        return school;
    }
    public void setSchool(String school){
        this.school=school;
    }
}
public class Excipise1109{
    public static void main(String[] args){
        Student s=new Student();
        s.setName("苏苏");
        s.setAge(21);
        s.setSchool("一中");
        System.out.println("姓名："+s.getName());
        System.out.println("年龄："+s.getAge());
        System.out.println("学校："+s.getSchool());
    }
}
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

以上的程序用extends实现继承之后：

继承的目的是在原有的代码上继续进行功能的扩充，消除了结构定义上的重复

class Person{
    private String name;
    private int age;

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}
class Student extends Person{
    private String school;

    public String getSchool(){
        return school;
    }
    public void setSchool(String school){
        this.school=school;
    }
}
public class Excipise1109 {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("苏苏");
        s.setAge(21);
        s.setSchool("一中");
        System.out.println("姓名：" + s.getName());
        System.out.println("年龄：" + s.getAge());
        System.out.println("姓名：" + s.getSchool());
    }
}
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