Java基础系列15-面向对象之继承

落日映苍穹つ 2022-09-05 04:20 211阅读 0赞

### 文章目录 ###

*  一.继承概述
 *   *  1.1 继承的好处和弊端
     *  1.2 Java中继承的特点
     *  1.3 Java继承中成员变量的特点
     *  1.4 继承案例
     *   *  1.4.1 父子类案例
         *  1.4.2 多重继承案例
 *  二. super关键字以及继承中的方法重写
 *   *  2.1 super关键字的概述和使用
     *  2.2 Java继承中构造方法的特点
     *  2.3 Java继承中成员方法的特点
     *  2.4 方法重写的概述和使用
 *  参考:

# 一.继承概述 #

继承的概述:

1.  多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类(extends)即可.
2.  单独的这个类称为父类，基类或者叫超类，多个类可以称为子类或者派生类.
3.  有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员.

实现继承的方式：

1.  通过extends关键字可以实现类与类的继承
2.  格式：public class 子类名 extends 父类名\{\}

## 1.1 继承的好处和弊端 ##

继承的好处:

1.  提高了代码的复用性，多个类相同的成员可以放到同一个类中;
2.  提高了代码的维护性，如果功能的代码需要修改，修改一处即可;
3.  让类与类之间产生了关系，是多态的前提，好处的第三点同时也是继承的弊端。

继承的弊端:  
类与类之间产生了关系，让类的耦合性增强了

## 1.2 Java中继承的特点 ##

1.  Java中只支持单继承，不支持多继承  
    1)一个类只能有一个父类，不可以有多个父类  
    public class Son extends Father\{\} // ok  
    public class Son extends Father,GrandFather // Error
2.  Java中类支持多层继承(继承体系)  
    Public class GrandFather\{\}  
    Public class Father extends GrandFather\{\}  
    Public class Son extends Father\{\}

## 1.3 Java继承中成员变量的特点 ##

A.局部变量
      a.定义位置：定义在局部范围中，如：函数内，语句内等;
      b.初始值：无,先定义,赋值后才能使用;
      c.调用方式：- - -
      d.作用域： 只在所属的区域有效;
      e.物理存储： 存储在 虚拟机栈(JVM Stack) 中（栈内存分为：虚拟机栈和本地方法栈）;
    变量名 和 值 都在虚拟机栈(JVM Stack)的栈帧(Stack Frame) 的 局部变量表(Local Variable Table) 中;
      f.生命周期：与方法共存亡，随着方法的调用而存在，随着方法调用完毕自动回收释放;
    
    B.成员变量（别名：实例变量）
      a.定义位置：在类中,方法外;
      b.初始值：有默认初始化值;
      c.调用方式：对象调用;
      d.作用域：在整个类中都可以被访问;
      e.物理存储：
        对象的实例存储在 堆内存(Heap) 中。堆内存速度慢、成本低、空间较大。这个堆内存会有一个内存地址;
        对象的引用存储在 ==虚拟机栈(JVM Stack)中
      f.生命周期：与对象共存亡，随着对象的创建而存在，随着对象被回收而释放;
    
    C.静态变量（别名：类变量）
      a.定义位置：由staic修饰的，在类中,方法外;
      b.初始值：有默认初始化值;
      c.调用方式：对象调用，类名调用;
      d.作用域：全局中都能使用、被所有对象所共享;
      e.物理存储：存储在 方法区(Method Area) 的 静态域(Static Field) 中;
      f.生命周期：与类共存亡，随着类的加载而存在，随着类的消失而消失。

成员变量名称不一样，使用的时候非常简单  
成员变量名称一样的情况：  
 在子类中访问变量：（就近原则）  
  在方法的局部范围找，如果有就使用  
  在子类的成员范围找，如果有就使用  
  在父类的成员范围找，如果有就使用  
  如果还找不到 就报错

![image.png][]

## 1.4 继承案例 ##

### 1.4.1 父子类案例 ###

接下来，我们创建一个父子类，父类是人类的类，子类是学生类，然后学生类继承人类 类。

**代码:**  
jicheng1类

package Java_study;
    /**
     * 
     * @author    只是甲
     * @date      2021-6-24
     * @remark    继承案例1, 人类 类
     *
     */
    public class jicheng1 {
    	private String name;
    	private int age;
    	
    	/**
    	 * @remark 无参构造
    	 */
    	public jicheng1() {
    		
    	}
    	
    	/**
    	 * @remark  全参构造
    	 * @param   name
    	 * @param   age
    	 */
    	public jicheng1(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;
    	}
    
    }

student\_new类

package Java_study;
    
    /**
     * @author   只是甲
     * @date     2021-06-24
     * @remark   学生类,继承人类类
     */
    public class student_new extends jicheng1 {
    	public void teach() {
    		System.out.println("老师要好好讲课");
    	}
    }

jicheng\_test

package Java_study;
    
    /**
     * @author   只是甲
     * @date     2021-06-24
     * @remark   测试类
     */
    public class jicheng_test{
    	public static void main(String[] args) {
    		//创建对象
    		student_new student1 = new student_new();
    		
    		//调用父类方法
    		student1.setName("杜兰特");
    	    student1.setAge(32);
    		System.out.println("学生姓名:" + student1.getName());
    		System.out.println("学生年龄:" + student1.getAge());
    		
    		//调用子类方法
    		student1.teach();
    	}
    }

**测试记录:**

学生姓名:杜兰特
    学生年龄:32
    老师要好好讲课

### 1.4.2 多重继承案例 ###

接下来是一个多重继承的，祖父、父亲、儿子三个类。

**代码:**  
grandFather类:

package Java_study;
    
    /**
     * 
     * @author  Administrator
     * @date    2021-06-24
     * @remark  多重继承祖父类
     */
    public class grandFather {
    	public void grandFatherSay() {
    		System.out.println("爷爷都是从孙子熬过来的");
    	}
    }

father类

package Java_study;
    
    /**
     * 
     * @author  Administrator
     * @date    2021-06-24
     * @remark  多重继承父类
     */
    public class father extends grandFather {
    	public void fatherSay() {
    		System.out.println("爸爸都是从儿子走过来的");
    	}
    
    }

son类

package Java_study;
    
    /**
     * 
     * @author  Administrator
     * @date    2021-06-24
     * @remark  多重继承子类
     */
    public class son extends father {
    	public static void main(String[] args) {
    		father son = new father();
    		son.fatherSay();
    		son.grandFatherSay();
    	}
    
    }

**测试记录：**

爸爸都是从儿子走过来的
    爷爷都是从孙子熬过来的

# 二. super关键字以及继承中的方法重写 #

## 2.1 super关键字的概述和使用 ##

super的用法和this很像  
  this代表本类对象的引用  
  super代表父类存储空间的标识（可以理解为父类对象引用）  
  super（）且放在第一行 ； 目的是在初始化当前对象时，先保证了父类对象先初始化 。

**用法（this和super均可如下使用）**  
  访问成员变量  
    this.成员变量  
    super.成员变量  
  访问构造方法  
    this(…)  
    super(…)  
  访问成员方法  
    this.成员方法()  
    super.成员方法()

**构造方法中this()或者super()要放在第一行**

1.  在构造函数中，如果你不指定 构造器之间的调用关系 ，那么编译器会给你加上 super（）且放在第一行 ； 目的是在初始化当前对象时，先保证了父类对象先初始化 。所以，你指定了构造函数间的调用，那么this（）必须在第一行，以保证在执行任何动作前，对象已经完成了初始化。
2.  构造函数只能被构造函数调用，因为对象只会初始化一次。  
    this()和super()这样的方法被称为构造方法，顾名思义，他的作用就是在JVM堆中构建出一个指定类型的对象，如果你调用了两个这种形式的方法，岂不是代表着构建出了两个对象。
3.  同理，为了避免构建出两个对象这种问题的出现，Java在编译时对这种情况做了强校验， 用户不能再同一个方法内调用多次this()或super()，同时为了避免对对象本身进行操作时，对象本身还未构建成功(也就找不到对应对象),所以对this()或super()的调用只能在构造方法中的第一行实现，防止异常。
4.  在普通的成员方法中，如果调用super()或者this()，你是想要重新创建一个对象吗？抱歉Java为了保证自身对象的合理性，不允许你做这样的操作。

**代码:**  
super1

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-25
     * @remark  人类父类   super关键字概述
     *
     */
    public class super1 {
    	//为了演示案例的方便，这里我们使用public修饰了成员变量，实际开发中，修饰符使用private
        //年龄
    	public int age = 45;//c:在父类的成员范围找，如果有就使用
    }

super2

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-25
     * @remark  人类子类   super关键字概述
     *
     */
    public class super2 extends super1 {
    	// 年龄
    	public int age = 20;
    	
    	public void printAge() {
    		int age = 10;
    		//我要访问局部范围的age?//10
    		System.out.println(age);
    		//我要访问成员范围的age
    		System.out.println(this.age);
    		//我要访问父类成员范围的age? //45
    		System.out.println(super.age);
    	}
    }

super3

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-25
     * @remark  人类测试类   super关键字概述
     *
     */
    public class super3 {
    	public static void main(String[] args) {
    		super2 s = new super2();
    		//s.show();
    		//10
    		//20
    		//45
    		s.printAge();
    	}
    
    }

## 2.2 Java继承中构造方法的特点 ##

子类所有构造方法都默认访问父类的空参数的构造方法  
为什么呢？  
  因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化  
  每一个构造方法的第一条默认语句都是super

如果父类中没有构造方法，该怎么办呢？  
  在父类中加一个无参的构造方法  
  通过使用super关键字去显示的调用父类的带参构造方法  
  通过这里我们发现第一种解决方案最简单，所以，建议我们自定义类的时候永远自己给出无参构造方法

**代码:**  
jicheng\_gouzao1

package Java_study;
    /**
     * 
     * @author   只是甲
     * @date     2021-06-25
     * @remark   人类父类   Java继承中构造方法的访问特点
     *
     */
    
    public class jicheng_gouzao1 {
    	/**
    	 * @remark  Father无参构造方法
    	 */
    	public jicheng_gouzao1() {
    		System.out.println("Father无参构造方法");
    	}
    	
    	/**
    	 * @remark  Father带参构造方法
    	 * @param   name  姓名
    	 */
    	public jicheng_gouzao1(String name) {
    		System.out.println("Father带参构造方法");
    		System.out.println("father:" + name);
    	}
    
    }

jicheng\_gouzao2

package Java_study;
    
    /**
     * 
     * @author   只是甲
     * @date     2021-06-25
     * @remark   人类子类   Java继承中构造方法的访问特点
     *
     */
    public class jicheng_gouzao2 extends jicheng_gouzao1 {
    	String name;
    	public jicheng_gouzao2() {
    		//super();
    		System.out.println("Son无参构造方法");
    	}
    	
    	public jicheng_gouzao2(String name) {
    		super( name);
    		//this();
    		System.out.println("Sone带参构造方法");
    		System.out.println("son:" + name);
    	}
    
    }

jicheng\_gouzao3

package Java_study;
    
    /**
     * 
     * @author   只是甲
     * @date     2021-06-25
     * @remark   人类测试类   Java继承中构造方法的访问特点
     *
     */
    public class jicheng_gouzao3 {
    	public static void main(String[] args) {
    		/*
            Father无参构造方法
            Son无参构造方法
            */
    		jicheng_gouzao2 s1 = new jicheng_gouzao2();
    		
    		System.out.println("----------");
    		
    		/*
            Father带参构造方法
            father:杜兰特
            Son带参构造方法
            son:杜兰特
            */
    		jicheng_gouzao2 s2 = new jicheng_gouzao2("杜兰特");
    	}
    
    }

**测试记录:**

Father无参构造方法
    Son无参构造方法
    ----------
    Father带参构造方法
    father:杜兰特
    Sone带参构造方法
    son:杜兰特

## 2.3 Java继承中成员方法的特点 ##

通过子类对象去访问一个方法

1.  首先在子类中找
2.  然后在父类中找
3.  如果还是没有就会报错

**代码:**  
jicheng\_chengyuan1

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-25
     * @remark  人类父类  Java继承中成员方法的访问特点
     *
     */
    public class jicheng_chengyuan1 {
    	public void method() {
    		System.out.println("Father method");
    	}
    	
    	public void show() {
    		System.out.println("Father show");
    	}
    }

jicheng\_chengyuan2

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-25
     * @remark  人类子类  Java继承中成员方法的访问特点
     *
     */
    public class jicheng_chengyuan2 extends jicheng_chengyuan1 {
    	@Override
    	public void method() {
    		super.method();
    	}
    	
    	/**
    	 * @remark  重写父类方法
    	 */
    	@Override
    	public void show() {
    		System.out.println("Son show");
    	}
    }

jicheng\_chengyuan3

package Java_study;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-06-25
     * @remark  人类测试类  Java继承中成员方法的访问特点
     *
     */
    public class jicheng_chengyuan3 {
    	public static void main(String[] args) {
    		jicheng_chengyuan2 s = new jicheng_chengyuan2();
    		
    		//直接调用父类的method方法：Father method
    		s.method();
    		
    		//重写了父类的show方法：Son show
    		s.show();
    	}
    
    }

**测试记录：**

Father method
    Son show

## 2.4 方法重写的概述和使用 ##

方法重写的概述：  
  方法重写：子类中出现了和父类中一摸一样的方法声明

方法重写的应用:  
  当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写中的方法，这样重写父类中的方法  
  这样，即沿袭了父类的功能，又定义了子类特有的内容

方法重写的注意事项：

1.  注解  
    @Override表明该方法的重写父类的方法
2.  方法重写的注意事项  
    1)父类中私有方法不能被重写  
    2)子类重写父类方法时，访问权限不能更低  
    3)子类重写父类方法时，建议访问权限一摸一样

具体案例可以参考上一节2.3。

# 参考: #

1.  https://blog.csdn.net/qq\_43529621/article/details/115209518

[image.png]: /images/20220829/954ce86b5515462db1baf910920e632d.png