Java学习之继承

1、继承介绍

继承就好比一个A和一个B，A中有着一些属性和方法，而B也想要拥有A中的某些属性或方法就要用到继承

1.1代码演示

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
//现有两个类Zi类和Fu类，它们有着自己的方法或属性，现在子类想要使用父类中的方法或属性就需要继承
public class Fu {
    //父类
    public int age = 30;
    public void show() {
        System.out.println("父类的show方法");
    }
}
----------------------------------------------------------------------------------------
//子类想要继承父类的方法可以通过extends关键字
public class Zi extends Fu {
    //子类
    public int height = 165;
    public int age = 18;

    public void zshow() {
        System.out.println("子类的zshow方法");
    }

    public void show_ha() {
        int age = 20;
        System.out.println("身高：" + height);
        System.out.println("年龄：" + age);
    }
}
----------------------------------------------------------------------------------------
   //使用类
    public class Demo_1 {
    public static void main(String[] args) {
        //调用两个类中的方法
        Fu f = new Fu();
        f.show();
        Zi z = new Zi();
        z.zshow();
        //在子类调用父类的方法
        z.show();
    }
}
/*
    上面会输出Fu类中的show方法中的内容
    Zi类则会输出自己zshow方法中的内容还会在输出Fu类中的show方法中的内容
*/
//使用继承特性访问Fu类中的变量
public class Demo_2 {
    public static void main(String[] args) {
        //调用子类的方法查看身高年龄
        Zi z = new Zi();
        z.show_ha();
        /*
            继承中变量的访问特点
            在子类方法中访问一个变量其查找顺序为
            1- 子类局部范围查找
            2- 子类成员范围查找
            3- 父类成员范围查找
            4- 如果没有就报错(不考虑父亲的父亲...)
         */
    }
}

2、super关键字

依旧是上面的代码，现在提出要求需要访问 ==Zi类==中的成员变量，以及父类中的成员变量

2.1代码演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//直接对Zi类进行修改分别使用this关键字和super关键字即可
public class Zi extends Fu {
    //子类
    public int height = 165;
    public int age = 30;
    public void zshow() {
        System.out.println("子类的zshow方法");
    }

    public void show_ha() {
        int age = 20;
        System.out.println("身高：" + height);
        //访问局部变量的写法
        System.out.println("年龄：" + age);
        //访问成员变量的写法
        System.out.println("年龄：" + this.age);
        //访问父类变量的写法
        System.out.println("年龄：" + super.age);
    }

2.2super关键字总结

super关键字的用法和this关键字的用法相似

  • this：代表本类对象的引用
  • super：代表父类存储空间的标识(可以理解为父类对象的引用)
关键字 访问成员变量 访问构造方法 访问成员方法
this this.成员变量
访问本类成员变量		 this(…)
访问本类构造方法		 this.成员方法(…)
访问本类成员方法
super super.成员变量
访问父类成员变量		 super(…)
访问父类构造方法		 super.成员方法(…)
访问父类成员方法

3.继承中构造方法访问特点

依旧引用顶部的代码

3.1代码演示

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
//无参Fu类构造方法
    public Fu(){
        System.out.println("Fu类无参构造方法");
    }
    //带参Zi类构造方法
    public Fu(int age){
        System.out.println("Fu类带参构造方法");
    }
//无参Zi类构造方法
    public Zi(){
        System.out.println("Zi类无参构造方法");
    }
    //带参Zi类构造方法
    public Zi(int age){
        System.out.println("Zi类带参构造方法");
    }
//调用构造方法
public class Demo_4 {
    public static void main(String[] args) {
        //分别掉用Zi类和Fu类中的构造方法
        Zi z = new Zi();
        Zi z_2 = new Zi(1);
    }
}
//掉用后会这样输出是为什么呢？
/*
    Fu类无参构造方法
    Zi类无参构造方法
    Fu类无参构造方法
    Zi类带参构造方法
*/

3.1继承构造方法总结

继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中的无参构造方法，这是为什么呢？

  • 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类中的数据初始化
  • 每一个子类构造方法的第一条语句默认就是super()（只是默认隐藏了而已）

如果父类中没有无构造构造方法，只有带参构造方法，该怎么办呢？

  • 通过使用super关键字去显示的调用父类的带参构造方法
  • 在父类中自己提供一个无参构造方法

推荐：自己给出无参构造方法

4.继承中成员方法的调用特点

依旧引用顶部的代码

4.1代码演示

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
//Fu类
public void show() {
        System.out.println("父类的show方法");
    }
//Zi类
public void show() {
        System.out.println("子类的show方法");
    }
public void zshow() {
        System.out.println("子类的zshow方法");
    }
//调用方法
public class Demo_5 {
    public static void main(String[] args) {
        //继承中调用成员方法
        Zi z = new Zi();
        z.zshow();
        z.show();
    }
}
//会输出
/*
	子类的zshow方法
    父类的show方法
    子类的show方法
*/

4.2继承中调用成员方法总结

继承中成员方法的访问特点

通过子类对象访问一个方法，其顺序为

  • 子类成员范围查找
  • 父类成员范围查找
  • 如果没有就报错(不考虑父亲的父亲…)

5.继承中方法的重写

5.1方法重写概述

  • 子类中出现和父类中一模一样的方法声明

5.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
public class Phone {
    //手机父类
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}
-----------------------------------------------------------------------------------------
public class NewPhone extends Phone {
    //新手机子类
    @Override //如果下方重写方法在父类中不存在则会显示红色虚线
    public void call(String name) {
        System.out.println("打开视频功能");
        super.call(name);
    }
}
-----------------------------------------------------------------------------------------
    public class Demo_6 {
    public static void main(String[] args) {
        //测试调用手机类
        Phone c = new Phone();
        c.call("小明");
        NewPhone c_2 = new NewPhone();
        c_2.call("小红");
    }
}
//输出
/*
	给小明打电话
	打开视频功能
	给小红打电话
*/

ps：上面用到的@Override

  • 是什么：是一个注解(后面会详细说到)
  • 可以干嘛：可以帮助检查重写方法的方法声明的正确性

6.方法重写的注意事项

  • 私有方法(指的是被private关键字修饰的方法)不能被重写（父类私有成员子类是不能继承的）

  • 子类方法访问权限(指的是如果父类中用了默认修饰符，那么子类要么和父类同权限要不就要比父类要高)不能低于父类

6.1代码演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Fu {
    private void show(){
        System.out.println("这是父类中的私有方法");
    }
    void call(){
        System.out.println("这是父类中默认修饰的方法");
    }
}

public class Zi extends Fu {
    @Override  //这里会报错：Method does not override method from its superclass
    public void show(){
        System.out.println("这是父类中的私有方法,在子类中无法使用");
    }
    //要不就下面这种要不就加上public修饰符，总之权限必须高于父类
    void call(){
        System.out.println("这是父类中默认修饰的方法,共有两种方式可访问");
    }
}

7.Java中继承的注意事项

  • Java中类只支持单继承，不支持多继承
  • Java中类支持多层继承

7.1代码演示

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
public class Granddad{
    public void drink(){
        System.out.println("爷爷爱喝酒");
    }
}
public class Father extends Granddad{
    public void smoke(){
        System.out.println("爸爸爱抽烟");
    }
}
public class Mother{
    public void dance(){
        System.out.println("妈妈爱跳舞");
    }
}
public class Son extends Father{
    
}
//以上是正确的多层继承方法：儿子继承父亲————父亲继承祖父
/*
	public class Son extends Father,Mother{
		
	}
*/
//上面这个是错误的继承法因为Java中不支持多继承

8.继承之学生与老师案例

8.1代码演示

8.1.1创建人——类

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
public class Person {
    private String name;
    private int age;

    Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

8.1.2创建老师类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Teacher extends Person {
    //为教师类创建无参构造方法
    public Teacher() {
    }

    //为教师类创建带参构造方法
    public Teacher(String name, int age) {
        super(name, age);
    }

    public void tech() {
        System.out.println("教书育人");
    }
}

8.1.3创建学生类

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Student extends Person {
    public Student (){

    }

    public Student(String name, int age) {
        super(name, age);
    }

    public void study(){
        System.out.println("我是学生，我爱学习");
    }
}

8.1.4创建测试用类

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
//测试类
public class Person_Test {
    public static void main(String[] args) {
        //创建老师类对象
        //无参构造方法
        Teacher t_1 = new Teacher();
        t_1.setName("小明");
        t_1.setAge(23);
        System.out.println("教师姓名：" + t_1.getName() + "\t年龄：" + t_1.getAge());
        t_1.tech();
        //带参构造方法
        Teacher t_2 = new Teacher("小红", 20);
        System.out.println("教师姓名：" + t_2.getName() + "\t年龄：" + t_2.getAge());
        t_2.tech();
        //创建学生类对象
        //无参构造方法
        Student s_1 = new Student();
        s_1.setName("小兰");
        s_1.setAge(18);
        System.out.println("学生姓名：" + s_1.getName() + "\t年龄：" + s_1.getAge());
        s_1.study();
        //带参构造方法
        Student s_2 = new Student("小黄", 19);
        System.out.println("学生姓名：" + s_2.getName() + "\t年龄：" + s_2.getAge());
        s_2.study();
    }
}
//输出结果
/*
    教师姓名：小明	年龄：23
    教书育人
    教师姓名：小红	年龄：20
    教书育人
    学生姓名：小兰	年龄：18
    我是学生，我爱学习
    学生姓名：小黄	年龄：19
    我是学生，我爱学习
*/
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家