面向对象的继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思是“扩展”。子类是父类的扩展。

JAVA中类只有单继承，没有多继承。(一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）

继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

子类和父类之间，从意义上讲应该具有“ is a"的关系。

子类与父类的体现：

package com.rgf.oop.Demo06;

public class Application {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.say();
        System.out.println(stu1.getMoney());
    }
}

package com.rgf.oop.Demo06;
//Person人类，父类
public class Person {
    //public  公共访问权限
    //private   私有访问权限
    //default  默认访问权限
    //protected 受保护的访问权限

        private   int money=1_0000_0000;
        public void say( ){
            System.out.println("说了一句话");
        }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

package com.rgf.oop.Demo06;
//学生 is 人，派生类（子类）
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    //除了继承之外，还可以采用组合的方法，将人组合到里面变成一个属性
    //Person person;采用组合的方法
    //ctrl+h,会体现出继承的关系
}

package com.rgf.oop.Demo06;
//Teacher is 人，派生类（子类）
public class Teacher extends Person {
}

运行界面如下：

通过其他方法体现出object类

按住ctrl,点击String，进入该页面

 

我们发现没有extends,我们点击ctrl+h,发现如下所示的关系。

 

一、继承性的好处：

1.减少了代码的冗余，提高了代码的复用性

2.便于功能的扩展。

3.为之后多态性的使用，提供了前提

二、继承性的格式：class A  extends  B{ }

A:子类、派生类、subclass

B:父类、超类、基类、superclass

2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性，方法。

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。

2.2子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的扩展。

extends:延展、扩展。

三、java只支持单继承和多层继承，不允许多重继承

1.java中类的单继承性：一个子类只能有一个父类

2.一个父类可以派生出多个子类

子类和父类的关系，不同于子集和集合的关系。

四、Java中关于继承性的规定：

1.一个类可以被多个子类继承

2.Java中类的单继承性，一个类只能有一个父类

3.子父类是相对的概念

4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。

5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。

五、

1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类

2.所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类

3.意味着，所有的java类具有java.lang.Object类声明的功能。

super关键字的体现：

super关键字的使用：

1.super理解为：父类的

2.super可以用来调用，属性、方法、构造器。

我们创建如下示例：

父类：

package com.hy;

public class Person {

    String name;
    int age;
    int id=1001;
    public Person(){
        System.out.println("我无处不在");
    }
    public  Person(String name){
        this.name=name;
    }
    public Person(String name,int age){
        this(name);
        this.age=age;
    }

    public  void eat(){
        System.out.println("人，吃饭");
    }

    public void walk(){
        System.out.println("人，走路");
    }
}

子类：

package com.hy;

public class Student extends Person{
  String major;
  int id=1002;
  public  Student(){
       super();
  }
public Student(String name,int age,String major){
     super(name,age);
      this.major=major;

}
  public Student(String major){
      this.major=major;
  }


    public void eat() {
        System.out.println("学生，多吃有营养的食物");


    }

    public void study(){
        System.out.println("学生，学习知识");
        super.eat();
    }

    public void  show(){
        System.out.println("name="+this.name+",age="+this.age);
        System.out.println("id="+super.id);
    }
}

测试类为：

package com.hy;

/**
 * super关键字的使用：
 * 1.super理解为：父类的
 * 2.super可以用来调用，属性、方法、构造器。
 * 3.super的使用，调用属性和方法
 * 3.1我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法，
 * 但是，通常情况下，我们习惯省略““super.”
 * 3.2特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的
 * 方式，表明调用的是父类中声明的属性。
 * 3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.方法”
 * 的方式，表明调用的是父类中被重写的方法。
 * 4.super调用构造器
 *4.1我们可以在子类的构造器中显式的使用“super(形参列表）”的方式，调用父类中声明的构造器
 *4.2“super(形参列表）”的使用，必须声明在子类构造器的首行!
 *4.3我们在类的构造器中，针对于“this(形参列表）”或“super(形参列表）”只能二选一,不能同时出现
 *4.4在构造器的首行，没有显式的声明“this(形参列表）”或“super(形参列表）”，则默认调用的是父类中空参的构造器：super()
 *4.5在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表）”，调用父类中的构造器
 */
public class PersonTest {
    public static void main(String[] args) {
        Student student = new Student("it");
        student.study();
        Student s1 = new Student("Tom", 12, "计算机");
        s1.show();

    }
}

运行之后如下所示：

 

子类对象实例化：

子类对象实例化的全过程 ：

1.从结果上来看，（继承性） *子类继承父类以后，就获取了父类中声明的属性或方法，创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

 2.从过程上来看，  当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用父类的构造器，，进而调用父类的构造器, *直到调用了java.lang.Object类中空参的构造器为止，正因为加载过所有的父类的结构， *所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

 super里面访问成员变量和成员方法的详细代码：

package com.rgf.oop.Demo07;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("love");
        student.print();
    }
}

package com.rgf.oop.Demo07;
//学生  is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法。
public class Student extends Person {
    private String name = "ypl";

   
    public void test(String name) {
        System.out.println(name);//love
        System.out.println(this.name);//ypl
        System.out.println(super.name);//rgf
    }

    public void print() {
        System.out.println("Student");
    }

    public void test1() {
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}

package com.rgf.oop.Demo07;
//在java中，所有的类，都默认直接或者间接继承object.
//Person 人：父类
public class Person {
   //private String name="rgf";  私有的东西无法被继承
   protected String name="rgf";

   

   public void print(){
      System.out.println("Person");
   }



}

运行界面如下：

 super要调用父类的构造器时，必须要在子类构造器的第一行。

package com.rgf.oop.Demo07;
//学生  is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法。
public class Student extends Person {
    private String name = "ypl";
//隐藏代码：调用了父类的无参构造
    public Student() {
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

}

package com.rgf.oop.Demo07;
//在java中，所有的类，都默认直接或者间接继承object.
//Person 人：父类
public class Person {
   //private String name="rgf";  私有的东西无法被继承
   protected String name="rgf";

   public Person() {
      System.out.println("Person无参执行了");
   }

}

package com.rgf.oop.Demo07;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();

    }
}

运行界面如下：

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一行。

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法。

super和this的不同点：

代表的对象不同：

this：本身调用者这个对象

super:代表父类对象的引用

前提：

this:没有继承也可以使用

super:只能在继承条件下才可以使用

构造方法不同：

this:本类的构造

super:父类的构造

子类对象实例化过程：