一、设计模型之模板模型
1、定义
。实现类和接口中的方法保持一致
。为什么要保持一致？ 为了扩展性，我们要求，是实际编程中，
尽量使用多态，使用多态的过程中，我们发现，如果子类中有特有
方法，那么，无法使用，所以，我们要求，尽量让子类和父类中的
方法保持一致，开发中，我们又发现，接口作为父类的情况较多，
当接口作为父类，实现类和接口中的方法保持一致时，我们称这种现象
为模板模型。
。使用接口指定规则，然后子类根据实现不同的方法内部代码
。实现类暴露的可用方法必须和接口中相同
二、成员内部类
。成员内部类作用：对类中的成员再次整理
1、定义：
。内部类就是在类的内部定义另一个类
2、使用：
。内部类可以直接访问外部类的成员，包括私有
。外部类名.this .成员
。外部类调用内部类方法，必须先创建对象
。内部类名 对象 = 内部类对象
。内部类 对象名 = new 内部类（）
public class Outer{
//外部类非静态方法
public void outerMethod(){
System.outprintln("外部类方法");
//外部类调用内部类方法 必须先创建内部类对象
Inner inner = new Inner();
inner.innerMethod();
}
class Inner{
//内部类非静态方法
public void innerMethod(){
//内部类调用外部类非静态方法
//Outer.this.outerMethod();
//如果没有相同的方法 可以省略前缀
outerMethod();
}
}
}
3、别的类要访问内部类的成员，就必须创建对象
。外部类名.内部类名 对象名 = 外部类对象.内部类对象
。外部类.内部类 对象名 = new 外部类（）.new 内部类（）
public static void mian(String[] args){
//创建内部类对象，必须要先创建外部类对象
Outer.Inner inner = new Outer().new Inner();
//调用内部类方法
inner.innerMethod();
}
4、内部类的权限
。内部类的权限和成员方法一样，可以有private 默认protected
public
。外部类只能是public和默认的
。private效果等同于私有化方法，别的类无法直接调用，但是外部类
可以调用，可以通过方法return回去
。我们完全可以把内部类当做是一个类中的方法来看待
。内部类同时具有方法和类的所有权益
public class Outer{
//外部类非静态方法
public void outerMethod(){
//私有化的内部类只能在外部类中使用
Inner inner = new Inner();
inner.innerMethod();
}
//只能在内部类使用
private class Inner{
//内部类非静态方法
public void innerMethod(){
}
}
public static void main(String[] args){
Outer.Inner inner = new Outer().new Inner();//报错
}
}
5、注意事项：
。成员内部类中方法可以随意调用外部类的方法，因为安全。
。成员内部类方法可用时，说明成员内部类对象一定存在，
成员内部类对象存在，说明外部类对象一定存在
。外部类的方法无法直接调用成员内部类的方法
。因为外部类方法可用时，我们不确定内部类对象就一定存在
，就是存在，也有可能有多个内部类的对象
三、静态内部类
。
1、定义：
。使用static 关键字修饰内部类
2、使用
。调用静态内部类内部的非静态方法
。外部类名.内部类名 对象名 = new 外部类名.内部类名（）；
public calss Outer{
//静态内部类
public static class Inner(){
//静态内部类的非静态方法
public void innerMethod(){
}
}
}
public static void main(String[] args){
//创建内部类对象
Outer.Inner inner = new Outer.Inner();
//调用内部类的方法
inner.innerMethod();
}
。调用静态内部类内部的静态方法
。外部类名.内部类名.方法名（）
public class Outer{
//静态内部类
public static class Inner{
//静态内部类的静态方法
public static void innerMethod(){
}
}
}
public static void main(String[] args){
//类名调用
Outer.Inner.innerMethod();
}
。静态内部类调用外部类的非静态方法
。必须先new出外部类然后才能调用
public class Outer{
//外部类非静态方法
public void outerMethod(){
System.out.println("外部类的非静态方法");
}
//静态内部类
piublic static class Inner{
//静态内部类非静态方法
public void innerMethod(){
//必须先创建外部类对象
new.Outer().outerMethod();
}
}
}
3、注意事项
。内部类中如果有静态方法，那么内部类也必须是静态的
。内部类是静态的，并不意味着内部类中的方法都是静态的，只是说
明我们可以绕过外部类对象直接找到内部类来使用
。在静态内部类中，可以使用外部类的静态成员，不可以使用外部类的
非静态成员
。在静态内部类中，
四、局部内部类
1、定义：
。定义在类中的方法中的内部类叫做局部内部类
2、使用：
。极端情况下有用:一个方法内的代码在当前方法内需要重复使用多次
，当出了这个方法就有用处了
。局部内部类的作用范围仅限本方法中
。局部内部类在访问它所在方法中的局部变量必须使用final
修饰
。局部内部类想要使用局部变量，那么，变量必须变成常量
。因为当调用这个方法时，局部变量如果没有用final修饰，它的生命
周期和方法的生命周期是一样的，当方法弹栈，这个局部变量也会
消失，那么如果局部内部类对象还没有麻黄素那个消失想用这个变
量，就没有了，如果用final修饰会在类加载的时候进入常量池，即使
方法弹栈，常量池的常量还在，也可以继续使用
。jdk1.8取消的这个定义，其实不是取消了，是设置为了隐式的
public static void main(String[] args){
//局部内部内使用局部变量必须是final的
final String name = "小红";
//局部内部类
class Inner{
public void method(){
System.out.println("局部内部类");
}
public String method2(){
return name+ "爱你";
}
}
Inner inner = new Inner();
inner.method();
inner.method2();
}
五、匿名内部类
1、定义：
。匿名内部类就是局部内部类的简写形式，相当于是一个
没有名字的子类
。匿名内部类用于定义接口的或者类的子类
2、使用：
。前提是必须存在一个类，或者接口
。这里的类可以是具体的类也可以是抽象的
。相当于是一个没有名字的子类继承或者实现一个类或者接口
，然后重写里面的方法，本质是一个继承了该类或者实现了该
接口的匿名子类对象
。多用于规则简单，子类使用很少的接口应用中
3、格式：
。new 类名或者接口名（）{
重写方法；
}
4、演示：
public static void main(String[] args){
//匿名内部类
MyInterface mi = new MyInterface(){
@Override
public void method(){
System.out.println("重写接口的方法");
}
};
}
六、异常
1、定义：
。异常是指java程序在运行过程中出现的错误Throwable
2、分类：
。Error 错误 致命的错误 比如数据库崩溃 服务器宕机
。Exception 异常 局部行的错误， 警报 告诉开发者程序有问题
或可能出现问题
。编译时异常
。因为语法不规范，对代码没有进行预制处理导致异常，编译器
可以检查出来，如果不处理，编译无法通过
。运行时异常 导致程序停止运行
。编译时期不报错，运行时报错
。常见的角标越界，空指针等都是运行时异常，也就是只有运行起
来才能发现的，这是程序员犯的错误
七、异常的处理
。异常：程序发生问题，无法继续运行
。运行时异常：这个问题是程序运行起来之后，才发生的
。编译时异常：这个问题是在编译时发生的
1、jvm是如何处理异常的
。运行时出现异常，jvm打印异常信息，并停止运行
2、手动处理异常的两种方式
。抓取异常并处理
。对异常进行处理后，程序依然可以继续执行
。手动抛出异常
。程序会在抛出异常的点上停止运行并将异常信息抛出
3、抓取处理方式
。try{} catch（异常类型）{}
public static void main(String[] args){
int i = 0;
try{
//将可能出现异常的代码包裹起来
int num = 10/i ;
}catch(Exception e){
//对相应类型的异常信息进行处理
e.printStackTrace();//打印异常信息
}
}
。try{}catch(异常类型){} catch（异常类型）{}.....
public static void mian(String[] args){
int i = 0;
try{
//将可能出现异常的代码包裹起来
int num = 10/i;
}catch(ArithmeticException e){
//对相应类型的异常信息进行处理
e.printStackTrace();//打印异常信息
}catch(Exception e){
//对相应类型的异常信息进行处理
e.printStackTrace();//打印异常信息
}
}
。try{}catch（异常类型）{}finally{}
public static void main(String[]args){
int i = 0 ;
try{
//将可能出现异常的代码包裹起来
int num =10/i;
}catch(ArithmeticExcaption e){
//对相应类型的异常信息进行处理
e.printStackTrace();//打印异常信息
}catch(Exception e){
e.printStackTrace();
}finally{
//最后一定会执行的代码
System.out.println("这个体系中最后执行的代码")；
}
}
4、抛出异常方式
。使用throws关键字在方法声明后抛出异常
。接收到异常的方法要么抛出要么处理
。方法声明上的异常类型必须大于等于程序中出现的异常
类型才能抛出
5、注意事项
。多个catch处理异常时，遵循从上往下的原则，上面如果有
catch可以处理，下面将不再执行，所以我们应当将小的异常
放在上面，大的异常放在下面
。无论什么情况，只要try...catch体系执行了，finally中的代码一定
会执行的，除非虚拟机退出：System.exit(0)
。finally主要是用于释放资源
八、自定义异常（了解）
1.定义：
。在项目中我们有时需要处理一些逻辑的问题，比如说性别不能输入中
性，这些在java中不被认为是异常，但是在实际的业务中却是异常
。自定义异常有时名称的，所以比单纯的状态值更好记忆
。自定义异常类，可以携带更多的信息供我们使用
。抛出遗产的方式不会破坏方法的格式
2、自定义异常
。继承Exception 必须抛出，需要在编译前处理
。继承RuntimeException 不需要抛出，编译前不许要处理
//自定义编译时异常
public class MyException extends Exception{
//定义空参构造
public MyException(){}
//定义有参构造
public MyException(String message){
//将信息传递过父类处理
super(message);
}
}
//自定义运行时异常
public class MyException extends RuntimeException{
//定义空参构造
public MyException(){}
//定义有参构造
public MyException(String message){
//将信息传递过父类处理
super(message);
}
}