第六天
1. instanceof 和 类型转化
-
instanceof：用于比较两个对象是否有继承关系
-
类型转化：
-
低可以直接转高
Person //父类
Student //子类
//子类转化为父类，可能丢失自己本来的一些方法，要想再次使用，可以强制转化为子类
Person person = new Student(); //低 转 高
/*
1.父类引用指向子类对象；
2.把子类转化为父类，向上转型；
3.把父类转化为子类，向下转型； 需要强制转换
4.方便方法的调用，减少重复的代码！ 简洁
*/
-
2. static
-
代码块
-
可以使用它开赋 初始值
public class Student{
//它在创建对象的时候生成，并且在构造器之前生成
{
//代码块（匿名代码块）
System.out.println("匿名代码块");
}
//它在类加载时生成，且就执行这一次
static{
//静态代码块
System.out.println("静态代码块");
}
//无参构造方法
public Student(){
System.out.println("无参构造");
}
public static void main(String[] args){
Student student= new Student();
System.out.println("=========================");
Student student1 = new Student();
}
}
/*
运行结果:静态代码块
匿名代码块
无参构造
=========================
匿名代码块
无参构造
*/
//证实了：静态代码块只执行一次，和它们的执行顺序 -
-
静态导入包
import static java.lang.Math.random
-
静态变量
public static int age;
-
静态方法
public static void go(){
}
3. 抽象类
-
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象类；如果修饰类，那么该类就是抽象类
-
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
-
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。
-
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
-
子类 继承 抽象类，那么就必须要 实现抽象类 没有实现 的 抽象方法，否则 该子类 也要 声明为抽象类。
注意抽象的约束：1. 不能new这个抽象类，只能靠子类去实现他
2. 抽象类中可以写普通的方法
3. 抽象方法必须在抽象类中
4. 接口
-
接口：只有规范！自己无法写方法！
-
普通类：只有具体实现
-
抽象类：具体实现和规范（抽象方法）都有！
-
-
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。例如：如果你是汽车，则必须能开着跑等等。
-
接口的本质是契约，就像我们人的法律一样
-
OO的精髓，是对 对象 的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式 都只 针对具备了 抽象能力的语言（比如c++,java+c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
-
声明类的关键字是class'; 声明接口的关键字是interface
-
接口中 所定义的其实都是抽象的public abstract
-
public interface UserService{
public static final int NAME = 'lcb';
//或 int NAME = 'lcb';
public abstract void go();
//或
void go();
/*
这俩写法是一样的，接口中默认方法为：public abstract
默认变量为：public static final (但一般不会在接口中定义变量)
*/
} -
接口一般都会有实现类，以Impl结尾
-
实现了接口中的类，就需要实现接口中的所有方法
-
接口是多继承，可以继承多个接口
-
通过implements来实现接口的继承
public class UserServiceImpl implements UserService[,...,...]{
@Override
public void go(){
}
} -
-
接口不能被实例化，接口中没有构造器
最重要的就是抽象的思维
-
5. 内部类
-
定义：内部类就是在一个类的内部再定义一个类，比如，A类中定一个B类，那么B类为A的内部类，A类为B类的外部类。
-
内部类可以直接访问外部类的私有方法
public class Outer{
private String name = 'lcb';
private void out(){
System.out.println("这是外部类的方法");
}
class Inter{
public void in(){
System.out.println("这是内部类的方法");
out();
}
public void getName(){
System.out.println(name);
}
}
}public class Application(){
public static void main(String[] args){
Outer outer = new Outer();
//通过外部类来实例化 内部类
Outer.Inter inter = outer.new Inter();
inter.getName();
}
}
//结果为：lcb
//牛逼的就是，访问到了，私有属性，实现了高效解体 -
一个java中只能有一个public类，但是可以有多个class文件
-
局部内部类：
public class A{
public void go(){
class B{
}
}
} -
匿名内部类
public class A{
public static void main(String[] args){
//没有 名字初始化类 ，不用将实例保存到变量中
new B().to();
new C(){
@Override
public void go(){
//方法体；
}
};
}
}
class B{
public void to(){
System.out.println("B");
}
}
interface C{
void go();
}
6. 异常
-
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
-
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
-
运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
-
错误ERROR：错误不是异常，而是脱离了程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
-
-
异常体系结构
-
Java把异常当做对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类。
-
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception
-
-
Error
-
Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
-
Java虚拟机运行错误（Virtual MachineError)，当JVM不再有继续执行操作所需要的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般不会选择线程终止；
-
还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError)、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且大多数是程序运行时不允许出现的状况。
-
-
Exception
-
运行时异常
-
在Exception分支中有一个重要的子类RuntimeException（运行时异常）
-
ArrayIndexOutOfBoundsException（数组下标越界）
-
NullPointerException（空指针异常）
-
ArithmeticException（算术异常）
-
MissingResourceException（丢失资源）
-
ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
-
-
这些异常一般是由于程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；
-
-
非运行时异常
-
-
Error和Exception的区别
-
Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程。
-
Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
-
-
异常处理机制
-
异常处理的五个关键字
-
try、catch、finally、throw、throws
-
-
异常的捕获
public class Test{
public static void main(String[] args){
int a=1;
int b=0;
try{ //监控区
System.out.println(a/b);
}catch(ArithmeticException e){ //它用来捕获想要的异常
System.out.println("分母不能为0");
e.printStackTrace(); //打印错误的栈信息
}[catch(){
//...
}catch(){
//...
}]finally{ //处理善后工作，不论是否出现异常，它都执行
}
}
}
/*
1.finally可以不写。例如：在IO流中使用，最后可以用来关闭资源。
2.catch块可以有多个，使用方法类似if-else，捕获的异常从上到下一次增大,且只会生效一个catch块
3.
*/ -
异常的抛出
-
一般用在方法中
public class Test{
public static void main(String[] args){
int a=1;
int b=0;
new Test().test(a,b);
}
public void test(int a,int b){
if(b == 0){
throw new ArithmeticException();
//主动的抛出异常，一般在方法中使用
}
}
}
public class Test{
public static void main(String[] args){
int a=1;
int b=0;
//2.因为在方法上抛出异常了，所以需要在这捕获一下异常
try{
new Test().test(a,b);
}catch(ArithmeticException e){
e.printStackTrace();
}
}
//1.假设这个方法中，处理不了这个异常，方法上抛出异常,
public void testOne(int a,int b) throws ArithmeticException{
}
}
-
-
自定义异常：
-
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
-
在程序中使用自定义异常类，大题可以分为一下几个步骤
-
创建自定义异常类。
-
-
在方法中通过throw关键字抛出异常对象
-
-
如果在当前抛出异常的方法中处理异常，可以使用 try-catch 语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
-
-
在出现异常方法的调用中捕获并处理异常
-
{
自定义异常总结：使用的时候要抛出异常,并捕获异常
Java自带异常：使用时，可以仅抛出来使用（当然不建议），也可以抛出，并捕获异常
}这两句不知道对不对，实践的时候去多多总结吧
//自定义的异常类
public class MyException extends Exception{
//传递数字不为1
private int date;
public MyException(int date){
this.date = date;
}
//toString:打印异常信息
@Override
public String toString(){
return "MyException{"+date+"}";
}
}public class Test{
public static void main(String[] args){
//捕获异常
try{
test(1);
test(0);
}catch(MyException e){
e.printStackTrace();
}
}
public void test(int a) throws MyException{
if(a != 1){
throw new MyException(a); //抛出
}
}
}
-
-
总结
-
处理运行异常时，采用逻辑去合理规避同时辅助 try-catch 处理
-
在多重catch块后面，可以加一个catch（Exception）来处理可能被遗漏的异常
-
对于不确定的代码，也可以加上 try-catch ，处理潜在的异常
-
尽量去处理异常，不要只是简单的调用 printStackTrace() 去打印输出
-
具体如何处理异常，要根据不同的业务需求和异常类型去决定
-
尽量添加 finally 语句去释放占用的资源（尤其在IO流中）
-
-
拓展
1.为什么抽象类都不能创建对象，但还有构造器呢？
-
抽象类作为类一定有构造器，而且抽象类必须有构造器。
-
提供给子类创建对象 调用 父类构造器使用的。
-
-
抽象类虽然有构造器但是抽象类不能创建对象。
-
抽象方法 没有方法体，创建对象不能执行，所以不能创建对象。
-
2.IDEA捕获异常快捷键
-
选中需要捕获异常的代码
-
Ctrl + Alt + t