内部类：
其实就是在类中在定义类。
特点：内部类可以直接访问外部类中的成员。是因为内部类都持有一个外部类的引用。 外部类名.this
外部了要访问内部类必须要建立内部类的对象。
什么定义内部类呢？
当分析事物时，事物的内部还有具体的事物，将这个具体的事物用内部类进行描述。
只要一个类需要直接访问另一个类中的成员。那么就将该类定义成内部类。
定义到内部可以进行封装，通过外部类对外提供公有方法来获取内部类的对象。
interface Inter
{
public void show();
}
class Outer
{
private int num;
private class Inner implements Inter
{
public void show()
{
System.out.println(Outer.this.num);
}
}
public Inter getInstance()
{
return new Inner();
}
}
class Main
{
public static void main(String[] args)
{
Outer out = new Outer();
// Outer.Inner in = out.new Inner();
// in.show();
Inter in = out.getInstance();
in.show();
}
}
作为了解：
内部类定义在外部类的成员位置上。可以使用一些成员修饰符所修饰。
public private static
一般内部都会被隐藏，所以都有private修饰。
如果内部类中定义了静态成员，那么内部类必须是静态的。
静态内部类只能访问外部类中的静态成员。
注意：静态内部类是不会持有外部的this引用的。持有的是外部类名。
class Outer
{
static int num = 9;
static class Inner
{
void show()
{
System.out.println(Outer.num);
}
static void show2(){}
}
}
1,静态内部类的非静态成员show方法的访问。
Outer.Inner in = new Outer.Inner();
in.show();
2,静态内部类的静态成员访问。
Outer.Inner.show2();
定义内部类定义在局部位置上时：
内部类只能访问局部中被final修饰的局部变量。
----------------------------------------------
匿名内部类。
特点：
1，其实就是内部类的简写格式。
2，它就是一个匿名子类对象。这个对象有点胖。
前提：
内部类必须继承或者实现一个外部类或者接口。
建议这个接口中的方法不超过3个。
格式：
new 父类名or接口名(){}
interface Inter
{
void show();
}
class Outer
{
/*
class Inner implements Inter
{
public void show(){}
}
*/
public void method()
{
//new Inner().show();
new Inter()
{
public void show(){}
}.show();
}
}
-------------------------------
异常：
在程序运行时期，发生一些不正常情况。
异常的由来：
其实就是java按照面向对象的思想将问题进行描述，并封装成了对象。
不正常情况有两种：
1，严重情况：Error。
2，非严重情况：Exception
这些情况的发生，都有自己的名字，以及一些详细的信息。
这些共性内容进行抽取，就出现了异常体系。
Throwable : 异常体系的特点在于该体系中所有类都具备可抛性，可以被throw 和 throws关键字操作。
|--Error
属于程序中的严重性问题，一般是由jvm抛出的。比如 NoClassDefFoundError,OutOfMemoryError
出现Error一般我们不编写针对性的代码进行处理。因为程序已经没有办法在继续执行。
需要对程序进行修正。
|--Exception
属于程序的可以处理的问题，是可以编写针对性的代码进行处理的。
该异常属于编译被检测的异常。也就是说函数内如果抛出了该异常，
该异常没有try或者抛的处理，编译会失败。
|--RuntimeException
属于运行时异常，在编译时期是不会检测的。如果函数内抛出该异常，可以不用try和throws。
也就是可以不需要调用者进行处理，它的出现需要让程序停止，对代码进行修正。
ArrayIndexOutOfBoundsException NullPointerException
这个体系中的具体问题(子类)在定义名称时，都是父类名字作为后缀。
Throwable中定义了一些操作错误和异常的共性方法：
1，String getMessage():获取异常的信息。
2，String toString():覆盖了Object类中的toString方法，建立了异常对象自己特有的字符串表现形式。
返回的是异常的名字和异常的信息。
3，void printStackTrace():打印异常的在内存中的信息。包括，异常类名，异常信息，异常出现在代码中的位置。
自定义异常：
在自定义项目中出现的问题，java并没有进行描述，需要自己对问题描述。
将问题描述封装对象，这就是自定义异常。
如何定义呢？
其实很简单，一样是描述事物。
只要让该类继承异常体系即可。这样该了就具备了可抛性。
class MyException extends Exception/*RuntimeException*/
{
MyException()
{
super();
}
MyException(String message)
{
super(message);
}
}
class Demo
{
void show()throws MyException
{
throw new MyException();
}
}
throws和throw的区别：
throws后面抛出的是异常类，可以有多个，用逗号隔开。
throw后面抛出的是异常对象。
注意：throw语句单独存在时，在其下面不可以有任何语句，因为执行不到。
因为return用于结束函数，throw也可以用于结束函数。
public int div(int a,int b)
{
if(b<0)
throw new RuntimeException("除数为负数，不可以运算。");
return a/b;
}
int[] arr = new int[3];
int index = 5;
getElement(arr,index);
public int getElement(int[] arr,int index)
{
if(arr==null)
throw new NullPointerException("数组实体不存在，操作什么东西");
if(index<0 || index>=arr.length)
throw new RuntimeException("index的接收的值是错误的，值是："+index);
return arr[index];
}
异常处理的原则：
1，异常可以throws，可以try.
如果功能内部发生的异常无法自身进行处理，就throws出去。
如果可以自身处理，就try。
2，定义功能时，如果发现该功能会出现问题，而且不止一个。
就将可能发生的问题都用throws标识在函数。标识最具体的问题。
调用者处理时，有几个异常，就对应几个catch代码块，对异常进行针对性处理。
3，异常的封装。将本层出现的特有问题进行try处理，然后抛出，其他层可以识别的并处理的异常。
//操作数据库的添加数据方法。
class NoDataException extends Exception
{
}
public void add()throws NoDataException
{
try
{
操作数据库的动作。
throw new SQLException();
}
catch (SQLException e)
{
处理数据库异常。
//throw new RuntimeException("数据添加失败");
throw new NoDataException("没有数据");
}
}
4，当子类覆盖父类方法时，如果父类的方法抛出了异常。
子类只能抛出父类异常的子类或者子集。
简单说，子类怎么抛都行，就是不能抛出父类超出父类范围的异常。
如果父类或者接口被覆盖的方法没有抛出异常，
那么子类在覆盖时，方法中出现异常，就只能try，不能throws。
异常的正对性处理语句：
try
{
需要被检测的代码。
}
catch (异常类 变量)
{
异常的处理代码。
}
finally
{
一定会被执行的代码。
一般定义的就是关闭资源的代码。
特点：只有当执行到System.exit(0);finally代码块不会执行。
}
语法结构：
1,try和catch结合使用。可以和多个catch结合。
try
{
}
catch ()
{
}
2,try和finally结合使用。
这种组合主要用关闭资源。但是对于出现的异常，并没有catch处理，需要抛出。
异常的基本思想：
问题尽量避免发生，如果避免不了，就需要预先给出处理方式。要么catch，要么throws