JAVA 基础部分学习

F1owermoon

于 2022-11-28 20:49:17 发布

阅读量163

点赞数

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/m0_49352508/article/details/128086972

版权

JAVA 基础部分

面向对象

1.类的创建以及调用

类的声明是 class +类名
方法的声明是 public static +返回值的类型+方法名

流程

创建类，2.造对象 Scanner st= new Scanner(System.in) 3. 调功能
192

构造方法的方法名和类型相同，没有返回值类型，无参构造方法系统会默认调用，不用我们声明定义，但是如果我们自定义了一个有参的构造方法，那么我们就要显示的定义无参构造方法，它的作用就是当我们new实例化一个类的对象的时候，系统就是自动执行这个构造方法，并进行一些初始化工作。

构造方法

1、构造方法的特点：
（1）构造方法的名字必须与定义他的类名完全相同（甚至连void也没有），且没有返回类型；

（2）构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。

Person p = new Person(); : person() 调用的就是Person的构造方法。
1
（3）每个类可以有零个或多个构造方法；

（4）不能被static、final、synchronized、abstract和native修饰。且构造方法不能被子类继承。

（5）构造方法在创建对象时自动执行，一般不能显式地直接调用。
—————

快捷键

shift ＋回车空下一行
ctrl ＋shift ＋回车调整代码，并且将光标移动最后
https://www.php.cn/java/guide/478876.html

数组

一维数组声明和初始化

int [] arr4=new int [10];

Arrays 数组的操作方法 API 工具类

boolean equals(int []a, int [] b);//判断两个数组是否相等

String toString(int [] a)  //输出数组信息

void fill(int []a,int val) 将指定的值填充到数组中（全部替换为val）4.

void sort(int [] a) //对 a 进行排序处理

面向对象

1. 面向对象思想编程内容的三条主线

1. 类以及类的成员：属性，方法，构造器；代码块，内部类
2. 面向对象的三大特征：封装，继承，多态
3. 其他关键字：this super ，interface，static,final,package;

2. 面向对象的编程思想

类和对象的，面向对象的三大特征
万事万物皆对象

3. 谈谈对面向对象中类和对象的理解，并且指出二者的关系

类：抽象的，概念上的内容。
对象：实实在在存在的个体。真正的创建了一个对象，占内存空间
对象是由类派生出来的

4. 面向对象的思想的体现一：类和对象的创建和执行操作有哪三步

1.创建类
2.类的实例化，创建对象
3.调用对象的结构：“对象.属性”，或者“对象.方法”。

// 局部变量都是在栈空间中，且生命周期结束销毁

类的方法内是否可以定义变量，是否可以调用属性，是否可以定义方法，是否可以调用方法？
是；是；否；是

理解

过程的理解
面向过程：强调的是功能行为
面向对象：强调具备功能的对象/类
写代码的思路
1. 现实世界中的主体
2. 概念世界中的类
3. 相乘后计算机世界中类的定义
4. 将类实例化计算机世界的对象

补充：几个概念的使用说明

属性=成员变量=field=域、字段
方法=成员方法=函数=method
创建类的对象 = 类的实体化 = 实例化类

对象的创建与对象的内存解析

person p1 =new person();
person p2 = new person();
person p3=p1;

先编译一后运行，bin是虚拟机的文件，生成 .class （编译之后）
编译完源程序 -> 生成一个或者多个字节码文件

使用JVM中类的加载器和解释器对生成的字节码文件进行解析运行，放到内存中

虚拟机栈 = 平时提到的栈

将局部变量存放在这个栈中

堆，平时所说的堆，将new出来的结构（数组，对象）加载在堆中

（非static的）对象的属性，加载在堆当中

方法区，类的加载信息，常量池，静态域（static中）

属性 VS 局部变量
局部变量要先声明再使用；

万事万物皆对象

在Java语言范畴中，我们都将功能、结构等封装的到类中，通过类的实例化，来调用具体的功能结构
涉及Java语言与前后端Html 后端数据库交互时，前后端的结构在Java层面交互时，都体现为类，对象。

内存解析的说明

引用类型的变量，只可能存储两类值，NULL 或者地址（含变量的类型）

三、匿名对象的使用

理解，我们创建的对象，没有显示的赋给一个变量名，即为匿名对象
特征：匿名对象只能调用一次
只能用一次，匿名对象，除非指定给具体的对象
直接放入 new phone（）

class Phone{
	public void sendEmail(){
	}
	public void playGame(){
	}
}

new Phone().sendEmial();
new Phone().playGame();

再谈方法

一、方法的重载

一个类中，允许存在多个同名的方法，只要他们的参数个数或者参数类型不同即可

同名方法构成了重载

由于参数名字不同，所以可以区分

两同一不同：
同一个类，相同方法名
参数列表不同，参数个数不同，参数类型不同

判断是否是重载：
跟方法的权限修饰符，返回值类型，形参变量名，方法体都没关系
满足自动类型升级
在通过对象调用方法时，如何确定某一个指定的方法：
方法名 —> 参数列表
和返回值无关，只看方法名和形参

二、可变形参的方法

1. 定义方法，形参类型 ... 形参名称

public void show(String ... strs){

}

2.当调用可变形参的个数时，传入的参数个数可以时0，1，2，3 .。。 都可以
3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

public void show(String [] strs){
	for(int i=0;i<strs.length;i++){
		System.out.println (strs[i]);
		}

}          同等与上面

4.可变个数形参的方法与本类相同，形参类型也相同的数组之间不构成重载
5.可变个数形参在方法的形参中，必须声明在末尾
6.可变个数形参在方法的形参中,最多声明一个可变形参

三、方法参数的值传递机制

方法，必须由其所在的类或者对象调用才有意义。
规则：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

若方法含有参数：形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值

Java里方法的参数传递方式只有一种：值传递。将实际参数值的复制品，传入方法内，而参数本身不受影响

方法的形参的传递机制：值传递
1. 形参：方法定义时，声明的小括号内的参数
2. 实参：方法调用时，实际传递给形参的数据

存在 static 必须new 一个新的对象，才能使用

值传递机制
1. 如果参数时基本数据类型，此时实参付给形参的时实参真实储存的数据值

四、递归方法

递归方法：一个方法体内调用它自身
方法递归包含了一种隐式的循环，它会重复执行某段代码，但在这种重复执行无需循环控制。

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环

return 的作用

结束方法
有返回值，返回数据

P218 复习

方法的重载与重写的区别
{
两者没有任何关系；
}

面向对象特征之一：封装与隐藏

思想：把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。

高内聚，低耦合。内部操作自己完成，不允许干涉，外部紧外暴露少量的方法用于使用

同时避免堆属性进行赋值，

二、封装性的体现

将封装属性私有化，同时提供公共（public）的方法来获取和设置

拓展：封装性的体现：不对外暴露私有的内部东西

三、封装性的体现，需要权限修饰符来配合。

Java规定的4（从下到大）种权限 private ，缺省（什么也不写），protected，public
四种权限可以用来修饰类以及类的内部结构：属性、方法、构造器、内部
具体的，四种权限都可以修饰类的内部结构
修饰类的话只能用缺省，public

出了Order 类所属的包以后，四有的结构、缺省声明的结构就不可以调用了

类的结构三：构造器或者构造方法

constructor: 建设、建造。 construction

一、构造器的作用

创造对象
初始化对象的信息

二、说明：

如果没有显示定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名（与类同名）（形参列表）{ }
一个类种允许多个构造器，构成（重载）
一旦定义了类的构造器之后，系统就不再提供默认的空参构造器。
在一个类种一定会存在构造器，至少要有一个构造器。

构造器是造对象的

方法是函数，被调用的两者不相同

总结：属性赋值的先后顺序

默认初始化
显式初始化
构造器中赋值
通过“对象.方法 ” 或者 “ 对象.属性 ”的方法，赋值

1 -> 2-> 3 -> 4

Java Bean 式一种Java语言写成的可重用组件

符合一下Java规则
1. 类式公共的
2. 有一个无参的公共的构造器
3. 有属性，且有对应的get，set方法

This 关键字

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

this 当形参与属性重名的时候，可以用this 表示this.name 是这个类的属性name

使用

1. this 可以用来修饰：属性、方法、构造器
2. this 修饰属性和方法
	1. 理解为当前对象

在类的方法种，我么可以使用 this 调用当前对象属性或者方法。通常情况下，可以省略this 特殊情况下必须显示的使用this ，表示变量是属性，而非形参 

3. this 调用构造器
	1. 如果在类的构造器种，可以显示的使用“this”方式，调用本类中指定的其他构造器
	2. 构造器中不能通过“this” 方式调用自己
	3. 如果一个类中有n个构造器，则最多有n-1构造器中使用了“this(形参列表)”
	4. this 必须声明在构造器的首行
	5. 构造器内部，最多只能声明一个this ，用来调用其他构造器

Package

一、使用

1. 为了更好的实现项目中类的管理，提供包的概念
2. 使用package 使命类或者接口所属的包，声明在源文件的首行
3. 包，属于标识符，遵循标识符的命名规则、规范，见名知意
4. 每. 一次，就代表一层文件目录

补充：同一个包下，不能命名同名的类，接口
不同的包下，可以命名同名的类，接口

MVC 的设计模式

1. MVC 对应三个层次，视图模型层，控制器层，与数据模型层。

Pasted image 20220928184930

Pasted image 20220928185058

Import 关键字的使用

导入 import
1.在源文件中显示的使用import 结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个结构，则并列的写出即可
4. 可以使用xxx.*的形式，将所有的包全部导入
5. 如果使用的是Java.lang 包下的，则可以省略这个结构

继承性(OOP特征二)

一、继承性的好处

1. 减少了代码的冗余，提高了代码的重复性
2. 便于功能的扩展
3. 为之后的多态性的使用提供了前提

二、继承性的按格式：

calss A extends B{
	//声明结构
}

A：子类、爬升类，subclass
B：弗雷、超类、基类、superclass
体现：一旦子类A继承父类B以后，子类A中就获取了父类中声明过所有的结构：属性、方法
特别的，父类中声明为private的属性或者方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只因为封装性的影响，所以子类不能直接调用父类的结构。

子类继承父类之后，可以继续定义自己的构造器，属性，方法。实现功能的扩展

Java中关于继承性的规定

1.一个类可以被多个子类继承。
2.Java中类的单继承行：一个类只能有一个父类。
3. 子父类是相对的概念。
4. 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。多层继承，全部继承。

四、

1.如果我们没有现实的声明一个类的父类的话，则此类继承于java.lang.Object类
2.所有的Java类（除上）都直接或者间接的继承与java.lang.Object类
3.一维这，所有的Java类具有java.lang.Object类声明的功能

方法的重写（override）

在子类中可以对从父类中继承来到方法进行改造，也成为方法的重置、覆盖。在程序执行的时候，子类的方法将覆盖父类的方法。

1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
2.应用：重写以后，当创建子了对象以后，通过子类对象调用子父类中的同名同参数的方法是，实际执行的是子类重写父类的方法。
3. 重写的规定：
	1. 方法的声明：权限修饰符，返回值类型，方法名（形参列表）throws 异常的类型{
				//方法体
	   }
	2.约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
1. 子类中重新写的方法的方法名和形参列表与父类中被重写的方法的方法名和形参列表相同
2. 子类重写的方法的权限修饰符不小于父类被重写的权限修饰符（保证能被覆盖掉） 特殊情况：子类不能重写中声明为 private 的方法
3. 返回值类型：
	1. 如果父类中被重写的返回值是void 则子类中被重写的返回值类型只能是 void
	2. 父类被重写的方法的返回值类型是A类型，则子列重写的方法的返回值类型可以是A类或者A类型的子类型
	3. 父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型（必须也是doble）
	4. 子类重写的方法抛出的一场类型不大于父类被重写的方法抛出的异常类型。

实际开发中直接copy要重写的方法

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static（不是重写）

super 关键字

1.super理解为：父类的
2. super 可以用来修饰方法，属性，构造器
3. super 的使用 同等与this 只不过是子父类的关系
super.age 和this.age 
	1. 我们可以在子类方法和构造器中，通过使用super.属性或者 super.方法的方式，显示的带哦用父类中声明的属性或者方法。通常情况下我们习惯省略 super
	2. 特殊：当子类和父类中定义了同名的属性是，我们要想在子类中调用父类中声明的属性。
	3. 特殊情况：当子类重写父类中方法后，想调用父类中被重写的
4.super调用构造器
	1.我们可以在子类的构造器中显示的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器
	2.“super（形参列表）”的使用，必须声明在子类构造器的首行
	3.我们在类中的构造器中，针对于“this”或者“super”只能二选一。不能同时出现。

public Person(String name,int age){
	super(name,age);
}

	4.在构造器的首行，没有显示的声明“this”或者“super”	则默认调用的是父类中空参的构造器

子类对象的实例化过程

1. 从结果上来看：（继承性）

	子类继承父类以后，就获取的父类中声明的属性或者方法。
	创建子类的对象，在对空间中，就会加载所有父类中声明的属性

2. 从过程上来看：

	当我们通过子类的构造器，创建子类对象时，我们一定会直接或者间接的调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有弗列终端结构，子类对象才可以考虑进行调用。

面向对象的特征三：多态性

1.理解多态性：可以理解为一个实物的多种形态

	Person p2 = new Man();

父类的引用指向子类的对象
2. 多态的使用：虚拟方法调用
	有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类.
	总结：编译，看左边；运行，看右边
3.多态使用的前提 
	1.类的继承关系 
	2.方法的重写

实现代码的通用性 Objetc中定义的public boolean equals(Object obj){}
//存放的是类的子类可以

Pasted image 20221005154502

instanceof关键字的使用

1. a instaanceof A ：判断对象a是否是类A的实例。 如果是，返回true;如果不是 返回false
   2. 使用情景，为了避免在向下转型时出现ClassException 的异常，我们在向下转型之前，先进行instanceof 的判断。一旦返回true 就进行向下转型，如果返回 false，不进行向下转型
3. 如果a instanceod A 返回true，则a instanceof B 也返回true，其中 类B是类A的父类

向上转型，多态。强转符：（）

Object 类的使用

Pasted image 20221005181751

equals（）关键字的使用

一、回顾 == 的使用：

1.可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
		如果比较的是引用数据类型变量：比较两个对象的地址值是否相同。即两个引用

二、equals（）方法的使用

1.是一个方法，而非运算符
2.只能适用于引用数据类型
3. Object 类中 equals（）的定义 Object类中定义的equals（）和==作用是相同的：比较地址值是否相同
4. 像String,Data,File、包装类等都重写了Object 类中的equals（）的方法。重写以后，比较的不是两个引用的地址是否相同，二是比较两个对象的“实体内容”是否相同
5. 通常情况下，我们自定义的类如果使用equals
   （）的话，也通常是比较两个对象的实体内容是否相同。那么我们就需要对Object类中的equals（）进行重写
//重写的原则，比较两个对象的试题内容（name和age ）是否相同

在实际操作中，自动生成 IDEA中Alt+ins

Pasted image 20221005182241

toString方法

包装类的使用

Java中JUnit单元测试（IDEA直接测试）

基本数据类型和包装类之间的相互转换

Pasted image 20221005104302

一、基本数据类型到包装类

public void test1{
	int num1=10;
	Integer in1 = new Integer(num1);
	System.out.println(in1.toString());
}

二、包装类转化为基本数据类型

public void test2{
	Integer in1= new Integer(12);
	int in2=in1.intValue();
}

三、基本数据类型，包装类转化为字符串

public void test3{
	int num1=10;
	//方法一
	String str1= num1+"";
	//方法二：调用String 重载的valueof（）
	float f1=12.f;
	String str2=String.valueof(f1);
	Double d1=new Double(12.5);
	String s3=String.valueod(d1);

}

自动拆箱可以让基本数据类型与包装类互相转化

IntegerCache结构，保存了-128~127的数据，如果赋值的时候在这个范围内，则可以直接使用数组的元素，不用再去new了，为的是提高效率。
Pasted image 20221005153745

关键字：static

1. static ：静态的
2， 可以用来修饰属性、方法、代码块、内部类
3.static修饰属性：静态变量（类变量）
		属性，按照是否使用static修饰分成，静态属性和非静态属性（是咧变量）
		实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象的非静态属性是，不会导致其他对象中同样的属性值的修改
		静态变量：我们创建了类的多个变量，多个对象共享一个静态变量。导致其他对象调用此静态变量时，是修改过的。  
	2. 其他说明
		1. 静态变量随着类的加载而加载  可以通过类.静态变量的方法进行调用
		2. 静态变量的加载要早于对象的创建
		3. 类只会加载一次，则静态变量也只会存在一份:存在方法区的静态域中
		4.    类变量    实例变量
		类     yes        no
		对象    yes        yes

4. static修饰方法：静态方法
	1.随着类的加载而加载，可以通过类.方法来直接调用（不用创建对象）
	2.静态的方法中，只能调用静态的方法或者属性
		非静态的方法中，均可以调用

5.static注意点：
	在静态的方法内，不能使用this，super关键字

6. 开发中，如何确定一个属性是否要声明为static
	> 属性是可以被多个对象所共享的，不会随着对象的不同而不同
7.开发中，如何确定一个方法是否需要声明为static 
	> 操作静态属性的方法，通常设置为static
	> 工具类中的方法，习惯上声明为static ，Math，Arrays

类的成员之四：代码块

1. 代码块的作用

1.初始化类或者对象

2. 代码块的分类

1. 静态代码块（static修饰）
> 内部可以有输出语句
> 随着类的加载而执行，而且只执行一次
> 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构	

2. 非静态代码块
> 随着对象的创建而执行
> 内部可以有输出语句
> 每创建一个对象，就执行一次非静态代码块
> 作用：可以在创建对象时，对对象的属性等进行初始化
> 如果一个类中定义了多个非静态代码块，则按照顺序进行执行
> 非静态代码块内可以调用静态的属性、静态的方法、或者非静态的属性、非静态的方法

属性赋值的位置
Pasted image 20221006141617

执行的先后顺序：① - ② / ⑤ （看出现的顺序）- ③ - ④

Final关键字的使用

1.final ：最终的
2. final 可以用来修饰的结构：方法，类，属性
3. final 用来修饰一个类 ， 不能够被其他类继承。不能被继承
	例如：String 类，System类

Pasted image 20221006142330

抽象类与抽象方法（抽象性）

abstract 关键字的使用

abstract ：抽象的
abstract 可以用来修饰的结构：类，方法
abstract 修饰类：抽象类

此类不能实例化

抽象类中一定有构造器。便于子类对象实例化时调用（涉及子类对象实例化的过程）
abstract 修饰方法：抽象方法

抽象方法只有方法的声明，没有方法体

包含抽象方法的类一定是一个抽象类。反之抽象类中可以没有抽象方法

若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，此子类必须抽象化

接口

类似于USB接口，就是一种规范

1.接口的使用

1.用interface来定义

2.在Java中，接口和类是并列的两个结构

3.如何定义接口：定义接口中的成员

3.1 JDK7以前，只能定义全局常量和抽象方法

> 全局常量：public static final的（但是书写时可以省略）

interface Flyable{
    public static final int MAX_SPEED=7900;
    int MIN_SPEED=1;
}

> 抽象方法：public abstract 的 (也可以去省略)

public abstract void fly();
    void stop();

3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

4.接口中不能定义构造器！意味着接口不可以实例化

5.在Java开发中，接口通过让类去实现（implements）（类和接口的关系）

类去实现接口

如果实现类覆盖了接口中所有抽象方法，则此实现类就可以实例化

如果实现类没有覆盖结构中所有的抽象方法，则此实现类仍为一个抽象类

public abstract void fly();
public abstract void stop();

6.Java类可以实现多个接口（多实现）—> 弥补了Java 单继承性的局限性

格式：

class AA extends BB implements CC ,DD,EE

7.接口与接口之间可以继承，可以多继承

8.接口的使用，能够体现多态性

9.接口实际上可以看作是一种规范

使用也是用多态的方法去用，使用上也满足多态性

package hello;

public class USBtest {
    public static void main(String[] args) {
        Computer cm=new Computer();
        Flash flash=new Flash();
        cm.transferData(flash);
    }
}
class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("具体传输细节");
        usb.stop();
    }
}
interface USB{  //定义了一种规范
    void start();
    void stop();
}
class Flash implements USB{
    @Override
    public void start() {
        System.out.println("Upan开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}
class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

接口就是一种规范

创建了接口的匿名实现类的非匿名对象

创建了接口的匿名实现类的匿名对象

2.接口的应用：代理模式

3.工厂模式（23种设计模式之一，了解）

Java 8 种新特性

1.接口中定义的静态方法，只能通过接口来调用

2.通过实现类的对象，可以调用接口中的默认方法

如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法

3.如果子类（或者实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此类方法的情况下，默认调用的是父类中的同名同参数的方法（类优先原则）

4.如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况西，报错 -->接口冲突。

内部类：类的内部成员之五

1.Java中允许讲一个类A声明在另一个类B中，则类A 就是内部类，类B成为外部类

2.内部类的分类：成员内部类 vs 局部内部类（方法内，代码块内，构造器内）

3.成员内部类：

>一方面，作为外部类的成员：

①调用外部类的结构

②可以被static 修饰

③可以被四种不同的权限修饰

>另一方面，作为一个类：

①类内可以声明定义属性，方法，构造器等

②可以被Final 修饰，表示此类不能被继承。言外之意，没有final 则可以进行继承操作

③可以被abstract 修饰，可以抽象化、

4.关注一下三个问题

①如何实例化成员内部类的对象

②如何在成员内部类中区分带哦用外部类的结构

③开发中局部类的使用

异常处理

一、异常的概述与异常体系结构

两者顶级的父类叫做 Throwable

OutOfMemory （OOM） Error

狭义上的异常处理，叫做Exception

存在两种 1. 编译时异常 2. 运行时异常

一、异常体系结构

二、常见异常

三、异常处理机制一：try -catch - finally

一、异常处理：抓抛模型

过程一：“抛” ：程序在正常执行过程中，一旦出现异常，就会在异常代码出生成一个对象异常类的对象。并且将此对象抛出。

关于异常对象的产生：① 系统自动生成的异常对象

② 手动的生成一个异常对象，并抛出（throws）

一旦抛出对象以后，其后的代码就不再执行。

过程二：“抓” ：可以理解为异常的处理方式：① try-catch-finally ② throws

二、try -catch-finally 的使用

try{
    //可能出现的代码
}catch(异常类型1 变量名1){
    //处理异常的方式1
}catch(异常2)
finally {
    //一定会执行的代码
}

finally 的使用

finally是可以选择的
finally 中声明的是一定会被执行的代码。即使catch中又出现异常了，try 中有 return 语句，catch中有return 语句等情况，finally 依旧会被执行
像数据库连接，输入输出刘，网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放，此时的资源释放，就需要声明在finally 中。

四、异常处理机制二：throws+异常类型

“throws + 异常类型 ” 写在方法的声明出。指明此方法执行时，可能会抛出异常类型

一旦当方法体执行时，出现异常，仍会在异常代码出生成一个异常类的对象此对象满足throws 后异常类型时，就会被抛出去。
体会：try -catch- finanlly ：真正的将异常给处理掉了

throws 的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉

开发中如何选择使用 try -catch- finally 还是使用throws ？

1. 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws ，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理 。
2. 执行的方法A中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws 的方法进行处理。而执行的方法a 可以考虑使用 try -catch-finally 方法处理

五、手动抛出异常：throw

六、用户自定义异常封装类

如何自定义异常类？

1. 继承于现有的异常结构：RuntimeException\Exception
1. 提供全局常量：serialVersionUID
1. 提供重载的构造器

Java基础部分小结

学习的内容：

	1. Java基础语法
	1. 基本语法
	1. 数组
	1. 面向对象的编程（上）
	1. 面向对象的编程（中）
	1. 面向对象的编程（下）
	1. 异常处理

F1owermoon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA 基础部分学习

Java基础部分学习
复制链接

扫一扫

JAVA 基础部分学习

JAVA 基础部分

面向对象

1.类的创建以及调用

流程

构造方法

数组

面向对象

1. 面向对象思想编程内容的三条主线

2. 面向对象的编程思想

3. 谈谈对面向对象中类和对象的理解，并且指出二者的关系

4. 面向对象的思想的体现一：类和对象的创建和执行操作有哪三步

理解

万事万物皆对象

三、匿名对象的使用

再谈方法

一、方法的重载

二、可变形参的方法

三、方法参数的值传递机制

四、递归方法

面向对象特征之一：封装与隐藏

二、封装性的体现

三、封装性的体现，需要权限修饰符来配合。

类的结构三：构造器或者构造方法

一、构造器的作用

二、说明：

Java Bean 式一种Java语言写成的可重用组件

This 关键字

使用

Package

一、使用

MVC 的设计模式

Import 关键字的使用

继承性(OOP特征二)

一、继承性的好处

二、继承性的 按格式：

Java中关于继承性的规定

四、

方法的重写（override）

super 关键字

子类对象的实例化过程

1. 从结果上来看：（继承性）

2. 从过程上来看：

面向对象的特征三：多态性

instanceof关键字的使用

Object 类的使用

equals（）关键字的使用

一、回顾 == 的使用：

二、equals（）方法的使用

toString方法

包装类的使用

Java中JUnit单元测试 （IDEA直接测试）

基本数据类型和包装类之间的相互转换

一、基本数据类型到包装类

二、包装类转化为基本数据类型

三、基本数据类型，包装类转化为字符串

关键字：static

类的成员之四：代码块

1. 代码块的作用

2. 代码块的分类

Final关键字的使用

抽象类与抽象方法（抽象性）

接口

1.接口的使用

接口就是一种规范

2.接口的应用：代理模式

3.工厂模式（23种设计模式之一，了解）

Java 8 种新特性

内部类：类的内部成员之五

异常处理

一、异常的概述与异常体系结构

两者顶级的父类叫做 Throwable

存在两种 1. 编译时异常 2. 运行时异常

一、异常体系结构

二、常见异常

三、异常处理机制一：try -catch - finally

一、异常处理：抓抛模型

二、try -catch-finally 的使用

finally 的使用

四、异常处理机制二：throws+异常类型

二、继承性的按格式：

Java中JUnit单元测试（IDEA直接测试）