【阶段一】java之面向对象上

懒得想名字专注学习

于 2022-03-25 15:07:21 发布

阅读量1.1k

点赞数 13

分类专栏： java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_41549523/article/details/123546193

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

面向对象语言具有如下特征：

面向对象是一种常见的思想，比较符合人们的思考习惯；
面向对象可以将复杂的业务逻辑简单化，增强代码复用性；
面向对象具有抽象、封装、继承、多态等特效。

1、什么是面对对象

Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented Programming, OOP)。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

抽象(abstract)

忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用关注细节。
例如：要设计一个学生成绩管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象是什么？就是将多个物体共同点归纳出来，就是抽出像的部分！

封装(Encapsulation)

封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过指定的方式。
在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

继承(inheritance)

继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。
新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。
派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增加新的方法使之更适合特殊的需要继承性很好的解决了软件的可重用性问题。比如说，所有的Windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

多态(polymorphism)

多态性是指允许不同类的对象对同一消息作出响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
相同类域的不同对象,调用相同方法,表现出不同的结果。

2、类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。

例如: Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

Student student = new Student(1,"tom",20);
student .study();
Car car = new Car(1,"BWM",500000);
car .run();

对象s就是Student类的一个实例，对象c就是Car类的一个具体实例，能够使用的是具体实例，而不是类。类只是给对象的创建提供了一个参考的模板而已。
但是在java中，没有类就没有对象，然而类又是根据具体的功能需求，进行实际的分析，最终抽象出来的。

3、对象和引用的关系

引用 “指向” 对象
使用类类型、数组类型、接口类型声明出的变量，都可以指向对象，这种变量就是引用类型变量，简称引用。
在程序中，创建出对象后，直接使用并不方便，所以一般会用一个引用类型的变量去接收这个对象，这个就是所说的引用指向对象。
总结：对象和引用的关系，就如电视机和遥控器，风筝和线的关系一样。

—方法回顾

1、方法的定义是什么

格式： 修饰符 返回类型 方法名(参数列表)异常抛出类型{...}

1.修饰符
public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口 main方法，就使用了public static这个俩个修饰符

注：如果一个方法或者属性有多个修饰符，这多个修饰符是没有先后顺序的

2.返回类型
方法执行完如果有要返回的数据，那么就要声明返回数据的类型，如果没有返回的数据，那么返回类型就必须写void

只有构造方法(构造器)不写任何返回类型也不写void

【示例】

public String sayHello(){
    return "hello";
}
public int max(int a,int b){
    return a>b?a:b;
}
public void print(String msg){
    System.out.println(msg);
}

break和return的区别
return 语句的作用：
(1) return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。
(2) return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。
(3) return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。

break语句的作用：
(1)break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不在判断执行循环的条件是否成立，直接转向循环语句下面的语句。
(2)当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。

3.方法名
遵守java中标示符的命名规则即可.

4.参数列表
根据需求定义,方法可以是无参的,也可以有一个参数,也可以有多个参数

5.异常抛出类型
如果方法中的代码在执行过程中，可能会出现一些异常情况，那么就可以在方法上把这些异常声明并抛出，也可以同时声明抛出多个异常，使用逗号隔开即可。

public void readFile(String file)throws IOException{
}

public void readFile(String file)throws IOException,ClassNotFoundException{
}

2、方法调用

1.非静态方法

没有使用static修饰符修饰的方法，就是非静态方法。
调用这种方法的时候，是"一定"要使用对象的调用。因为非静态方法是属于对象的。(非静态属性也是一样的)

【例子】

public class Student{ 
	public void say(){
	
	}
}
main:
Student s = new Student();
s.say();

2.静态方法

使用static修饰符修饰的方法,就是静态方法。

调用这种方法的时候，"可以"使用对象调用，也"可以"使用类来调用，但是推荐使用类进行调用。因为静态方法是属于类的。(静态属性也是一样的)

【例子】

public class Student{ 
	public static void say(){

	} 
}

main:
Student.say();

3.类中方法之间的调用

假设同一个类中有俩个方法，a方法和b方法，a和b都是非静态方法，相互之间可以直接调用。

public void a(){
    b();
}
public void b(){
    
}

a和b都是静态方法,相互之间可以直接调用

public static void a(){
    b();
}
public static void b(){
    
}

a静态方法，b是非静态方法，a方法中不能直接调用b方法，但是b方法中可以直接调用a方法。静态方法不能调用非静态方法！

public static void a(){
    //b();报错
}
public void b(){
    a();
}

另外：在同一个类中，静态方法内不能直接访问到类中的非静态属性。

总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方法是非静态的时候，非静态方法可以调用静态方法，反之不能。

3、调用方法时的传参

1、形参和实参

public static void test(int a){

}

public static void main(String[] args) {
    int x = 1;
    test(x);
}

参数列表中的a是方法test的形参(形式上的参数) 调用方法时的x是方法test的实参(实际上的参数)

注意：形参的名字和实参的名字都只是一个变量的名字,是可以随便写的,我们并不关心这个名字,而是关心变量的类型以及变量接收的值。

2、值传递和引用传递

调用方法进行传参时，分为值传递和引用传递两种。

如果参数的类型是基本数据类型，那么就是值传递。

如果参数的类型是引用数据类型，那么就是引用传递。

值传递是实参把自己变量本身存的简单数值赋值给形参。引用传递是实参把自己变量本身存的对象内存地址值赋值给形参。

所以值传递和引用传递本质上是一回事，只不过传递的东西的意义不同而已。

【示例：值传递】

public static void changeNum(int a) {
    a = 10;
}

public static void main(String[] args) {
    int a = 1;
    System.out.println("before: a = " + a); //1
    changeNum(a);
    System.out.println("after: a = " + a); //1
}

【示例：引用传递】

public class Test {
    public static void changeName(Student s) {
        s.name = "tom";
    }

    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("before: name = " + s.name); //null
        changeName(s);
        System.out.println("after: name = " + s.name); //tom
    }

    static class Student {
        String name;
    }

}

4、this关键字

在类中，可以使用this关键字表示一些特殊的作用。

1、this在类中的作用

区别成员变量和局部变量

public class Student{
    private String name;
    public void setName(String name){
        //this.name表示类中的属性name
        this.name = name;
    }
}

调用类中的其他方法

public class Student{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public void print(){
        //表示调用当前类中的setName方法
        this.setName("tom");
    }
}

调用类中的其他构造器

public class Student{
    private String name;
    public Student(){
        //调用一个参数的构造器,并且参数的类型是String
        this("tom");
    }
    public Student(String name){
        this.name = name;
    }
}

注：this的这种用法，只能在构造器中使用。普通的方法是不能用的。并且这局调用的代码只能出现在构造器中的第一句。
【示例】

public class Student{
    private String name;
    //编译报错,因为this("tom")不是构造器中的第一句代码.
    public Student(){
        System.out.println("hello");
        this("tom");
    }
    public Student(String name){
        this.name = name;
    }
}

2、this关键字在类中的意义

this在类中表示当前类将来创建出的对象。

【例子】

public class Student {
    private String name;

    public Student() {
        System.out.println("this = " + this);
    }

    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("s = " + s);
    }
}

运行后看结果可知，this和s打印的结果是一样的，那么其实也就是变量s是从对象的外部执行对象，而this是在对象的内部执行对象本身。

这样也就能理解为什么this.name代表的是成员变量，this.setName(“tom”)代表的是调用成员方法。因为这俩句代码从本质上讲，和在对象外部使用变量s来调用是一样的，s.name和s.setName(“tom”)

【this和s打印出来的内存地址是一样的，使用==比较的结果为true。】

public class Student{
    public Student getStudent(){
        return this;
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = s1.getStudent();
        System.out.println(s1 == s2);//true
    }
}

【调用类中的this，s1和s2不相等】

public class Student{
    private String name;
    public void test(){
        System.out.println(this);
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        s1.test();
        s2.test();
    }
}

注：这句话是要这么来描述的，s1对象中的this和s1相等，s2对象中的this和s2相等，因为类是模板，模板中写的this并不是只有一个，每个对象中都有一个属于自己的this，就是每个对象中都一个属于自己的name属性一样。

创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
那么对main方法中的以下代码：Student s = new Student();
1）为对象分配内存空间，将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋值)
2）如果代码中实例变量有显式赋值，那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象)

例如：显式赋值，private String name = "tom";

3）调用构造器
4）把对象内存地址值赋值给变量。(=号赋值操作)

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

1.必须和类的名字相同
2.必须没有返回类型,也不能写void

构造器的作用:

1.使用new创建对象的时候必须使用类的构造器
2.构造器中的代码执行后，可以给对象中的属性初始化赋值
【演示】

public class Student{
    private String name;
    
    public Student(){
        name = "tom";
    }
}

构造器重载

除了无参构造器之外，很多时候我们还会使用有参构造器，在创建对象时候可以给属性赋值。

【例子】

public class Student{
    private String name;
    public Student(){
        name = "tom";
    }
    public Student(String name){
        this.name = name;
    }
}

构造器之间的调用

使用this关键字，在一个构造器中可以调用另一个构造器的代码。

注意：this的这种用法不会产生新的对象，只是调用了构造器中的代码而已。一般情况下只有使用new关键字才会创建新对象。

【演示】

public class Student{
    private String name;
    public Student(){
        this();
    }
    public Student(String name){
        this.name = name;
    }
}

默认构造器

在java中，即使我们在编写类的时候没有写构造器，那么在编译之后也会自动的添加一个无参构造器，这个无参构造器也被称为默认的构造器。

【示例】

public class Student{
    
}

main:
//编译通过,因为有无参构造器
Student s = new Student();

但是,如果我们手动的编写了一个构造器,那么编译后就不会添加任何构造器了

【示例】

public class Student{
    private String name;
    public Student(String name){
        this.name = name;
    }
}
main:
//编译报错,因为没有无参构造器
Student s = new Student();

内存分析

JAVA程序运行的内存分析

栈 stack：

1.每个线程私有，不能实现线程间的共享！
2.局部变量放置于栈中。
3.栈是由系统自动分配，速度快！栈是一个连续的内存空间！

堆 heap：

1.放置new出来的对象！
2.堆是一个不连续的内存空间，分配灵活，速度慢！

方法区(也是堆)：

1.被所有线程共享！
2.用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

注意：本次内存分析，我们的主要目的是让大家了解基本的内存概念。类加载器、Class对象这些更加详细的内容，我们将在后面专门讲反射的课程里面讲。

引用类型的概念

java中，除了基本数据类型之外的其他类型称之为引用类型。
java中的对象是通过引用来操作的。(引用：reference)说白了，引用指的就是对象的地址！
属性（field，或者叫成员变量）

1.属性用于定义该类或该类对象包含的数据或者说静态属性。
2.属性作用范围是整个类体。
3.属性的默认初始化：
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化(数值：0,0.0 char：u0000, boolean：false, 所有引用类型：null)
4.属性定义格式：

[修饰符] 属性类型 属性名 = [默认值]

类的方法

方法是类和对象动态行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序有一个个函数调用组成；面向对象中，整个程序的基本单位是类，方法是从属于类或对象的。

方法定义格式：

[修饰符] 方法返回值类型 方法名(形参列表) {
    // n条语句
}

java对象的创建和使用

必须使用 new 关键字创建对象。
Person person= new Person ();
使用对象（引用）.成员变量来引用对象的成员变量。
person.age
使用对象（引用）. 方法（参数列表）来调用对象的方法
person.setAge(18)

类中就是：静态的数据动态的行为
学习完类与对象终于认识到什么是类，什么是对象了。
接下来要看的就是java的三大特征：继承、封装、多态。

封装

1、封装的步骤

1.使用private 修饰需要封装的成员变量。

2.提供一个公开的方法设置或者访问私有的属性
设置通过set方法，命名格式： set属性名（）; 属性的首字母要大写
访问通过get方法，命名格式： get属性名（）; 属性的首字母要大写

【演示】

//对象能在类的外部"直接"访问
public class Student{
    public String name;
    public void println(){
        System.out.println(this.name);
    }
}
public class Test{
    public static void main(String[] args){
        Student s = new Student();
        s.name = "tom";
    }
}

在类中一般不会把数据直接暴露在外部的，而使用private(私有)关键字把数据隐藏起来

【演示】

public class Student{
    private String name;
}
public class Test{
    public static void main(String[] args){
        Student s = new Student();
        //编译报错,在类的外部不能直接访问类中的私有成员
        s.name = "tom";
    }
}

如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性

【示例】

//set负责给属性赋值
//get负责返回属性的值
public class Student{
    private String name;
    public void setName(String name){
    this.name = name;
	}
	public String getName(){
        return this.name;
	}
}
public class Test{
    public static void main(String[] args){
        Student s = new Student();
        s.setName("tom");
        System.out.println(s.getName());
    }
}

2、作用和意义

1.提高程序的安全性，保护数据。
2.隐藏代码的实现细节。
3.统一用户的调用接口。
4.提高系统的可维护性。
5.便于调用者调用。

良好的封装，便于修改内部代码，提高可维护性。

良好的封装，可进行数据完整性检测，保证数据的有效性。

3、方法重载

例如:

public class Test{
    public void test(String str){
        
    }
    public void test(int a){
        
    }
}

方法重载必须满足以下条件
1.方法名必须相同
2.参数列表必须不同(参数的类型、个数、顺序的不同)

public void test(Strig str){}
public void test(int a){}

public void test(Strig str,double d){}
public void test(Strig str){}

public void test(Strig str,double d){}
public void test(double d,Strig str){}

3.方法的返回值可以不同，也可以相同。

在java中，判断一个类中的俩个方法是否相同，主要参考俩个方面：方法名字和参数列表

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
为什么需要继承？继承的作用？

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性。

extands的意思是“扩展”。子类是父类的扩展。
【注】JAVA中类只有单继承，没有多继承！接口可以多继承！

1、继承

1.继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
2.继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类，使用关键字extends来表示。

public class student extends Person{
}

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

student is a person
dog is a animal

4.类和类之间的继承是单继承

一个子类只能"直接"继承一个父类,就像是一个人只能有一个亲生父亲一个父类可以被多子类继承,就像一个父亲可以有多个孩子。
注:java中接口和接口之间,有可以继承,并且是多继承。

5.父类中的属性和方法可以被子类继承

子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。

例如：
父类中的属性和方法使用public修饰，在子类中继承后"可以直接"使用父类中的属性和方法使用private修饰，在子类中继承后"不可以直接"使用
注：具体细则在修饰符部分详细说明
父类中的构造器是不能被子类继承的，但是子类的构造器中，会隐式的调用父类中的无参构造器（默认使用 super关键字）。
注:具体细节在super关键字部分详细说明

2、Object类

java中的每一个类都是"直接" 或者 "间接"的继承了Object类。所以每一个对象都和Object类有"is a"的关系。从API文档中，可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is a Object。

System.out.println(任何对象 instanceof Object);
输出结果:true 注:任何对象也包含数组对象

例如：

//编译后,Person类会默认继承Object
public class Person{}

//Student是间接的继承了Object
public class Student extends Person{}

在Object类中，提供了一些方法被子类继承，那么就意味着，在java中，任何一个对象都可以调用这些被继承过来的方法。(因为Object是所以类的父类)

例如：toString方法、equals方法、getClass方法等

3、Super关键字

子类继承父类之后，在子类中可以使用this来表示访问或调用子类中的属性或方法，使用super就表示访问或调用父类中的属性和方法。

1、super的使用

【访问父类中的属性】

public class Person{
    protected String name = "zs";
}

public class Student extends Person{
    private String name = "lisi";
    public void tes(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

【调用父类中的方法】

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

public class Student extends Person{
    public void print(){
        System.out.println("Student");
    }
    public void test(){
        print();
        this.print();
        super.print();
    }
}

【调用父类中的构造器】

public class Person{
}

public class Student extends Person{
    //编译通过,子类构造器中会隐式的调用父类的无参构造器
    //super();
    public Student(){
    }
}

父类没有无参构造

public class Person{
    protected String name;
    public Person(String name){
        this.name = name;
    }
}
public class Student extends Person{
    //编译报错,子类构造器中会隐式的调用父类的无参构造器,但是父类中没有无参构造器
    //super();
    public Student(){
        
    }
}

【显式的调用父类的有参构造器】

public class Person{
    protected String name;
    public Person(String name){
    this.name = name;
	}
}

public class Student extends Person{
    //编译通过,子类构造器中显式的调用父类的有参构造器
    public Student(){
        super("tom");
    }
}

注：不管是显式还是隐式的父类的构造器，super语句一定要出现在子类构造器中第一行代码。所以this和 super不可能同时使用它们调用构造器的功能，因为它们都要出现在第一行代码位置。
【例子】

public class Person{
    protected String name;
    public Person(String name){
        this.name = name;
    }
}

public class Student extends Person{
    //编译报错,super调用构造器的语句不是第一行代码
    public Student(){
        System.out.println("Student");
        super("tom");
    }
}

【例子】

public class Person{
    protected String name;
    public Person(String name){
        this.name = name;
    }
}
//编译通过
public class Student extends Person{
    private int age;
    public Student(){
        this(20);
    }
    public Student(int age){
        super("tom");
        this.age = age;
    }
}

super使用的注意的地方

用super调用父类构造方法，必须是构造方法中的第一个语句。
super只能出现在子类的方法或者构造方法中
super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

super 和 this 的区别

1.代表的事物不一样：

this：代表所属方法的调用者对象。
super：代表父类对象的引用空间。

2.使用前提不一致：

this：在非继承的条件下也可以使用。
super：只能在继承的条件下才能使用。

3.调用构造方法：

this：调用本类的构造方法。
super：调用的父类的构造方法

4、方法重写
方法的重写（override）

方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写
静态方法不能重写
1.父类的静态方法不能被子类重写为非静态方法 //编译出错
2.父类的非静态方法不能被子类重写为静态方法；//编译出错
3.子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)

【例子】

A类继承B类 A和B中都一个相同的静态方法test
B a = new A(); a.test();//调用到的是B类中的静态方法test
A a = new A(); a.test();//调用到的是A类中的静态方法test
可以看出静态方法的调用只和变量声明的类型相关 这个和非静态方法的重写之后的效果完全不同

私有方法不能被子类重写，子类继承父类后,是不能直接访问父类中的私有方法的,那么就更谈不上重写了

public class Person{
    private void run(){}    
}

//编译通过,但这不是重写,只是俩个类中分别有自己的私有方法
public class Student extends Person{
    private void run(){}
}

重写的语法

1.方法名必须相同
2.参数列表必须相同
3.访问控制修饰符可以被扩大，但是不能被缩小： public protected default private
4.抛出异常类型的范围可以被缩小,但是不能被扩大

ClassNotFoundException ---> Exception（不能扩大）

5.返回类型可以相同，也可以不同。

如果不同的话，子类重写后的方法返回类型必须是父类方法返回类型的子类型。

**例如：**父类方法的返回类型是Person，子类重写后的返回类可以是Person也可以是Person的子类型

注：一般情况下，重写的方法会和父类中的方法的声明完全保持一致，只有方法的实现不同。(也就是大括号中代码不一样)

public class Person{
    public void run(){}
    protected Object test()throws Exception{
        return null;
    }
}

//编译通过,子类继承父类,重写了run和test方法.
public class Student extends Person{
    public void run(){}
    public String test(){
        return "";
    }
}

为什么要重写？

子类继承父类，继承了父类中的方法，但是父类中的方法并不一定能满足子类中的功能需要，所以子类中需要把方法进行重写。

总结：

1.方法重写的时候，必须存在继承关系。
2.方法重写的时候，方法名和形式参数必须跟父类是一致的。
3.方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected < public，friendly < public )
4.方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有明确的上下级关系
5.方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。