1. 内部类类别：
1.1成员内部类：在一个类的成员位置定义另外一个类就称为成员内部类。
1.1.1成员内部类的访问方式：
方式1：在外部类内提供一个方法创建内部类的对象进行访问。
方式2：在其他类创建内部类的对象进行访问。创建的格式：外部类.内部类 变量名=new 外部类()
注意：如果是静态内部类在其他类的创建对象方式：外部类.内部类 变量名=new 外部类.内部类（）；
1.1.2成员内部类要注意的事项：
①成员内部类可以直接访问外部类成员。
②如果成员内部类与外部类存在同名的成员，在内部类中默认访问内部类的成员
成员通过“外部类.this.成员“指定访问外部类的成员。
③如果成员内部类出现了静态的成员，那么该成员内部类也必须使用static修饰。
④如果成员内部类是私有的，那么创建内部类的对象就只能在外部类提供方法创建。
1.2局部内部类：在一个类的方法内部定义另外一个类，另外一个类就称为局部内部类。
局部内部类要注意：如果局部内部类访问了局部变量，那么该变量需要使用fianl修饰。（原因：生命周期不同。）
匿名内部类：没有类名的类。
匿名内部类的好处：简化书写。
匿名内部类的使用前提：必须存在继承或者实现关系。
匿名内部类的格式：
new 父类（父接口）{
匿名内部类的成员；
} ；
2.异常：
2.1异常的体系；
---------------|throwable
-------------------|error（错误）错误一般是由于jvm或者是硬件引发的问题，所以我们一般不会通过代码去处理。
-------------------|exception（异常）异常我们
2.2异常处理方式
2.2.1 方式一：捕获处理
捕获处理的格式
try{
可能发生异常的代码
}catch（捕获的异常类型 变量名）{
处理异常的代码
}
捕获处理要注意的细节：
①如果一个try块中出现了异常的代码，经过出来后，那么try-catch块外面的代码可以正常执行。
②如果一个try块中出现了异常的代码，那么在try块中出现异常的代码后面的语句无法执行
③一个try块后面可以跟多个catch块，也就是一个try块可以捕获多种异常的类型，但是捕获的类型必须从小到大进行捕获。
2.2.2方式二：抛出处理（throw throws）
①．如果一个方法内部抛出了一个编译时异常对象，那么该方法必须要声明抛出。
②．如果调用了一个声明抛出编译时异常的方法，那么调用者必须要处理。
③．如果一个方法抛出了一个异常对象，那么该方法也会马上停止（一个方法遇到了throw关键字，那么该方法就会马上停止）
④在一种情况下只能抛出一种异常对象。
Throw关键字是用于方法体之内抛出异常对象的，throws是用于方法声明抛出异常的。
运行时异常都是可以通过程序员的编译习惯来避免。
二．自定义异常类
1.1来由，sun提供的异常类不够，所以需要自定义异常类。
class NoMoneyException extends Exception{
public NoMoneyException(String message){
super(message);
}
class Demo8{
public static void main(String[] args){
try{
eat(5);
}catch(NoMoneyException e){
System.out.println("跟我洗碗一个月！！！");
}
}
public static void eat(int money)throws NoMoneyException{
if(money<10){
throw new NoMoneyException("吃霸王餐");
}
System.out.println("吃上了香喷喷的地沟油");
}
}
异常体系里面的Exception（异常）异常一般都通过代码处理
分运行时异常：如果一个方法内部抛出了一个运行时异常，那么方法上可以声明也可以不声明，调用者可以处理，也可以不处理。
编译时异常：（非运行时异常、受检异常）：如果方法内部抛出了一个编译时异常对象，那么方法上就必须要声明，而且调用者必须处理
错误符号有RuntimeException以及其子类
三．Finally块
Finally块的使用前提是必须要存在try块才能使用。
Finally块的代码在任何情况下都会执行，除了jvm退出的情况。
Finally非常适合做资源释放的工作，这样才能保证资源在任何情况下都会被被释放
Try块的三种组合方式：
第一种：比较适合有异常要处理，但没有资源要释放。
try{可能发生异常的代码}catch
（捕获的异常类型 变量名}{
处理异常的代码
}
第二种：比较适用于及有异常要处理，又有资源要释放
try{可能发生异常的代码}catch
（捕获的异常类型 变量名}{
处理异常的代码
}finally{
释放资源的代码
}
第三种：比较适用于内部抛出的是运行时异常，并且有资源要被释放。
try{可能发生异常的代码}
}finally{
释放资源的代码；
}
三．导包语句：java中的包相当于windows文件夹
1.包的作用：
①解决类名重复产生冲突的的问题。
②便于软件版本的发布。
2定义包的格式：
package 包名；
包名命名规范：包名全部小写。
3.包语句要注意的事项：
①package语句必须位于Java文件中的第一个语句。
②如果一个类加上了包语句，那么该类的完整类名就是；包名.类名
③一个Java文件只能有一个包语句
javac -d指定类文件的存放路径 java源文件
javac -d . Demo2.java
4.有了包之后类与类之间的访问：
问题：有了包之后类与类之间的访问每次都必须要写上包名！！！烦
解决方案：sum提供导包语句让我们解决该问题。
导包语句的作用：简化书写。（误区：把一个类导入到内存中）
导包语句的格式：
Import 包名.类名；（导入xxx包中的某个类）；
5.导包语句要注意的细节：
①一个java文件中可以出现多句导包语句。
②”*”是导包语句的通配符。可以匹配任何的类名。
③。import aa.*；是不会作用于aa包下面的子包的。
推荐使用：import 包名.类名；因为使用“*”通配符会
6.什么时候使用import语句：
①相互访问的两个类不是在同一个包下面，这时候就需要使用到导包语句。
②java.lang是默认导入的，不需要我们自己导入。
四．访问权限修饰符
1.定义：权限修饰符就是控制 被修饰的成员的范围可见性。
public（公共） protect（受保护的） default （缺省） private（大到小）
同一个类 true true true true
同一个包 true true true false
子父类 true true true false
不同包 true false false false
注意：在不同包下面只有public与protected可以访问，而且protected必须是在继承关系下才能够访问。
五．打jar包 ：需要使用jdk的开发工具（jar.exe）
jar文件的作用：①方便用户快速运行一个项目。
②提供工具类给别人使用。
使用格式：
jar cvf jar文件名 class文件或者文件夹
打jar包要注意的事项：
① 一个程序打完了jar之后必须要在清单文件指定入口类： 格式Main-class：包名.类名
② jar包双击运行仅对于图形化界面的程序起作用，对于控制台的程序不起作用。
如果使用jar包里面的类必须要先设置classpath路径。
Jre=jvm+核心类库
六．模板模式：
定义：解决某类事情的步骤有些是固定的，有些是会发生变化的，那么这时候我们为这类事物提供一个模板代码，从而提高效率。
需求:编写一个计算机程序运行时间的模板。
模板模式的步骤：
① 先写出解决该类事情其中个=的一件的解决方案。
② 分析代码，把会发生变化的代码抽取出来独立成一个方法。把该方法独立描述成一个抽象的方法。
③ 使用final修饰模板方法，防止别人重写你的模板方法。
1. 抽象类
描述一类事物的时候，发现确实存在某种行为，但是目前这种行为不具体，这时候应该抽取这种行为的声明，而不去实现这种行为，这时候这种行为我们成为抽象行为，这时候应该使用抽象类。
要注意的细节：
① 如果一个方法没有方法体，那么该方法必须使用abstract修饰。
② 如果一个类函数有抽象方法，那么这个类肯定是一个抽象类或接口。
③ 抽象类不能创建方法，抽象类是含有构造方法的。
④ 抽象类可以存在非抽象方法与抽象方法。
⑤ 抽象类可以不存在抽象方法。
⑥ 非抽象类继承抽象类的时候，必须要把抽象类中所有抽象方法全部实现。
⑦ abstract不能与以下关键字一起使用，static，private，final
2. 接口
接口的定义格式：
Interface 接口名{
成员变量
成员函数….
}
接口的作用：
① 程序的解耦
② 定义约束的规范
③ 拓展功能
接口要注意的细节
① 接口中的成员变量都是常量，默认的修饰符是public static final。
② 接口中的方法全部都是抽象方法，默认的修饰符：public abstract。
③ 接口不能创建对象。
④ 接口是没有构造函数的。
⑤ 非抽象类通过implements实现接口的时候，必须要把接口中所有方法全部实现。
接口与类之间的关系：实现关系
注意：一个类可以实现多个接口。
接口与接口之间的关系：继承关系
注意：一个接口可以继承多个接口。
3. 多态,父类的引用类型变量指向了子类的对象，或者是接口的引用类型变量指向了接口实现类的对象。
要注意的细节
① 多态情况下，如果子父类存在同名的成员变量时，访问的是父类的成员变量。
② 多态情况下，如果子父类存在同名的非静态函数时，访问的是子类的成员变量。
③ 多态情况下，如果子父类存在同名的静态函数时，访问的是父类的成员变量。
④ 多态情况下，不能访问子类特有的成员。
多态的应用：
① 多态用于形参类型的时候，可以接收更多类型的数据。
② 多态用于返回值类型的时候，可以返回更多类型的数据。
二 强制类型转换：
1.来源：由于目前多态情况下不能访问子类特有的成员。
2.如果需要访问子类特有的成员，那么需要进行类型强制转换。
小数据类型----------->大的数据类型 自动类型转换
大数据类型------------>小的数据类型 强制类型转换 小数据类型
变量名=（小数据类型）大数据类型；
3.引用数据类型的转换
小数据类型----------->大的数据类型 自动类型转换
大数据类型------------>小的数据类型 强制类型转换
类型转换最常见的问题；java.lang.ClassCastException。强制类型转换失败。
If(a instanceof Fish)
接口 变量=new 接口实现类的对象
三 内部类
定义：一个类定义在另一个类的内部，那么该类就称作为内部类。
内部类的class文件名：外部类$内部类。便于区分该class文件是属于哪个外部类的
内部类的类别：
1. 成员内部类：
成员内部类的访问方式：
方式一在外部类提供一个方法创建内部类的对象进行访问。
方式二：在其他类直接创建内部类的对象。格式：外部类。内部类 变量名
=new 外部类().new内部类（）。
注意：如果是一个静态内部类，那么在其他类创建的格式：
外部类.内部类 变量名=new 外部类.内部类（）；
内部类的应用场景：我们在描述A事物的时候，发现描述的A事物内部还存在另外一个比较复杂的事物B的时候，而且这个比较复杂事物B还需要访问A事物的属性等数据，那么这时候我们就可以使用内部描述B事物。
2. 局部内部类
在一个类的方法内部定义另外一个类，那么另外一个类就称作为局部内部类。
注意：
如果局部内部类访问了一个局部变量，那么该局部变量必须使用final修饰。
3. 匿名内部类
① 定义：没有类名的类就称为匿名内部类。
② 好处：简化好写。
③ 使用前提：必须存在继承或者实现关系才能使用。
匿名内部类一般用于实参
四Throwable以及错误
异常：
Throwable分为error和exception，exception又分为运行异常和编译时异常 1..throwable常用的方法
tostring() 返回当前对象的完整类名 +病态信息。
Throwable t=new Throwable();
String info = t.tostring();
System.out.println(“tostring:”+info);//java.lang.Throwable 包类+类名=完整类名
getMessage() 返回的是创建Throwable传入的字符串信息。
Throwable t=new Throwable(“头晕，感冒….”);
String message = t.getMessage ();
System.out.println(“tostring:”+info);//java.lang.Throwable
System.out.println(“getMessage:”+message);
printstackTrace() ：打印异常的栈信息。
1.1error：错误一般是用于jvm或者是硬件引发的问题
1.2Exception异常 是需要代码去处理
如何区分error与Exception
如果程序出现不正常的信息，如果不正常的信息以error肯定是一个错误，
如果是以Exception结尾，那么肯定就是一个异常。
1.3异常的处理：
方式一：捕获处理。
捕获处理的格式：
try{
可能发生异常的代码;
}catch（捕获的异常类型 变量名）
{处理异常的代码
}
1.3.1捕获处理要注意的细节：
① 如果try-catch块外面的代码可以正常执行。
② 如果try块中出了异常代码，那么在try块中出现异常代码后面的代码是不会执行的。
③ 一个try块后面可以跟多个catc模块的。
1.4方式二：抛出处理。
① 如果一个方法的内部抛出了一个异常对象，那么必须在方法上声明抛出。
② 如果调用了一个声明抛出异常的方法，那么调用者必须处理异常。
③ 如果一个方法内部抛出了一个异常对象，那么throw语句后面的代码都不会再执行了
④ 在一种情况下，只能抛出一种类型异常对象。
1.4.1 throw与throws两个关键字：
② throw关键字是用于方法内部的，throws是用于方法声明上的。
②throw 是用于方法内部抛出一个异常对象的，throws关键字是用于在方法声明上声明抛出异常类型的。
③ Throws关键字后面只能有一个异常对象，throws’后面一次可以声明抛出多种类型的异常
