* 1.补全代码的声明：alt + /
* 2.快速修复: ctrl + 1
* 3.批量导包：ctrl + shift + o
* 4.使用单行注释：ctrl + /
* 5.使用多行注释： ctrl + shift + /
* 6.取消多行注释：ctrl + shift + \
* 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
* 8.删除指定行的代码：ctrl + d
* 9.上下移动代码：alt + up 或 alt + down
* 10.切换到下一行代码空位：shift + enter
* 11.切换到上一行代码空位：ctrl + shift + enter
* 12.如何查看源码：ctrl + 选中指定的结构 或 ctrl + shift + t
* 13.退回到前一个编辑的页面：alt + left
* 14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
* 15.光标选中指定的类，查看继承树结构：ctrl + t
* 16.复制代码： ctrl + c
* 17.撤销： ctrl + z
* 18.反撤销： ctrl + y
* 19.剪切：ctrl + x
* 20.粘贴：ctrl + v
* 21.保存： ctrl + s
* 22.全选：ctrl + a
* 23.格式化代码： ctrl + shift + f
* 24.选中数行，整体往后移动：tab
* 25.选中数行，整体往前移动：shift + tab
* 26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
* 27.批量修改指定的变量名、方法名、类名等：alt + shift + r
* 28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
* 29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
* 30.调出生成getter/setter/构造器等结构： alt + shift + s
* 31.显示当前选择资源(工程 or 文件)的属性：alt + enter
* 32.快速查找：参照选中的Word快速定位到下一个 ：ctrl + k
* 33.关闭当前窗口：ctrl + w
* 34.关闭所有的窗口：ctrl + shift + w
* 35.查看指定的结构使用过的地方：ctrl + alt + g
* 36.查找与替换：ctrl + f
* 37.最大化当前的View：ctrl + m
* 38.直接定位到当前行的首位：home
* 39.直接定位到当前行的末位：end
一、继承性的好处：
① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提
二、继承性的格式： class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass
2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
子类和父类的关系，不同于子集和集合的关系。
extends：延展、扩展
三、Java中关于继承性的规定：
1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。
间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
四、 1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2.所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
3.意味着，所有的java类具有java.lang.Object类声明的功能。
1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖 *** 作
2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
重写的规定：
方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{}
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况：子类不能重写父类中声明为private权限的方法
③ 返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。
- 面试题：区分方法的重载与重写
1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器
3.super的使用：调用属性和方法
- 3.1 我们可以在子类的方法或构造器中。
通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。
但是，通常情况下，我们习惯省略"super."
- 3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
- 3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
4.super调用构造器
- 4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
- 4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
- 4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
- 4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
- 4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
1.从结果上来看：（继承性）
- 子类继承父类以后，就获取了父类中声明的属性或方法。
- 创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
2.从过程上来看：
- 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，...
- 直到调用了java.lang.Object类中空参的构造器为止。
正因为加载过所有的父类的结构，所以才可以看到内存中有
- 父类中的结构，子类对象才可以考虑进行调用。
明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象
面向对象特征之三：多态性1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
- 多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。
4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
day13 instanceof的使用和向下转型x instanceof A:检验x是否为类A的对象，返回值为boolean型
使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。
如果返回false，不进行向下转型。
如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
- 多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
- 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。
子类特有的属性和方法不能调用。
如何才能调用子类特有的属性和方法？—— 向下转型：使用强制类型转换符。
（Man m1 = (Man)p2;）
1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性、方法)就具有通用性。
- 属性：无
- 方法：equals() / toString() / getClass() /hashCode() / clone() / finalize() / wait() 、 notify()、notifyAll()
4.Object类只声明了一个空参的构造器
equals()一、回顾 == 的使用：
== ：运算符
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。
（不一定类型要相同）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
补充： == 符号使用时，必须保证符号左右两边的变量类型一致。
二、equals()方法的使用：
1.是一个方法，而非运算符
2.只能适用于引用数据类型
3.Object类中equals()的定义：
public boolean equals(Object obj) {
return (this == obj);
}
说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
4.像String、Date、File、包装类等都重写了Object类中的equals()方法。
重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。
那么，我们就需要对Object类中的equals()进行重写.
重写的原则：比较两个对象的实体内容是否相同
bject类中toString()的使用：1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2.Object类中toString()的定义：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
3.像String、Date、File、包装类等都重写了Object类中的toString()方法。
使得在调用对象的toString()时，返回"实体内容"信息
4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
Java中的JUnit单元测试（eclipse）步骤：
1.选中当前工程 - 右键选择：build path - add libraries - JUnit 4 - 下一步
2.创建Java类，进行单元测试。
此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器
3.此类中声明单元测试方法。
此时的单元测试方法：方法的权限是public,没有返回值，没有形参
4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
说明：
- 1.如果执行结果没有任何异常：绿条
- 2.如果执行结果出现异常：红条
1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
2.掌握的：基本数据类型、包装类、String三者之间的相互转换
基本数据类型 --->包装类：调用包装类的构造器
public void test1(){int num1 = 10;
// System.out.println(num1.toString());
Integer in1 = new Integer(num1);
System.out.println(in1.toString());Integer in2 = new Integer("123");
System.out.println(in2.toString()); //报异常
// Integer in3 = new Integer("123abc");
// System.out.println(in3.toString());Float f1 = new Float(12.3f);
Float f2 = new Float("12.3");
System.out.println(f1);
System.out.println(f2); Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("TrUe");
System.out.println(b2);
Boolean b3 = new Boolean("true123");
System.out.println(b3);//false //特别注意此处，分别是boolean和Boolean，都没定义的情况下一个返回false一个返回null
Order order = new Order();
System.out.println(order.isMale);//false
System.out.println(order.isFemale);//null
}
}
class Order{
boolean isMale;
Boolean isFemale;
}
基本数据类型:调用包装类Xxx的xxxValue()
public void test2(){
Integer in1 = new Integer(12);int i1 = in1.intValue();
System.out.println(i1 + 1); Float f1 = new Float(12.3);
float f2 = f1.floatValue();
System.out.println(f2 + 1);
}
JDK 5.0 新特性：自动装箱 与自动拆箱
public void test3(){
//int num1 = 10;
//基本数据类型-->包装类的对象
//method(num1);//自动装箱：基本数据类型 --->包装类
int num2 = 10;
Integer in1 = num2;//自动装箱 boolean b1 = true;
Boolean b2 = b1;//自动装箱 //自动拆箱：包装类--->基本数据类型
System.out.println(in1.toString()); int num3 = in1;//自动拆箱
}
public void method(Object obj){
System.out.println(obj);
}
基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
public void test4(){int num1 = 10;
//方式1：连接运算
String str1 = num1 + "";
//方式2：调用String的valueOf(Xxx xxx)
float f1 = 12.3f;
String str2 = String.valueOf(f1);//"12.3" Double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
System.out.println(str2);
System.out.println(str3);//"12.4"
}
String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
public void test5(){
String str1 = "123";
//错误的情况：没有相关性
//int num1 = (int)str1;
//Integer in1 = (Integer)str1;
//可能会报NumberFormatException
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1);String str2 = "true1";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
}
总结
包装类面试题
题1
答案：第一题是1.0；第二题是1。
解析：true ? new Integer(1) : new Double(2.0);编译的时候，这段代码得保证true后面的数据类型一致，所以提升为Double
题2
day14 static关键字的使用public void test3() {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
//保存了从-128~127范围的整数。
如果我们使用自动装箱的方式，给Integer赋值的范围在
//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。
目的：提高效率 Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true Integer x = 128;//相当于new了一个Integer对象
Integer y = 128;//相当于new了一个Integer对象
System.out.println(x == y);//false
}
1.static:静态的
2.static可以用来修饰：属性、方法、代码块、内部类
3.使用static修饰属性：静态变量（或类变量）
3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。
当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。
当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
3.2 static修饰属性的其他说明：
① 静态变量随着类的加载而加载。
可以通过"类.静态变量"的方式进行调用
② 静态变量的加载要早于对象的创建。
③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
④ 类：类变量（√） 实例变量（×）
对象：类变量（√） 实例变量（√）
3.3 静态属性举例：System.out; Math.PI;
4.使用static修饰方法：静态方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
②类：静态变量（√） 非静态变量（×）
对象：静态变量（√） 非静态变量（√）
③ 静态方法中，只能调用静态的方法或属性；非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
- static注意点：
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
6.开发中，如何确定一个属性是否要声明为static的？
属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
类中的常量也常常声明为static
开发中，如何确定一个方法是否要声明为static的？
单例设计模式：*** 作静态属性的方法，通常设置为static的
工具类中的方法，习惯上声明为stati c的。
比如：Math、Arrays、Collections
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
如何实现？
饿汉式 vs 懒汉式
- 区分饿汉式 和 懒汉式
饿汉式：
- 坏处：对象加载时间过长。
- 好处：饿汉式是线程安全的
懒汉式：
- 好处：延迟对象的创建。
- 目前的写法坏处：线程不安全。
--->到多线程内容时，再修改
- 1. main()方法作为程序的入口
- 2. main()方法也是一个普通的静态方法
- 3. main()方法可以作为我们与控制台交互的方式。
（之前：使用Scanner）
1.代码块的作用：用来初始化类、对象
2.代码块如果有修饰的话，只能使用static.
3.分类：静态代码块 vs 非静态代码块
4.静态代码块
内部可以有输出语句
随着类的加载而执行,而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
5.非静态代码块
内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
对属性可以赋值的位置：
- ①默认初始化
- ②显式初始化/⑤在代码块中赋值
- ③构造器中初始化
- ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
执行的先后顺序：① - ② / ⑤ - ③ - ④
final关键字final:最终的
1.final可以用来修饰的结构：类、方法、变量
2.final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类
3.final 用来修饰方法：表明此方法不可以被重写。
比如：Object类中getClass();
4.final 用来修饰变量：此时的"变量"就称为是一个常量
4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
4.2 final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。
当我们调用此方法时，给常量形参赋一个实参。
一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
public void show(final int num){
//num = 20;//编译不通过
System.out.println(num);
}
//不可以在方法内赋值，只有在调用时赋值，如test.show(10);
static final 用来修饰属性：全局常量
面试题：排错
public class Something{
public int addOne(final int x){
return ++x;// 错误的，因为改变了x；
//return x + 1;//正确的。
未改变x；
}
}
1.abstract:抽象的
2.abstract可以用来修饰的结构：类、方法
3.abstract修饰类：抽象类
此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的 *** 作
4.abstract修饰方法：抽象方法
abstract使用上的注意点：抽象方法只有方法的声明，没有方法体
包含抽象方法的类，一定是一个抽象类。
反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所有的抽象方法后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
1.abstract不能用来修饰：属性、构造器等结构
2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类
接口的使用1.接口使用interface来定义
2.Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
3.1 JDK7及以前：只能定义全局常量和抽象方法
全局常量：public static final的.但是书写时，可以省略不写
抽象方法：public abstract的
3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
4.接口中不能定义构造器的！意味着接口不可以实例化
5.Java开发中，接口通过让类去实现(implements)的方式来使用.如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化；如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6.Java类可以实现多个接口 --->弥补了Java单继承性的局限性格式：class AA extends BB implements CC,DD,EE
7.接口与接口之间可以继承，而且可以多继承
8.接口的具体使用，体现多态性
9.接口，实际上可以看做是一种规范
面试题：抽象类与接口有哪些异同？
- 1.接口使用上也满足多态性
- 2.接口，实际上就是定义了一种规范
- 3.开发中，体会面向接口编程！
1.Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2.内部类的分类：成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)
3.成员内部类：
一方面，作为外部类的成员：
调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰
另一方面，作为一个类：
类内可以定义属性、方法、构造器等
可以被final修饰，表示此类不能被继承。
言外之意，不使用final，就可以被继承
可以被abstract修饰
4.关注如下的3个问题
- 4.1 如何实例化成员内部类的对象
- 4.2 如何在成员内部类中区分调用外部类的结构
4.3 开发中局部内部类的使用 见《InnerClassTest1.java》
//创建Dog实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();
dog.show();
//创建Bird实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();
bird.sing();
Java虚拟机无法解决的严重问题。
如：JVM系统内部错误、资源耗尽等严重情况。
比如：StackOverflowError和OOM。
一般不编写针对性的代码进行处理。
- java.lang.Error:一般不编写针对性的代码进行处理。
- java.lang.Exception:可以进行异常的处理
运行时异常(unchecked,RuntimeException)IOException
FileNotFoundException
ClassNotFoundException
NullPointerException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
InputMismatchException
ArithmeticException
一、异常的处理：抓抛模型
过程一："抛"：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象,并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行。
关于异常对象的产生：
① 系统自动生成的异常对象 ② 手动的生成一个异常对象，并抛出（throw）
过程二："抓"：可以理解为异常的处理方式：① try-catch-finally ② throws
二、try-catch-finally的使用
try{
//可能出现异常的代码
}catch(异常类型1 变量名1){
//处理异常的方式1
}catch(异常类型2 变量名2){
//处理异常的方式2
}catch(异常类型3 变量名3){
//处理异常的方式3
}
....
finally{
//一定会执行的代码
}
说明：
1.finally是可选的。
2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3.一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。
一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况）。
继续执行其后的代码
4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。
否则，报错
5.常用的异常对象处理的方式： ① String getMessage() ② printStackTrace()
6.在try结构中声明的变量，再出了try结构以后，就不能再被调用
7.try-catch-finally结构可以嵌套
体会1：使用try-catch-finally处理编译时异常，是得程序在编译时就不再报错，但是运行时仍可能报错。
相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
针对于编译时异常，我们说一定要考虑异常的处理。
1.finally是可选的
2.finally中声明的是一定会被执行的代码。
即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的释放。
此时的资源释放，就需要声明在finally中。
1."throws + 异常类型"写在方法的声明处。
指明此方法执行时，可能会抛出的异常类型。
一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。
异常代码后续的代码，就不再执行！
2.体会：try-catch-finally:真正的将异常给处理掉了。
throws的方式只是将异常抛给了方法的调用者,并没有真正将异常处理掉。
3.开发中如何选择使用try-catch-finally 还是使用throws？
- 3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。
- 3.2 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。
我们建议这几个方法使用throws的方式进行处理。
而执行的方法a可以考虑使用try-catch-finally方式进行处理。
方法重写的规则之一：
* 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
- 1. 继承于现有的异常结构：RuntimeException 、Exception
- 2. 提供全局常量：serialVersionUID
- 3. 提供重载的构造器
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）