面向对象02

最新推荐文章于 2024-05-10 08:04:03 发布

華同学.

最新推荐文章于 2024-05-10 08:04:03 发布

阅读量225

点赞数

分类专栏：继承后端文章标签： java

本文链接：https://blog.csdn.net/weixin_50769390/article/details/125878440

版权

后端同时被 2 个专栏收录

52 篇文章 1 订阅

订阅专栏

继承

2 篇文章 0 订阅

订阅专栏

继承

继承是面向对象三大特征之一。 ( 封装，继承，多态）

可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

1.1继承的格式：

public class 子类名 extends 父类名 { }

public class Zi extends Fu { }

Zi：是子类，也是派生类。

Fu: 是父类，也是基类，超类

代码演示：

父类：

public class Fu {
    private String name;
    private int age;

//    满参
    public Fu(String name, int age) {
        this.name = name;
        this.age = age;
    }
//无参
    public Fu() {
    }

//    get set 方法

    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;
    }
    public void show(){
        System.out.println("姓名：" + name + "年龄：" + age);
    }
}

子类：子类继承父类

public class Zi extends Fu{
    public void method(){
        System.out.println("method方法被调用！");
    }
}

测试类：

public class Demo {
    public static void main(String[] args) {
//        父类创建对象
        Fu f1 = new Fu("张三",20);
        f1.show();//姓名：张三年龄：20

//        子类创建对象
        Zi z1 = new Zi();
        z1.setName("李四");
        z1.setAge(19);

//        可以继承父类的属性和方法
//        子类也有自己的属性和方法
        z1.show();//姓名：李四年龄：19
        z1.method();//method方法被调用！


    }
}

继承中子类的特点

1.子类可以有父类的内容

2.子类还可以有自己特有的内容

继承的好处和弊端

好处：

提高了代码的 复用性 ( 多个类相同的成员可以放到同一个类中 )

提高了代码的 维护性 ( 如果方法的代码需要修改，修改一处即可 )

弊端：

继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

什么时候需要继承：

我有两个类 A 和 B ，如果他们满足 A 是 B 的一种，或者 B 是 A 的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承

举例：苹果和水果，猫和动物， 猫和狗

继承中访问成员变量特点：

在子类方法中访问一个变量

* 1.子类局部范围

* 2.子类成员范围

* 3.父类成员范围

* 4.如果没有就会报错

super关键字：

this关键字和super关键字：

父类：

public class Fu {
//    为了访问方便，年龄我们用public进行了修饰。
    public int age = 54;
    public void show(){
        System.out.println("我是show()方法");
    }
}

子类：


/*
* this :代表当前对象
*   this.成员属性  一般用于局部变量 和 成员变量区别
*   this.方法名（） 成员方法  默认this.调用
*   this() 调用本类的无参构造方法
*   this(参数列表) 调用本类的有参
*
* 注意：
*   this() this(参数) 必须放在第一行
* *
*
* 以后this 和 super 使用场景
*   this 用在成员变量 和局部变量 重名时
*   调用 本类其他构造方法时
*
* super
*   1.调用父类的有参构造时 使用
*   2.将这个属性值传递给父类
*
* */
public class Zi extends Fu{
    public int age = 20;
    public void mesther(){
        int age = 30;
        System.out.println("我是mether方法" + "age:   " + age);
    }
    public void ziShow(){
        System.out.println("年龄：" + age);
    }
//    super 关键字使用

    public void superShiYong(){
//        访问当前子元素 的成员变量 this.
//        this：代表调用该方法的对象
//        (一般我们是在当前类中使用this，所以我们常说this代表本类对象的引用)
        System.out.println("访问当前子元素的成员变量 ：this.age   " + this.age);
//        super：代表父类存储空间的标识
//        (可以理解为父类对象引用)
        System.out.println("访问父元素的成员变量 super.age       " + super.age);
    }
}

this ：代表调用该方法的对象 ( 一般我们是在当前类中使用 this ，所以我们常说 this 代表本类对象的引用 )

super ：代表父类存储空间的标识 ( 可以理解为父类对象引用 )

构造方法访问特点

***子类中所有的构造方法默认都会访问父类中无参的构造方法***

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化

每一个子类构造方法的第一条语句默认都是： super()

父类：

public class Fu {

//    构造方法
    public Fu(int age) {
        System.out.println("父类有参构造方法被调用");
    }
//    public Fu() {
//        System.out.println("父类无参构造方法被调用");
//    }
}

/*
* 所有子类构造方法中：
*   第一行 默认 super()
*
* 也就是说：在子类创建对象前，先创建父类对象
*
* 执行流程：
*   先加载父类 后加载子类
*   先创建父类对象 在创建子类对象
*   所有子类的构造方法第一行 默认super()
*
*
*
* */
public class Zi extends Fu{

    public Zi() {
//        super();
//        可以对父类的数据进行初始化
        super(20);
        System.out.println("子类无参构造方法被调用");
    }
    public Zi(int age) {
//        super();
        super(20);
        System.out.println("子类有参构造方法被调用");
    }
}

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

① 通过使用 super 关键字去显示的调用父类的带参构造方法

② 在父类中自己提供一个无参构造方法****推荐

成员方法访问：

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

1.子类成员范围找

2.父类成员范围找

3.如果都没有就报错 ( 不考虑父亲的父亲 …)

方法重写：

什么是方法重写？子类中出现了和父类中一模一样的方法声明

方法重写的应用场景：

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

重写案例：

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("给"+name+"开启视频");
        super.call(name);
    }
}

public class NewPhone extends Phone{
//可以帮助我们检查重写方法的方法声明的正确性
    @Override//是一个注解(注解后面会学习到)
    public void call(String name){
        System.out.println("给"+name+"开启视频");
        super.call(name);
    }
}

继承案例：

公共类：

//公共类
public class Common {
//    protected String name;
    private String name;
    private int age;

    public Common(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Common() {
    }

    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;
    }
}

学生类继承公共类：

public class Student extends Common{
//    学号
    private int id;
//    构造方法
    public Student() {
    }
    public Student(String name, int age) {
//        将 name age 传递给 父类
        super(name, age);
    }
//  getset
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
//    学习方法
    public void study(){
        System.out.println("好好学习");
    }
}

老师类继承公共类：

public class Teacher extends Common{
//    构造方法
    public Teacher(String name, int age) {
//        继承父类的name ，age
        super(name, age);
    }
    public Teacher() {
    }

//    方法
    public void teach(){
        System.out.println("教学员");
    }

}

//需求：定义老师类和学生类，然后写代码测试；
// 最后找到老师类和学生类当中的共性内容，
// 抽取出一个父类，用继承的方式改写代码，并进行测试
public class Demo {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        t1.teach();

        Student s1 = new Student();
        s1.study();
    }
}