java基础知识总结（面向对象完结加异常处理）

抽象类与抽象方法

（1）abstract：抽象的。
（2）abstract可以用来修饰：类、方法。
1）abstract修饰类：抽象类
①此类不能被实例化。
②此类中一定有一个构造器，便于子类初始化的时候使用。
③开发中，都会提供抽象类的子类，让子类去实例化，完成相关操作。
2）abstract修饰方法：抽象方法
①只有方法的声明没有方法体。
②包含抽象方法的类一定是一个抽象类，反之不成立，抽象类中不一定包含抽象方法。
③若子类重写了抽象类中的所有抽象方法后，这个子类就可以被实例化，否则，他还是一个抽象类。
（3）abstract使用的注意点：
①不能用来修饰：属性、构造器等结构。
②不能用来修饰私有方法、静态方法、final修饰的类、final修饰的方法。
（4）匿名子类：
例如：
一个抽象类Person。
创建匿名子类：

Person p = new Person(){
		重写的抽象方法;
};

接口

（1）接口使用interface关键字。
（2）java中的类和接口是两个并列的结构。
（3）如何定义接口：
定义接口中的成员：
1）jdk7及以前：只能去定义全局常量和抽象方法。
①全局常量：用public static final修饰的，可以省略不写。
②抽象方法：用public abstract修饰的，也可以省略不写。
2）jdk8后：除了定义全局常量和抽象方法之外，还可以定义静态方法和默认方法。
①静态方法：只能由接口名调用，不能通过子类调用。
②默认方法：通过类的实现，可以调用接口中的默认方法。如果实现类中重写了接口中的默认方法，则调用时，调用的是重写后的方法。
③如果实现类继承的父类和实现的接口中有一个同名同参的方法时，在没有重写的情况下，调用的是父类中的方法。（类优先原则）
④如果实现类实现了多个接口，这些接口中有多个同名同参的默认方法，那么在没有重写的情况下会报错。
⑤在实现类中可以用接口名.super.方法名调用实现的接口中的默认方法。
（4）接口中不能定义构造器，这就意味着接口不能被实例化。
（5）java开发中，让类去实现（implements）接口。
如果实现类实现了接口中的所有静态方法，那么这个类可以被实例化，否则这个类是个抽象类。
（6）java类实现多个接口–>弥补了java但继承性的局限性。
格式：class AA extends BB implements CC,DD,RR……{
}
（7）接口与接口之间可以继承，而且可以是多继承。
（8）接口的具体使用，体现了多态性。
（9）接口实际上就可以看作是定义了一种规范。
（10）接口的四种实现方式：
①非匿名实现类的非匿名对象：

Flash flash = new Flash();

②非匿名实现类的匿名对象：

new Flash();

③匿名实现类的非匿名对象：

Usb u = new Usb(){
     实现接口中的抽象方法;
};

④匿名实现类的匿名对象：

new Usb(){
  实现接口中的抽象方法;
};

内部类

（1）java中允许一个类A声明在另一个类B中，则类A为内部类，类B为外部类。
（2）内部类分类：成员内部类（静态、非静态）、局部内部类（方法内、代码块内、构造期内）
1）成员内部类：
①作为一个类内成员：
–可以调用外部类的结构。
–可以被static修饰。
–可以被4中权限修饰符修饰。
②作为一个类：
–类内可以定义属性、方法、构造器。
–可以用final修饰。
–可以被abstract修饰
（3）值得注意的问题：
1）如何实例化成员内部类：
①静态的：Person.Man m = new Person.Man();
②非静态的：Person p = new Person;
Person.Woman = p.new Woman();
2)如何在成员内部类中区分调用外部类的结构。
①内部类中：使用"this.属性或方法"。
②调用外部类的：“外部类.属性或方法”。
③如果不重名：直接写属性名或方法名即可。
（4）注意：
在局部内部类的方法中，如果调用他声明在的方法中的变量，那么这个变量必须是final的。
JDK 7之前，显式声明为final的。
JDK 8后，可以省略。
（5）生成的字节码文件：
成员内部类和局部内部类，在编译以后，都会生成字节码文件。
格式：成员内部类：外部类$内部类名.class局部内部类：外部类$数字内部类名.class

异常处理

（1）java程序在执行过程中所发生的一场分两类：
①Error：java虚拟机无法解决的严重问题。如：JVM系统内部崩溃、资源耗尽等严重情况。一般不编写针对性的代码进行处理。（如StackOverflowError和OOM）
②Exception：其他因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。
（2）Exception的解决方案：
①遇到错误就终止成语运行。
②程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。
（3）Exception分为编译时异常和运行时异常。
（4）常用的几个异常和异常的体系结构：
Java.lang.Throwable
|-------java.lang.Error:一般不编写针对性的代码进行处理。
|-------java.lang.Exception:可以进行异常的处理
|-------编译时异常(check)
|-------IOEexception
|-------FileNotFoundException
|-------ClassNotFountException
|-------运行时异常(unchecked)
|-------NullPointerException
|-------ArrayIndexOutOfBoundsException
|-------ClassCastException
|-------NumberFormatException
|-------InputMismatchException
|-------ArithmeticException
（5）异常处理机制一：try-catch-finally(抓抛模型)
①过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在代码处生成一个对应异常的对象，并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行。

关于对象的产生：
系统自动生成的异常对象。
手动的生成一个异常对象，并抛出（throw）

② 过程二：“抓”：可以理解为异常的处理方式：
1） try-catch-finally
2） throws
（6）try-catch-finally的使用

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

说明：
①finally是可选的。
②使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据这个对象的类型，去catch中匹配相应的异常。
③一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常处理，一旦处理完成，就跳出当前try-catch结构。（在没有finally的情况下），继续执行后面的代码。
④catch中的异常类型如果没有子父类关系，谁声明在上和下无所谓。
catch中的异常类型如果满足子父类的关系，则子类一点过要声明在父类的上面。否则会报错。
⑤常用的异常处理方式：

System.out.println(e.getMessage);
e.printStackTrace();

⑥在try-catch结构中定义的变量，在出了try-catch结构以后，就不能再被调用了。
⑦try-catch可以嵌套。
⑧fianlly的使用：
–finally是可选的。
–finally中声明的代码一定会被执行，即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
–像数据库连接，IO流，网络编程中的Scoket等资源，JVM是不能自动回收的，我们需要自己手动的进行资源的释放，此时的资源释放，就需要声明在fianlly中了。
体会
①使用try-catch-finally处理编译时异常，使得程序在编译时不在报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。
②开放中，由于运行时异常比较常见，一般我们修改代码就可以吗，所以我，我们可以不针对运行时异常编写try-catch-finally。
针对编译时异常，我们考虑异常处理。
（7）常见的异常处理方式二：
①"throws + 异常类型"写在方法的声明处，指此方法在执行时，可能会抛出的异常类型。一旦方法体执行，出现异常，就会在异常代码处生成一个异常类的对象。此对象满足throws后异常类型时，就会被抛出。异常代码后的代码就不执行了。
体会
try-catch-finally：真正的将代码处理掉了。
throws：只是将异常抛给了方法的调用者，并没有真正的将异常处理掉。
（8）开发中，如何选择异常处理的方式？
①如果父类中被重写的方法没有使用throws方式抛异常时，那么子类重写方法中也不能使用throws抛异常，只能使用try-cahch-finally的方式。
②执行方法a中，先后调用了另外的几个方法，这几个方法是递进关系的，我们建议这几个方法中都用throws方式处理异常，在执行方法a中可以考虑try-catch-finally的方式去处理。
（9）手动抛出异常。

throw new 异常类();

（10）自定义异常类。
①继承现有的异常结构：RuntimeException、Exception。
②提供全局变量：seriaVersionUID。
③提供重载的构造器。