后端学习第一周

m0_74973803

已于 2023-03-24 17:26:20 修改

阅读量455

点赞数

文章标签：学习

于 2023-03-24 17:23:19 首次发布

本文链接：https://blog.csdn.net/m0_74973803/article/details/129710808

版权

一、Java基础

一、继承

“不要去重新发明车轮，而是去改善它。”继承，面向对象编程的三大特性之一，让我们更加容易实现类的扩展，实现代码重用。

1. 继承的两个主要作用

1.代码复用，更容易实现类的扩展。

2.方便建模。

2.继承的实现

这是现实世界中的继承。哺乳动物继承了动物等等特性，而狗又继承了哺乳动物的特性。

Java中，我们用extends实现类的继承。

比如

package Java;

public class TestExtends {
    public static void main(String[] args) {
        Student stu = new Student("cqk", 1, "Java");
        System.out.println(stu.name);//可以使用Person中的name属性
        stu.rest();//可以调用Person中的rest方法
        System.out.println("stu是Student类吗：" + (stu instanceof Student));
        System.out.println("stu是Person类吗：" + (stu instanceof Person));
        System.out.println("stu是Object类吗：" + (stu instanceof Object));
    }
}

class Person {//没有跟extends的话编译器自动加：extends Object
    //类Person中定义了两个属性和一个方法。
    String name;
    int height;
    public void rest(){
        System.out.println("我要休息！");
    }

    public Person(String name, int height) {
        this.name = name;
        this.height = height;
    }
}

class Student extends Person{//Student会继承Person的属性和方法
    String major;//Student中新定义的属性
    public void study(){//Student中新定义的方法
        System.out.println("我在学习！");
    }

    public Student(String name, int height, String major) {
        super(name, height);
        this.major = major;
    }
}

我们定义一个Person类，然后定义一个Student类，并用语句

        class Student extends Person

使Student继承Person的属性和方法，此时Student是子类，Person是父类， 子类是父类的扩展。除此之外Student中我们定义自己的major属性和study方法。

于是可以看到，在main方法中，Student类对象stu具有name、rest等Person中定义的属性和方法，可以进行调用，说明子类会继承父类的属性和方法。

3. Object类

如上代码所示，Person类未加extends，那么是否意味着Person类没有父类呢？其实不然，对于没有extends的类，编译器会在其后自动加extends Object。也就是说，没有加extends的类的父类都是Object类。Object类是java.lang包中的一个类（Ctrl + 单击可以查看）。（不展开叙述）

4. instanceof运算符

instanceof运算符是二元运算符，左边是对象，右边是类，当对象是右边类或其子类所创建的对象时，返回true，否则返回false。

如上代码，main方法中，最后三个打印的语句打印了stu是否是Student、Person、Object类的（即，是否是它们及其子类所创建），其中instanceof语句的结果均为true，说明stu是它们及其子类所创建的。

5. 继承的其他使用要点

1. 父类也称作超类、基类；子类也被称作派生类等。

2. Java中类只有单继承，没有像c++那样的多继承，多继承会引起混乱，使得继承链过于复杂，系统难以维护。

3. 子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（比如，父类私有的属性和方法）（在封装中在深入研究）

6. 方法的重写override

不同的人群，休息的方式有区别，那么Person的不同子类想要有不同的rest方法，怎样实现？我们可以用override。

子类重写父类的方法，可以用自身行为替换父类行为。重写是实现多态的必要条件。

用具体代码说明。

package Java;

public class TestExtends {
    public static void main(String[] args) {
        Student stu = new Student("cqk", 1, "Java");
        Worker w = new Worker("w", 1);
        stu.rest();//输出"苦逼学生只能趴在书桌上休息！"
        w.rest();//输出"苦逼上班族也只能趴在工位上休息啊！！"
    }
}

class Person extends Object{
    String name;
    int height;
    public void rest(){
        System.out.println("我要休息！");
    }

    public Person(String name, int height) {
        this.name = name;
        this.height = height;
    }
}

class Student extends Person{
    String major;
    public void study(){
        System.out.println("我在学习！");
    }

    @Override
    public void rest() {//重写Student的rest方法
        System.out.println("苦逼学生只能趴在书桌上休息！");
    }

    public Student(String name, int height, String major) {
        super(name, height);
        this.major = major;
    }
}

class Worker extends Person {//定义了一个新的类worker，是Person的子类
    public Worker(String name, int height) {
        super(name, height);
    }

    @Override
    public void rest() {//重写Worker的rest方法
        System.out.println("苦逼上班族也只能趴在工位上休息啊！！");
    }
}

首先我们重写Student的rest，使得Student有自己休息的方式，即趴在书桌上。我们又定义了一个新类Worker，继承了Person，其中重写rest，让上班族趴在工位上休息。

main方法中，分别调用rest，可以分别输出他们对应的rest方式，而不是输出Person中的“我要休息！”。这说明，子类中重写了的rest方法覆盖了父类的方法，使得调用的时候执行子类中重写的方法。但父类的方法依然存在，我们在之后讨论super的时候再详细展开吧。

方法重写需要符合下面的三个要点：

1. “==” ：方法名、形参列表相同。

2. “≤”：返回值类型和声明异常类型，子类小于等于父类。

3. “≥”：访问权限，子类大于等于父类。

字面意思，限于篇幅，不展开详述。

7. 继承和组合

我们考虑怎样不用继承来实现代码复用，那我们就用组合。组合核心是：“将父类的对象作为子类的属性”。下面我们就用组合实现之前继承的代码。

package Java;

import java.sql.PreparedStatement;

public class TestExtends {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.p.name = "cqk";
        stu.study();//输出"cqk在学习！"
    }
}

class Person extends Object{
    String name;
    int height;
    public void rest(){
        System.out.println("我要休息！");
    }

}

class Student {//不用extends
    Person p = new Person();//new一个Person的对象作为我Student的属性
    String major;
    public void study(){
        System.out.println(this.p.name + "在学习！");//调用name时，需要这样输入this.p.name
    }

}

这次我们定义Student时不用extends，而是用了组合，new了一个Person的对象p作为我Student的一个属性，这样我依然可以调用Person中的属性和方法。如Student的study方法中，我用this.p.name调用了对象p的属性name。并且我在main方中可以一样，直接调用stu.p.name和用了study方法调用了stu.p.name。于是我们就不用继承而实现了代码复用。

但有人会因此认为组合优于继承，我们都应该用组合而不是用继承。诚然，组合更灵活，我可以在一个类中定义多个不同类的对象，从而拥有多个父类。但是别忘了，继承不只代码复用这一个作用，它还能更方便建模，即构建类之间的逻辑关系，就像上面第一张图“现实世界中的继承”那样。因此，我们一般对于构建逻辑关系时，“is-a”关系建议使用继承，“has-a”关系建议使用组合，如上面的Person和Student的关系就属于“is-a”关系，我们用继承会好些；而对于像“手机”和“芯片”这样的关系我们认为是“has-a”关系，可以用组合。

二、封装

为了方便使用，各种商品化的科技产物总是倾向于封装复杂的内部件，只留尽量少的与外界的部件，比如手机，从键盘演化到触屏，从电池可拆演化到完全一体。我们的程序设计也可以一样，追求“高内聚，低耦合”，高耦合即类的内部数据操作细节自己完成，不允许外部干涉；低耦合则是仅暴露少量的方法给外部使用，尽量方便外部调用。这就是封装。

封装的优点

1. 提高代码的安全性。

2. 提高代码的复用性。

3. “高内聚”︰封装细节，便于修改内部代码，提高可维护性。

4. “低耦合”︰简化外部调用，便于调用者使用，便于扩展和协作。