面向对象知识点全方位梳理

最新推荐文章于 2023-03-16 19:29:34 发布
置顶 最新推荐文章于 2023-03-16 19:29:34 发布
阅读量733 收藏 9
点赞数 4
文章标签： java 面向对象编程 多态 封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helltaker/article/details/107628317
版权

面向对象知识点整理归纳

面向对象的基本概念

1.面向对象
Java是一种面向对象的语言，比较符合人类认识现实世界的思维方式。
它的基本思想是把问题看成是由若干个对象组成，对象间相互独立，但又可以相互配合、连接和协调。
具有系统结构较稳定、子系统相对独立、软件可重用性、可维护性和可扩展性强的特点。
面向对象的三大特征：封装、继承和多态。

2.对象
对象是用来描述客观事物的一个实体
对象的属性：属性可以用来描述该对象，每个对象的每个属性都拥有特定值。
对象的方法：该对象可执行的操作。

3.类
类是具有相同属性和方法的一组对象的集合。
类定义了其对象将会有的特征（属性）和行为（方法）。

类与对象的关系：
I 类是对象的抽象，对象是类的实现
II 类是由属性和方法构成，它的每一个对象都有对应的属性和方法

定义类

所有Java程序都以类class为组织单元
关键字class定义自定义的数据类型

[访问修饰符] class 类名{
//省略类的内部具体代码
}

实例：一个类的基本结构

public class Person { //定义“人”类
	public String name; //姓名
	public String gender; //性别
	public int age; //年龄
	public void work(){ //行为：工作
	    System.out.println(this.name+"正在工作")
	}

创建和使用对象

1.创建对象

类名 对象名 = new 类名();

new是关键字
左边的类名为对象的数据类型
右边的类名()称为类的构造方法
实例：接上，创建Person类的对象

Person laowang = new Person();

2.使用对象
在Java中，要引用对象的属性和方法，需要使用“.”

对象名.属性      //引用对象的属性
对象名.方法名()  //引用对象的方法

实例：接上，调用对象laowang的属性和方法

public static void main(String[] args) {
    Person laowang = new Person();
    laowang.name = "老王"; //给laowang的属性赋值
    laowang.gender = "男";
    laowang.age = 40;
    laowang.work; //调用laowang的work方法
}

对象数组

实例：继续用Person类做例子

public class TestPerson{
	public static void main(String[] args){
		Person laowang = new Person();
		Person xiaoliu = new Person();
		Person liming = new Person();
		Person[] person = {laowang, xiaoliu, liming};
		//定义包含了3个元素的对象数组，数据类型为Person
	}
}

方法

方法的定义：

public 返回值类型 方法名(){
	//这里编写方法的主体
}

方法的返回值

方法的返回值有两种情况：
1.如果方法具有返回值，方法中必须使用关键字return返回该值，返回值类型为该值的类型。返回值只能有一个。

public String getName(){
	return name;
}

2.如果没有返回值，返回值类型为void，如果想查看结果则在方法内通过打印的方式来显示。

方法的调用

方法之间允许相互调用，不需要知道方法的具体实现，实现重用，提高效率。以下是两种调用情况的实例：
1.Student类的方法a()调用Student类的方法b()，直接调用

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

2.Student类的方法a()调用Teacher类的方法b()，先创建类对象，然后使用“.”调用

public class Student{
	public void a(){
    	Teacher t = new Teacher();
     	t.b();
	}
}

带参数的方法

定义带参数的方法：

<访问修饰符>  返回类型  <方法名>(<形式参数列表>) {
	//方法的主体
}

调用带参方法：

对象名.方法名(参数1,参数2,……,参数n)
//调用带参方法时，必须让实际参数的类型、顺序与形式参数列表匹配

注意：对象数组也可以作为参数，但是要记得匹配。

方法传参

基本数据类型和引用数据类型数据在传参时是有区别的！

  • 基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。
  • 引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用。
    实例：
public class Student(){
	int age;
}
public class Test {
	public void calc1(int num){
		num=num+1;
	}
	public void calc2(Student student){
		student.age=student.age+1;
	}
	public static void main(String[] args){
		Test test=new Test();
		int n=8;
		test.calc1(n);
		Student stu=new Student();
		stu.age=18;
		test.calc2(stu);
		System.out.println(n+"---"+stu.age);
	}
}
输出的结果是：8---19
//n是int类型，为基本数据类型，方法使用过以后并不会改变它的值
//stu.age是类的属性，为引用数据类型，在方法中改变值后传给同样的地址，所以值改变了

方法重载

方法重载的定义：
方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数类型或参数个数

方法重载的目的：
针对同一个行为的多种表现，对应相同方法名的多个方法

方法重载的特点：

  • 在同一个类中
  • 方法名相同
  • 参数的个数或类型不同
  • 方法的返回值不能作为判断方法之间是否构成重载的依据

方法重载的优点：
方法重载其实是对原有方法的一种升级，可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，简化了类调用方法的代码

public class Person{
	public String name;
	public String gender;
	public int age;
	public void work(){ //无参数的工作方法
		System.out.println(this.name+"的工作理念：撸起袖子加油干！")
	}
	public void work(String content){ //有参数的工作方法
		System.out.println(this.name+"的工作理念："+content)
	}
	public static void main(String[] args){
		Person p = new Person();
		p.work();
		p.work("干活挣钱有饭吃"); //调用重载的有参方法
	}
}

构造方法

Java中，当类创建一个对象时会自动调用该类的构造方法，构造方法分为默认构造方法和带参数的构造方法。构造方法的主要作用是进行一些数据的初始化。

<访问修饰符> 构造方法名(){ //无返回值，方法名与类名相同，可以指定参数
	//初始化代码
}

Student s1=new Student(); //new 类名();即是默认的无参构造

有参构造实例：

public class Student(){
	String name;
	int age;
	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}
	public static void main(String[] args){
		Student s1 = new Student("李磊",14);
		Student s2 = new Student("韩梅梅",13)
	}
}

构造方法重载

自定义构造方法：方法名相同、参数项不同，与返回值、访问修饰符无关
此时系统不再提供默认无参构造方法，入股有需要则自己手动写一个

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

this关键字

不难发现，this在上面的程序语句中已经出现过很多次了。那么this是什么含义呢？又有什么用法？
this关键字是对一个对象的默认引用。每个实例方法内部都有一个this引用变量，指向调用这个方法的对象。

  • 使用this调用成员变量，解决成员变量和局部变量的同名冲突（后文将详细阐述）
public void setName(String name){
	this.name = name; //成员变量和局部变量同名，必须使用this
}
  • 使用this调用成员方法
public void play(int n){
	health = health - n;
	this.print(); //this可以省略，直接调用print()方法
}
  • 使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法的第一条语句
public Penguin(String name, String sex){
	this.name = name;
	this.sex = sex;
}
public Penguin(String name, int health, int love, String sex){
	this(name, sex); //调用重载的构造方法
	this.health = health;
	this.love = love;
}
成员变量与局部变量

变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域

实例：

public class AutoLion{
	变量1类型  变量1；	//成员变量
	变量2类型  变量2；
	变量3类型  变量3；

	public 返回类型 方法1(){
		变量4类型  变量4;	//局部变量
	}

	public 返回类型 方法2(){
		变量5类型  变量5；	//局部变量超出其作用域之后不可使用
	}
}

成员变量和局部变量的区别：

作用域不同

  • 局部变量的作用域仅限于定义它的方法
  • 成员变量的作用域在整个类内部都是可见的

初始值不同

  • Java会给成员变量一个初始值
  • Java不会给局部变量赋予初始值

注意：
1.在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量
2.在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

封装

封装的概念是将类的某些信息隐藏在类内部，不允许外部程序直接访问；而是通过该类提供的方法来实现对隐藏信息的操作和访问

属性隐藏

1.修改属性的可见性

public class Person{ //将Person类属性私有化
	private String name;
	private String gender;
	private int age;
}

2.设置getter/setter()方法
可以用 右键 --> Generate --> getter&setter 由系统添加

public String getName(){
	return name;
}
public void setName(String name){
	this.name=name;
}

3.设置属性的存取限制（对属性合法值进行判断）

public void setAge(int age){
	if (age<0 || age>150) {
		System.out.println("输入年龄不合法，将重置！")
		return;
	}
	this.age=age;
}

封装的好处

1.便于使用者正确使用系统，防止错误修改属性
2.有助于系统之间的松耦合，提高系统独立性
3.提高软件的可重用性
4.降低了构建大型系统的风险

包机制

包的作用：
1.允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
2.有助于实施访问权限控制
3.防止命名冲突，区分名字相同的类

如何创建包？

package cn.jbit.inherit;	//声明包
public class School {
	//代码块
}

如何导入包？
为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类

import 包名.类名;

import java.util.*; //导入java.util包中所有类 *之所有类
import cn.jtest.classandobject.School; //导入指定包中指定类 (School)

使用包的注意事项：

  • 一个类同时引用了两个来自不同包的同名类
    必须通过完整类名来区分
import oop.Dog;
import pet.Dog;

...
	oop.Dog dog1 = new oop.Dog();
	pet.Dog dog2 = new pet.Dog();
...

  • 每个包都是独立的，顶层包不会包含子包的类

  • package和 import的顺序是固定的
    package必须位于第一行（忽略注释行）
    只允许有一个package语句
    其次是import
    接着是类的声明

访问权限控制

类的访问控制

类的访问修饰符：
public修饰符：公有访问级别
默认修饰符：包级私有访问级别（本包的可以访问，不同包不可）

类成员的访问控制

在这里插入图片描述

static修饰符

static可以用来修饰成员变量，成员方法，代码块

static变量

  • static变量又称类变量，或者静态变量，在内存中只有一个拷贝
  • 类内部，可在任何方法内直接访问静态变量
  • 其他类中，可以直接通过类名访问

static变量的作用：
（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间

类的成员变量包括了类变量和实例变量（没有被static修饰的变量），每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

static方法

  • static方法，又称静态方法，可直接通过类名访问，静态方法中不能使用this和super
  • 不能直接访问所属类的实例变量和实例方法，可直接访问类的静态变量和静态方法

另一种是实例方法，通过实例访问，可直接访问所属类的静态变量、静态方法、实例变量和实例方法 （上文方法小节里提到的）

注意：静态方法必须被实现，main()就是最常见的静态方法

static代码块

  • JVM加载类时，加载静态代码块，是在第一次访问该类时执行，且只执行一次
  • 如果有多个静态块，按顺序加载；每个静态代码块只会被执行一次
public class StaticTest {
	static int num=100;
	static{
		num+=100;
		System.out.println(num);
	}
	static{
		num+=100;
		System.out.println(num); 
	}
}

继承

先使用类图来理一下Pet 父类 和 Dog、Penguin 两个 子类 的关系
在这里插入图片描述
可以看到Dog和Penguin一些共有的东西被放进了 Pet类中，而他们各自仍保存了自己独有的属性和方法！这些共有的东西，就可以被看作是Dog类和Penguin类从他们的父类Pet中 继承 的。
在这里插入图片描述

使用继承

  • 编写父类
[访问修饰符] class Pet { 
	//公共的属性和方法
}
  • 编写子类，继承父类
[访问修饰符] class Dog extends Pet { 
    //子类特有的属性和方法
}

extends 是继承的关键字

知识要点：继承是Java中实现代码重用的重要手段之一；Java中只支持单根继承，即一个类只能有一个直接父类

super的用法

使用super关键字,super代表父类对象
访问父类构造方法：

super();    
super(name, gender, ...);
// 在子类构造方法中调用且必须是第一句

访问父类属性：

super.name;

访问父类方法：

super.print();

注意：不可以访问父类中定义为private的属性和方法

继承条件下构造方法的调用规则

在Java中，一个类的构造方法在如下两种情况总是会被执行：
1.创建该类的对象（实例化）
2.创建该类的子类的对象（子类的实例化）

  • 子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法，系统默认调用父类的无参构造方法
  • 子类构造方法通过super显式调用父类的有参构造方法，执行父类相应构造方法，而不执行父类无参构造方法
  • 子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则

Object类

Object类是所有类的父类。在Java中，所有Java类都直接或间接地继承了java.lang.Object类。在定义一个类时，如果没有使用extends关键字（即无显式继承），则这个类直接继承Object类。

常见的Object类方法

toString(); //返回当前对象本身的有关信息，按字符串对象返回
equals(); //比较两个对象是否是同一个对象，是则返回true
clone(); //生成当前对象的一个副本，并返回
hashCode(); //返回该对象的哈希代码值
getClass(); //获取当前对象所属的类信息，返回Class对象

方法重写

在子类中可以根据需求对从父类继承的方法进行重新编写，这称为方法的重写或方法的覆盖（Overriding）；重写时，可以用super.方法的方式来保留父类的方法；构造方法不能被重写。

方法重写的规则

  • 方法名相同
  • 参数列表相同
  • 返回值类型相同或者是其子类
  • 访问权限不能严于父类
  • 父类的静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法
  • 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
  • 父类的私有方法不能被子类覆盖
  • 不能抛出比父类方法更多的异常

方法重写实例

给Object类的equals方法重写

@Override
public boolean equals(Object book){
	if (book instanceof Book){
		Book book1 = (Book) book;
		if (this.getBookId()==book1.getBookId() &&
			this.getBookName().equals(book1.getBookName())){
			return true;
		}
	}
	return false;
}
//根据需求，只有当两本图书的编号Id和书名Name都相同时，
//两本书才会被判定为重复的书籍，因此改写.equals()方法

方法重写和重载

在这里插入图片描述

多态

多态一词在程序中，意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用的对象的方法，也就是根据作用到的不同对象类型，响应不同的操作。方法重写是实现多态的基础
多态：同一个引用类型，使用不同的实例而执行不同操作

应用多态实例一

//Dog类
public class Dog extends Pet {
	public void toHospital() {
		this.setHealth(60);
		System.out.println("狗狗打针、吃药");
	}
}

//Penguin类
public class Penguin extends Pet {
	public void toHospital() {
		this.setHealth(70);
		System.out.println("企鹅吃药、疗养");
	}
}

//主人类
public class Master {
	public void cure(Pet pet) {
		if (pet.getHealth() < 50)
			pet.toHospital();        
	}
}

//测试方法
Pet dog = new Dog();
Pet penguin = new Penguin();
Master master = new Master();
master.cure(dog); //体现了多态
master.cure(penguin);

//输出结果
狗狗打针、吃药
企鹅吃药、疗养

向上转型

上面代码里有展示Pet dog = new Dog();
这其实就是子类向父类的转换，称为向上转型：

<父类型><引用变量名> = new <子类型>();

向上转型的规则：

  • 父类的引用指向子类对象，系统将自动进行类型转换
  • 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法

注意： 此时通过父类引用的变量，无法调用子类特有的方法

向下转型

上文提到，通过父类引用的变量无法调用子类特有的方法；但如果此时需要调用子类特有的方法，可以通过把父类转换为子类来实现。
将一个指向子类对象的父类引用赋给一个子类的引用，即将父类类型转换为子类类型，称为向下转型，此时必须进行强制转换。

向下转型的语法：

<子类型><引用变量名> = (<子类型>)<父类型的引用变量>

Pet pet = new Dog();
pet.dogRun(); //dogRun是Dog类特有方法，故这里无法调用
Dog dog = (Dog) pet;
dog.dogRun(); //可执行Dog的特有方法

instanceof 运算符

在向下转型过程中，如果不是转换为真实子类类型，会出现类型转换异常

Pet pet = new Dog();
pet.toHospital();
Bird bird = (Bird) pet; //出错

于是我们可以用instanceof来判断
使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系，否则会出现编译错误。

Pet pet = new Dog();
//Pet pet = new Bird();
pet.toHospital();
if (pet instanceof Dog) {
	Dog dog = (Dog) pet;
	dog.dogRun();
}else if (pet instanceof Bird) {
	Bird bird = (Bird) pet;
	bird.birdFly();
}

应用多态实例二

使用父类作为方法的形参

class Host{
	public void letCry(Animal animal){
		animal.cry();
	}
}

public class Test {
	public static void main(String[] args) {
		Host host = new Host();
		Animal animal;
		animal = new Dog();
		host.letCry(animal);
		animal = new Cat();
		host.letCry(animal);
		animal = new Bird();
		host.letCry(animal);
	}
}

应用多态实例三

使用父类作为方法的返回值

class Host{
	public Animal donate(String type){
		Animal animal;
		if (type.equals("dog"){
			animal = new Dog();
		}
		if (type.equals("cat"){
			animal = new Cat();
		}
		if (type.equals("bird"){
			animal = new Bird();
		}
		return animal;
	}
}

public class Test{
	public static void main(String[] args) {
		Host host = new Host();
		Animal animal;
		animal = host.donate("dog");
		animal.cry();
		animal = host.donate("cat");
		animal.cry();
		animal = host.donate("bird");
		animal.cry();
	}
}

抽象

抽象方法

在Java中，当一个类的方法被abstract关键字修饰时，该方法称为抽象类方法。抽象方法所在的类必须被定义为抽象类。

[访问修饰符] abstract<返回类型><方法名>([参数列表])
//abstract关键字表示该方法被定义为抽象方法
  • 抽象方法需要用修饰符abstract修饰，普通方法不需要
  • 普通方法有方法体，抽象方法没有方法体

抽象类

在Java中，当一个类被abstract关键字修饰时，该类被称为抽象类

abstract class <类名>
//abstract关键字表示该类被定义为抽象类
  • 抽象类需要用修饰符abstract修饰，普通类不需要
  • 普通类可以实例化，抽象类不能被实例化

定义一个抽象类：

public abstract class 类名称{
	修饰符 abstract 返回类型 方法名();
	修饰符 返回类型 方法名(){
		方法体
	}
}

如何使用

抽象类与抽象方法的使用：

  • 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
  • 如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
  • 没有抽象构造方法，也没有抽象静态方法
  • 抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

抽象的利弊

以手机游戏“愤怒的小鸟”举例，小鸟都有飞行、叫声、攻击等这些方法。虽然每只鸟都有攻击行为，但是每种小鸟的攻击方式各不相同。在Java程序中即是没有方法体，这里就可以用到抽象类与抽象方法，让每个对象（鸟）各自去实现自己的攻击行为。

然而，抽象类也有局限性。依然是“愤怒的小鸟”这款游戏，刚才还提到了鸟的叫声。不同的鸟的叫声可能不一样，也可能一样。比如小一点的鸟叫声一样，体型大一点的又不一样了，甚至有的鸟干脆不叫。此时，叫声的行为不再通用，如果使用抽象方法去解决这一问题，会造成代码冗余的情况。如何解决？请看下一个知识点，接口。

接口

Java中接口的作用和生活中的接口类似，它提供一种约定，使得实现接口的类（或结构）在形式上保持一致。

定义和实现

定义：

public interface 接口名 {
	//接口成员
}
  • 和抽象类不同，定义接口使用interface修饰符，访问修饰符只能是public，且可选
  • 接口成员可以是全局常量和公共的抽象方法

与抽象类一样，使用接口也必须通过子类，子类通过implements关键字实现接口

实现：

public 类名 implements 接口名{
	实现方法
	普通方法
}
  • 实现接口使用implements关键字
  • 实现接口的类必须实现接口中定义的所有抽象方法

接口的特性

  • 接口不可以被实例化
  • 实现类必须实现接口的所有方法
  • 接口中的变量默认都是public static final
  • 接口中的方法默认都是public abstract

实例

public interface UsbInterface{
	void service();
}
public class UDisk implements UsbInterface{
	public void service(){
		System.out.println("连接USB接口，开始传输数据！")
	}
}

更复杂的接口

接口本身也可以继承接口

[修饰符] interface 接口名 extends 父接口1，父接口2...{
	常量定义
	方法定义
}

一个普通类只能继承一个父类，但能同时实现多个接口

class 类名 extends 父类名 implements 接口1，接口2...{
	类的成员
}

异常

异常是指在程序的运行过程中所发生的的不正常事件。异常会中断正在运行的程序。

如果使用if-else语句进行异常处理，会有以下弊端：
1、代码臃肿
2、程序员要花很大精力“堵漏洞”
3、程序员很难堵住所有“漏洞”

这时候就需要用到异常处理机制。

Java异常体系结构

所有异常类型都是Throwable类的子类，它派生了两个子类：Error类和Exception类。
1、Error类：仅靠程序本身无法恢复的严重错误，如内存溢出、虚拟机错误等。
2、Exception类：由Java应用程序抛出和处理的非严重错误，如所需文件找不到、算术运算错位、数组下标越界等。它又可以分为两大类异常：

  • 运行时异常：包括RuntimeException及其所有子类。不要求程序必须对它们进行处理。
  • Checked异常：除了运行时异常的其他从Exception类继承来的异常类。

常见的异常类

在这里插入图片描述

异常处理的关键字

Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws
在这里插入图片描述

try-catch块

第一种情况：正常

public void method(){
	try {
		// 代码段(此处不会产生异常)
	} catch (异常类型 ex) {
		// 对异常进行处理的代码段
	}
	// 代码段
}

第二种情况：出现异常

如果try语句在执行过程中发生异常，并且这个异常与catach语句块中声明的异常类型匹配，那么try语句块剩下的代码都将被忽略，而相应的catch语句块将会被执行

public void method(){
	try {
		// 代码段 1
		// 产生异常的代码段 2
		// 代码段 3，此时代码段3不执行
	} catch (异常类型 ex) {
		// 对异常进行处理的代码段4
	}
	// 代码段5
}

在这里插入图片描述
第三种情况：异常类型不匹配

public void method(){
	try {
		// 代码段 1
		// 产生异常的代码段 2
		// 代码段 3
	} catch (异常类型 ex) {
		// 对异常进行处理的代码段4
	}
		// 代码段5
}

在这里插入图片描述

处理异常信息

可以在catch块中处理异常，加入用户自定义处理信息
例如：

System.err.println("出现错误：被除数和除数必须是整数 ");

或者调用方法输出异常信息：

e.printStackTrace();

异常对象常用的方法：
在这里插入图片描述

try-catch-finally

无论是否发生异常，finally语句块中的代码总能被执行

存在return的try-catch-finally块

public void method(){
	try {
		// 代码段 1
		// 产生异常的代码段 2
	} catch (异常类型 ex) {
		// 对异常进行处理的代码段3
		return;
	}finally{
		// 代码段 4
	}
}

即使在catch语句块中存在return语句，finally语句块中的语句也会被执行。发生异常时的执行顺序是，先执行catch语句块中return之前的语句，再执行finally语句块中的语句，最后执行catch语句块中的return语句退出。

在这里插入图片描述

多重catch块

一段代码可能会引发多种类型的异常，可以在一个try语句块后面跟多个catch语句块分别处理不同的异常

排列catch语句的顺序：先子类后父类
发生异常时按顺序逐个匹配
只执行第一个与异常类型匹配的catch语句

throws和throw

throws
如果在一个方法体中抛出了异常，并希望调用者能够及时地捕获异常，Java语言中通过关键字throws声明某个方法可能抛出的各种异常以通知调用者。

throws声明某个方法可能抛出的各种异常，多个异常用逗号隔开

public static void divide() throws Exception{
	//代码块
}

throw
除了系统自动抛出的异常外，在编程过程中，有些问题是系统无法自动发现并解决的。

if (sex.equals("男") || sex.equals("女")) this.sex=sex;
else {
	throw new Exception("性别必须是男或女！");
}

throws和throw比较
在这里插入图片描述

自定义异常

当JDK 中的异常类型不能满足程序的需要时，可以自定义异常类
使用自定义异常的步骤：
在这里插入图片描述

//构造方法1
public MyException() {
	super();
}

//构造方法2
public MyException(String message) {
	super(message);
}

//构造方法3
public MyException(String message, Throwable cause) {
	super(message, cause);
}

//构造方法4
public MyException(Throwable cause) {
	super(cause);
}

异常链

A方法调用B方法时，B方法却抛出了异常。那A方法继续抛出原有的异常还是抛出一个新异常呢？
异常链创建了新的异常但却保留了原有异常的信息。

写在最后

这是个人整理的面向对象知识点，包括了各种实际使用的代码示例和需要注意的细节。面向对象的知识点多且复杂，需要配合大量的上机练习来巩固。如果你发现我这篇博文有哪里写的不对或者还有我没提到的知识点，欢迎捉虫！

Helltaker
关注
面向对象知识点的总结(全)
weixin_44536951的博客
11-12 2929
三大基本特征 继承 封装 多态 继承 1.场景: 如果多个类存在相同的属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那一个类即可。 其中，多个类可以称为子类，单独的那个类称为父类、超类、基类 继承描述的是事物之间的所属关系，这种关系是：is-a的关系。 父类更通用，子类更具体。我们主要是通过继承，可以使事物之间形成一种关系体系。 2.定义: 就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。 子类可以直接访问父类中的非私有的属性和行为。
面向对象知识整理
zhouym_的博客
04-18 198
面向对象内容概述图 回顾下面向过程和面向对象的内容 面向过程思想概述 1.面向过程的思想是去如何去实现一个功能的步骤：首先要做什么，然后做什么，最后做什么，一步一步去实现，具体的每一步都需要我们来操作的实现，这些步骤相互调用和协作，来实现我们的功能，每一步我们都是参与者，并且需要面对具体的每一个步骤和过程，这是面向过程最直接的体现 2.面向过程开发关心的就是每一步的实现，如果每一步都能够实现那么...
面向对象的六个知识点
huang6677的博客
04-04 568
1、面向对象： 问1：什么是面向对象 万事万物皆为对象 对象由什么组成： 属性和功能 属性：变量、全局变量 功能：函数/方法 对象和类的关系： 类是用来描述对象的 对象是根据类来创建 创建对象的格式： 类名 对象名 = new 类名(); 类名 对象名 = new 构造函数([参数]); 问2：面向对象...
面向对象（下）知识点
爱雨轩
05-09 949
指针：指向某个内存地址的变量。它有两个属性：地址值和指针类型。 空指针：不指向任何内存地址的指针。 指针类型可告诉编译器应该怎样进行接下来的数据访问。int类型和float类型就不是一样的。举个例,如：Cat cat = null;就告诉了cat变量是cat类型，则编译器会让cat变量去访问Cat类型数据；也即相当于在声明变量时完成了Cat类型的初始化，所以即使是Cat cat =
面向对象知识点总结
lanlangtu的博客
12-26 406
;类和对象   1.什么是类？什么是对象？   1)现实世界是由很多很多对象组成的     基于对象抽出了类   2)对象:真实存在的单个的个体     类:类型/类别，代表一类个体   3)类中可以包含:     3.1)所有对象所共有的属性/特征(静)-----成员变量 3.2)所有对象所共有的行为(动)----------方法   4)一个类可以创建多个对象   ...
2年经验JAVA面试精华：全方位知识点梳理
以下是各部分的主要知识点概要： 1. **CoreJava**（共95题）： - 基础及语法（61题）：涉及面向对象的基本概念，如抽象（强调关注目标相关性）、继承（类的层次模型和重用）、封装（隐藏实现细节并提供访问接口）...
Java发展史：从Oak到JDK，Java程序设计关键知识点梳理
Java主要分为三个技术分支：JAVASE（Java Standard Edition，标准版），它是面向普通开发者的基础版本，涵盖了面向对象编程、类集、Java I/O、JDBC等核心知识点；J2EE（Java Enterprise Edition，企业版），针对企业...
高级特效开发——知识点梳理
最新发布
m0_70298713的博客
03-16 161
高级特效开发——知识点梳理
Python编程思维导图：全方位知识概览
这可能包括了Python的基础知识、数据结构、控制流程、函数、模块、面向对象编程、异常处理、文件操作、网络编程、数据库交互、测试等众多方面的概念和知识点。 使用思维导图来学习Python编程语言，可以帮助学习者更...
2018下半年全国教师资格证复习资料考点梳理《综合素质》重点知识[中学阶段].doc
11-28
4. 素质教育是连贯的、全方位的、全过程的教育，涵盖各级各类学校，延伸至家庭和社会，强调终身学习的重要性。 三、素质教育观的产生与发展 素质教育观起源于20世纪80、90年代，为纠正应试教育的片面追求升学率和...
面向对象的知识点总结
08-11
面向对象的重要知识点总结
面向对象知识点
qq_66188895的博客
07-20 340
面向对象的特点: 1.封装性 封装是面向对象的核心思想，有两层含义:一层含义是指把对象的属性和行为看成一个密不可分的整体，将两者“封装”在一起（即封装在对象中）；另一层含义是指“信息隐藏”，将不想让外界知道的信息隐藏起来。例如，驾校的学员学开车，只需要知道如何操作汽车，无须知道汽车内部是如何工作的。 2.继承性 继承性主要描述的是类与类之间的关系，通过继承，可以在无须重新编写原有类的情况下，对原有类的功能进行扩展。例如，有一个汽车类，该类描述了汽车的普通特性和功能，进一步再产生轿车类，而轿车类中不仅应该包含
面向对象知识点概要总结
GodV的博客
07-09 892
具有一定jjava基础的，且对面向对象知识点有些模糊的，可以参考下
面向对象的知识点
m0_59453939的博客
02-20 209
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。 抽象 三大特性 封装 继承 多态 创建与初始化对象 使用new关键字创建对象 使用new关键字创建的时候，除了分配空间之外，还会给创建好的对象进行默认初始化以及对类中构造器的调用。 类中的构造器也称构造方法，是在进行创建对象的时候必须要调用的，并有2个特点。 1.必须和类的名字相同。 2.必须没有返回类型，也不能写void. 构造器的作用：
面向对象基础知识点
Duchuan14的博客
03-29 643
一、类和对象 （1）类：类是模子，确定对象将会拥有的特征(属性)和行为(方法)。 类的特点：类是具有相同属性和方法的一组对象的集合。 （2）对象 创建对象：类名 对象名 = new 类名() 使用对象：对象.属性 / 对象.方法名() （3）成员变量与局部变量 成员变量：在类中定义，用来描述对象将要有什么。（作用域在整个类内部都是可见的） 局部变量：在类的方法中定义，在方法中临时保存数据。（作用域仅限于定义它的方法） 区别： ①作用域不用 ②两类变量同名时，局部变量的优先级更高..
面向对象知识点整理
m0_49201977的博客
10-02 111
在学习C语言的时候，老师和我们说它是一门面向过程的语言 那么面向对象与面向过程之间有什么区别呢？ 面向过程就是自己干 面向对象就是别人干 举例：我们去吃饭 重点 饭是怎么来的 自己做饭：买菜-洗菜-切菜-炒菜——面向过程 这种事情至始至终都是我们自己解决问题 1.我们处于执行者 2.相对耗费时间、精力，做出来的结果也不一定是最优的 点外卖/去食堂：面向对象——这件事是由别人去做的，我们只需要等待结果 1.我们处于指挥者 2.相对节省时间、精力，做出来的结果一般是可观的 三大特征 1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值