后端学习第2周

m0_74973803

已于 2023-04-08 08:57:22 修改

阅读量64

点赞数

文章标签： html servlet 后端

于 2023-04-01 16:41:48 首次发布

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

版权

一、继承

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

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. 声明格式

[访问修饰符] interface 接口名 [extends 父接口1, 父接口2...]{

常量定义;

方法定义;

}

2. 接口的实现

class 类名 implements 接口1, 接口2...{}

3. 几点注意

其中访问修饰符只能是 public 或默认。

extends之后可以接多个父接口，即接口可以多继承。

接口中的属性只能是常量，总是：public static final修饰。不写也是。

接口中的方法只能是：public abstract。省略的话，也是public abstract。

JDK1.8(不含8)之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法；JDK1.8 (含8)后，接口中包含普通的静态方法、默认方法。

子类通过 implements 来实现接口中的规范。

接口不能创建实例，但是可用于声明引用变量类型。

一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

三、多态

对于同一个动作，不同人的做法不一样，比如吃饭，中国人吃饭用筷子，西方人吃饭用刀叉。Java中，我们用一种叫多态的方式，来实现同一个方法调用，不同的对象行为完全不同。

1. 多态的要点

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

四、异常类

工作中程序可能遇到各种不同的意外问题，异常机制就是用于对这些情况进行合理的处理和解决，其本质为一个当程序出现异常，程序安全的退出、处理完后继续执行的机制。

1. 异常类的分类

Exception 异常类是 Throwable类的子类。Throwable类的另一个子类是Error类。异常类分为 CheckedException 和 RuntimeException 两部分。

1. RuntimeException 运行时异常

1) ArithmeticException ：试图除以0。

解决：添加变量不等于0的判断。

2) NullPointException 空指针异常

解决：添加变量不等于null的判断。

3) ClassCastException 类型转化异常。

将Dog类对象转换为Cat类变量。

解决：添加变量是否 instanceof 该类的判断。

4) ArrayIndexOutOfBoundsException 数组越界异常

解决：添加变量在 [0, arr.length()) 的判断。

5) NumberFormatException 数字格式化异常

String str = "1234abcd";
System.out.println(Integer.parseInt(str));

此时出现数字格式化异常。

解决：

        String str = "1234abcd";
        Pattern p = Pattern.compile("^\\d+$");
        Matcher m = p.matcher(str);
        if(m.matches()){
            System.out.println(
                    Integer.parseInt(str);
            );
        }

2. CheckedException 已检查异常

CheckedException在编译时处理，否则无法通过编译。

两种处理方式：

1. “try/catch” 捕获异常机制

2. “throw” 声明异常