继承

最新推荐文章于 2023-09-22 19:02:36 发布

琉璃酱%

最新推荐文章于 2023-09-22 19:02:36 发布

阅读量106

点赞数

文章标签： java

本文链接：https://blog.youkuaiyun.com/m0_47656773/article/details/109045409

版权

继承

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

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

3.JAVA中类只有单继承，没有多继承!（一个儿子只能有一个爸爸，但一个爸爸可以有多个儿子

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

5.继承关系的俩个类， - 个为子类(派生类),-个为父类(基类)。子类继承父类使用关键字extends来表示。

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

示例：

package oop.demo05;

// 在Java中，所有的类，都默认直接或间接继承Object
// Person 人
public class Person /*extends Object*/ {

     // 优先级排序
     // public
     // protected
     // default
     // private
     private int money = 10_0000_0000;
     public void say(){
         System.out.println("说了一句话");
     }

     public int getMoney() {
         return money;
     }

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

package oop.demo05;

// Student is 人 ：派生类，子类
// 子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{

// Ctrl+H 查看继承结构树

}

package oop;

import oop.demo05.Student;

public class Application {

    public static void main(String[] args) {

        Student student = new Student();
        student.say();

    }

}

7.object类

在Java中，所有的类，都默认直接或间接继承Object

8.super - this

super注意点:

super 调用父类的构造方法，必须在构造方法的第一个
super 必须只能出现在子类的方法或者构造方法中!
super 和 this不能同时调用构造方法!

VS this:

代表的对象不同:

this : 本身调用的这个对象

super : 代表父类对象的引用

前提：

this : 没有继承也可以使用

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

构造方法：

this() : 本类的构造

super() : 父类的构造

示例：

无参构造

父类：

package oop.demo05;

// 在Java中，所有的类，都默认直接或间接继承Object
// Person 人
public class Person /*extends Object*/ {

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

    protected String name = "kuangshen";

     // 私有的东西无法被继承！
     public void print(){
         System.out.println("Person");
     }

 }

子类

package oop.demo05;

// Student is 人 ：派生类，子类
// 子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{

    public Student() {
        // 隐藏代码(super())：调用了父类的无参构造
        super();  // 调用父类的构造器，必须要在子类构造器的第一行（这句代码不写也是正常的）
        System.out.println("Student无参执行了");
    }

    private String name = "qinjiang";

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

    public void test(String name){
        System.out.println(name);       // 秦疆
        System.out.println(this.name);  // qinjiang
        System.out.println(super.name); // kuangshen
    }

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

}

在main方法中运行

package oop;

import oop.demo05.Student;

public class Application {

    public static void main(String[] args) {

        Student student = new Student();
        student.test("秦疆");
        student.test1();

    }

}

输出结果为：

Person无参执行了
Student无参执行了
秦疆
qinjiang
kuangshen
Student
Student
Person

当你想调用父类的有参构造时，在子类加一个参数就行

父类

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

子类

public Student() {
        // 隐藏代码(super())：调用了父类的无参构造
        super("name");  // 调用父类的构造器，必须要在子类构造器的第一行（这句代码不写也是正常的）
        System.out.println("Student无参执行了");
    }

输出结果不变

9.方法重写：重点—>多态

重写:需要有继承关系，子类重写父类的方法!

1.方法名必须相同

2.谷数列表列表必须相同

3.修饰符：范围可以扩大，但不能缩小：public > Protected > Default > private
4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必须一致，方法体不同!

为什么需要重写:

父类的功能，了类不一定需要，或者不一定满足 !

快捷键：

Alt + Insert 或者右键选择Generate
然后选择Override，然后点击OK就行

静态方法：（没有重写）

父类

package oop.demo05;

// 重写都是方法的重写，和属性无关
public class B {

    public static void test(){
        System.out.println("B=>test()");
    }

}

子类

package oop.demo05;

// 继承
public class A extends B{

    public static void test(){
        System.out.println("A=>test()");
    }

}

在main方法中调用

package oop;

import oop.demo05.A;
import oop.demo05.B;

public class Application {

    public static void main(String[] args) {

        // 方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();        // A

        // 父类的引用指向了子类的对象
        B b = new A();   // B
        b.test();
    }

}

输出结果为：

A=>test()
B=>test()

**非静态，可以选择重写：**旁边有圆圈有箭头才是重写

父类

public class B {

    public void test(){
        System.out.println("B=>test()");
    }

}

子类

public class A extends B{

    // Override 重写
    @Override // 注解：有功能的注释！
    public void test() {
        System.out.println("A=>test()");
    }
}

在main方法中调用

public class Application {

    // 静态的方法和非静态的方法差别很大！
    // 静态方法：方法的调用只和左边定义的数据类型有关
    public static void main(String[] args) {

        A a = new A();
        a.test();        // A

        // 父类的引用指向了子类的对象
        B b = new A();   // 子类重写了父类的方法
        b.test();
    }

}