static关键字
代码块：在构造方法前
static静态代码块：最先执行，且只执行一次
abstract抽象类
abstract抽象方法，只有方法名字，没有方法的实现。
- 不能new这个抽象类，只能靠子类去实现它；约束！
- 抽象类中可以写普通的方法。
- 抽象方法必须在抽象类中。
接口
接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程。
接口的本质是契约！
声明接口的关键字是interface
接口中定义的基本类型都是静态常量：public static final
接口中的所有定义其实都是抽象的public abstract
*接口都需要实现类：类的结尾Impl，implements
实现了接口的类，就需要重写接口的方法
多继承，利用接口实现
异常
异常：Exception
检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。在编译时不能被简单的忽略。
运行时异常：是可能被程序员避免的异常。可以在编译时被忽略。
错误：错误不是异常，是脱离程序员控制的问题。在代码中通常被忽略。
异常处理机制
抛出异常
捕获异常
异常处理五个关键字：try、catch、finally、throw、throws
package com.wang.exception;
public class Demo01 {
public static void main(String[] args) {
int a = 0;
int b = 0;
//Ctrl + Alt + T
try{ //try监控区域
System.out.println(a/b);
}catch (Error e){ //catch(想要捕获的异常类型！) 捕获异常
System.out.println("Error");
e.printStackTrace(); //打印错误的栈信息
}catch (Exception e){
System.out.println("Exception");
}catch (Throwable t){
System.out.println("Throwable");
}finally { //处理善后工作
System.out.println("finally");
}
}
}
在开发中，如果去调用别人写的方法时，是否能知道别人写的方法是否会发生异常？这是很难判断的。针对这种情况，Java总允许在方法的后面使用throws关键字对外声明该方法有可能发生异常，这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
如下面代码
public static void main(String[] args) {
// TODO Auto-generated method stub
int result = divide(4,2);
System.out.println(result);
}
public static int divide(int x,int y) throws Exception
{
int result = x/y;
return result;
}
这时候 编译器上会有错误提示 Unhandled exception type Exception
所以需要对调用divide()方法进行try…catch处理
public static void main(String[] args) {
try {
int result = divide(4,2);
System.out.println(result);
} catch (Exception e) {
e.printStackTrace();
}
}
public static int divide(int x,int y) throws Exception
{
int result = x/y;
return result;
}
}
package com.wang.exception;
public class Demo02 {
public static void main(String[] args) {
new Demo02().test(0,0);
}
//假设这方法中，处理不了这个异常，方法上抛出异常throws
public void test(int a,int b) throws ArithmeticException{
if(b==0){
throw new ArithmeticException(); //主动抛出的异常，一般在方法中使用
}
}
}
-
编译时异常
在Java 中，Exception类中除了RuntimeException 类及其子类外都是编译时异常。编译时异常的特点是Java编译器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法编译通过。
处理方法
使用try… catch 语句对异常进行捕获
使用throws 关键字声明抛出异常，调用者对其进行处理
2.运行时异常
RuntimeException 类及其子类运行异常。运行时异常的特点是Java编译器不会对其进行检查。也就是说，当程序中出现这类异常时，即使没有使用try… catch 语句捕获使用throws关键字声明抛出。程序也能编译通过。运行时异常一般是程序中的逻辑错误引起的，在程序运行时无法修复。例如 数据取值越界。
3.自定义异常
JDK中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况。例如divide()方法中不允许被除数为负数。为类解决这个问题，在Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。例子如下
package www.kangxg.jdbc;
public class DivideDivideByMinusException extends Exception {
/**
*
*/
private static final long serialVersionUID = 1L;
public DivideDivideByMinusException(){
super();
}
public DivideDivideByMinusException(String message)
{
super(message);
}
}
package www.kangxg.jdbc;
public class Example {
public static void main(String[] args) throws Exception {
try {
int result = divide(4,-2);
System.out.println(result);
} catch (DivideDivideByMinusException e) {
System.out.println(e.getMessage());
}
}
public static int divide(int x,int y) throws DivideDivideByMinusException
{
if(y<0)
{
throw new DivideDivideByMinusException("被除数是负数");
}
int result = x/y;
return result;
}
}