【JavaSE】继承

前言：为方便讲解一个java文件写多个类。

1. 如何继承

class Cat {
    public String name;
    public int age;
    public String sex;  //性别
    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
    public void mew() {
        System.out.println(this.name + ":喵喵喵");
    }
}
class Dog {
    public String name;
    public int age;
    public String sex;  //性别
    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
    public void bark() {
        System.out.println(this.name + ":汪汪汪");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

我们可以看到以上类中，狗类和猫类都有姓名、年龄、性别，同时都会有睡觉的动作。这时我们就可以把这些共性抽出来放到创建的父类中进行继承。

class Animal {
    public String name;
    public int age;
    public String sex;  //性别
    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
}
//继承用到关键字extends表示Cat继承Animal
class Cat extends Animal{
    public void mew() {
        System.out.println(this.name + ":喵喵喵");
    }
}
class Dog extends Animal{
    public void bark() {
        System.out.println(this.name + ":汪汪汪");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这时 Cat 和 Dog 类继承了 Animal 类，可以使用 Animal 中的变量和方法。

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "凉凉";
        cat.age = 3;
        cat.sex = "公";
        cat.sleep();
    }
}
1
2
3
4
5
6
7
8
9

这时用谁的对象进行访问 name、age等变量和方法就属于那个对象的，像上面猫访问name，name就属于猫的。

通过上面可以看出，继承就是抽出共性，达到代码的复用

注意：

1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，建议要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了。
   如上面的猫和狗，都有自己特有的成员方法，猫会喵喵叫，狗会汪汪叫。
3. 这时 Cat 和 Dog 可以叫做子类或派生类，Animal 可以叫 父类、基类或超类。

2. 子类如何访问父类的成员

那么我们子类该如何访问父类中的成员变量和成员方法呢？

2.1 子类中访问父类的成员变量

1. 子类和父类不存在同名成员变量

class Base {
    public int data1 = 10;
    public int data2 =20;

}
class Derived extends Base {
    public int data3 = 30;
    public int data4 = 40;
    public void method() {
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);
    }
}

public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

此时 derived 对象的内存情况为：

2. 子类和父类存在同名成员变量

class Base {
    public int data1 = 10;
    public int data2 =20;

}
class Derived extends Base {
    public int data1 = 30;
    public int data4 = 40;
    public void method() {
        System.out.println(data1);//优先访问自己的成员变量
        System.out.println(data2);
    }
}

public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

当子类和父类有同名成员变量时，应优先访问自己的成员变量。

那我们该如何在子类访问父类的同名成员变量呢
使用 super 关键字。

当然这时也可以使用 this 引用 data2 因为子类继承了父类此时 data2 也属于子类的成员变量

总结：

在子类方法中 或者 通过子类对象访问父类成员变量时：

• 如果访问的成员变量子类中有，优先访问自己的成员变量。
• 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
• 如果访问的成员变量与父类中成员变量同名，则优先访问自己的，即：子类将父类同名成员隐藏了。
• 成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

3. 父类中成员被 private 修饰时。

当父类中的成员变量被 private 修饰时，需要提供get 或 set 来对此成员变量进行操作，此时 data1 是被继承下来了，不过只能通过 get 或 set 进行访问。

class Base {
    private int data1 = 10;

    public int getData1() {
        return data1;
    }

    public void setData1(int data1) {
        this.data1 = data1;
    }
}
class Derived extends Base {
    public int data1 = 100;
    
    public void test() {
        System.out.println(this.getData1());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.2 子类中访问父类的成员方法

1. 子类和父类不存在同名成员方法

class Base {
    public void method1() {
        System.out.println("父类的方法");
    }
}
class Derived extends Base {
    public void method2() {
        System.out.println("子类的方法");
    }
    public void test() {
        method1();
        method2();
    }
}
public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这里和访问成员变量是一样的方法，就不再说了。

1. 子类和父类存在同名成员方法

class Base {
    public void method1() {
        System.out.println("父类的方法");
    }
}
class Derived extends Base {
    public String name;

    public void method1(String name) {
        System.out.println("子类的方法");
    }
    public void test() {
        method1("张三");
        method1();
    }
}
public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这里的两个 method 方法构成了重载。

当两个不同类中有相同的方法名，如果它们之间是继承关系那么这两个方法构成重载。

3. super关键字

主要作用：在子类中访问父类的成员变量和成员方法。

super 主要用法：

• super.成员变量 访问父类的成员变量
• super.成员变量 访问父类的成员方法
• super() 访问父类构造方法

在子类中，如果想要明确访问父类成员，则用 super 引用。

class Base {
    public int data1 = 10;
    public void method1() {
        System.out.println("父类的方法");
    }
}
class Derived extends Base {
    public int data1 = 100;
    public void test() {
        super.method1();//访问父类的成员方法
        System.out.println(super.data1);//访问父类的成员变量
        System.out.println(this.data1);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注意：super 关键字不能在静态的方法中使用

4. 如何写构造方法

当我们给父类写构造方法时，子类报错了。
那么我们该如何写呢

当子类写构造方法时，必须先帮父类进行构造。

class Animal {
    public String name;
    public int age;
    public String sex;
    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class Dog extends Animal {
    public String hire;
    public void bark() {
        System.out.println(this.name + ":汪汪汪");
    }
    //先帮父类构造方法，在构造子类方法
    public Dog(String name, int age, String hire) {
        super(name, age);//必须写在第一行
        this.hire = hire;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", hire='" + hire + '\'' +
                '}';
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog("小黄", 3,"黄色");
        System.out.println(dog);
    }
}

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

当父类中没写构造方法时，编译器默认帮我们提供一个不带参数的构造方法，当我们在父类中写了带参数的构造方法后，编译器就不会帮我们提供了。

也可以这样写，即父类中没写带参数的构造方法编译器会默认提供一个不带参数的构造方法，子类构造方法中，没在第一行写super()时，编译器会帮我们在第一行加上，相当于 super() 隐藏了。当然也可以自己在第一行写上 super()

最后想要使一个类不想被继承，可以在类前加 final 关键字

可以看到，被 final 修饰 Animal 不能被继承了

好的，到这里本章节就结束了，如发现有错误，请各位大佬及时指出