java基础第10天

（掌握）
1内部类（概况）：


成员内部类：类的成员之一
　　嵌套类：静态成员内部类
　　
局部内部类：（不常用）把一个类定义在局部。局部：方法内部（构造器内部）
　　局部匿名内部类：（常用）定义在赋值语句中，方法调用语句中，return语句中。
　　
2局部匿名内部类：没有名字的内部类。它是内部类的简化写法。
A：前提：内部类可以继承或实现一个外部类或者接口。
B：格式为：new 类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
C：简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。
局部匿名内部类代码举例（掌握）




（理解）
1：内部类
(1)将类A定义在另一个类B中。则类A就是内部类。
A：什么时候使用内部类：有Outer和Inner两个类，当Inner想要直接访问Outer                    中的成员，而Outer需要建立Inner对象来访问Inner中的成员。这个时候，我们就可以把Inner定义为Outer的内部类。
class Body
{
private class Heart()
{
//调用身体的其他部分
}
}
(2)访问方式：
A：内部类可以直接访问外部类中的成员，包括私有成员。
B：而外部类要访问内部类中的成员必须要建立内部类的对象。
(3)内部的存放位置
A：成员位置
**成员内部类，可以使用所有修饰符 private、protected、默认、public,static等成员修饰符修饰。一般内部类都是私有的。
    （普通类，只能使用默认与public来修饰。）　　
      成员内部类它不能有static相关的所有东西！（其中常量可以！）
　　 **被static修饰的内部类叫嵌套类。嵌套类只能访问外部类中的静态成员。嵌套类一般是pulbic，但在Java源码中，存在很多private的嵌套类。（包括private的静态属性和静态方法）
                  1,接口中可以定义嵌套类
　　                    接口中可以定义嵌套类，我们说的类，也包含接口。
　　                    其实在Java源代码中，有很多接口内部定义了接口。
　　                    接口中定义的类（或接口）默认的修饰是：public static
　　                                  public interface A {
　　                                            interface B {}
　　                                          }
                   2,private修饰的属性，普通类不能调用，此时用嵌套类调用，非静态直接使用，使用静态的需要new一个对象。如图：Test.java


public class Test {
     Private int i;
public static void main(String[] args) {

}
}


class Outer {
public static class Inner {
public void fun() {
Test t = new Test();
t.i = 100;
}
}
}


                       3.嵌套类外界调用内部类。
public class Test {
public static void main(String[] args) {
Outer.Inner  inner =  new  Outer.Inner();
}
}


class Outer {
public static class Inner {
public static int i;


public static void fun1() {}


public void fun() {
Test t = new Test();
t.i = 100;
}
}
}


B：局部位置
同时可以访问所在局部中的局部变量，以及形参！但必须是被final修饰的。                   1局部内部类与局部变量相似，不能使用访问修饰，也不能使用静态修饰2局部内部类不能拥有静态的属性和方法
//形参但必须是被final修饰的举例：
class  Test
{
public static void main(String[] args) 
{
Outer o = new Outer(100);
}
}
class Outer {
public Outer(final int a) {
// 可见性，只在局部可见
// 可以直接访问外部的成员，包含私有成员
// 可以访问局部的final变量。
class Inner1 {
public void innerFun() {
System.out.println("局部变量：" + a);
}

}
Inner1 inner = new Inner1();
   inner.innerFun();
}
}


　　Outer$Inner.class:$表示成员内部类。
Outer$1Inner.class:$1表示它是一个局部内部类。
**编号：如果存在多个内部类同名时（不在同一方法中），这时使用编号来区分。


(4)匿名内部类：没有名字的内部类。它是内部类的简化写法。
A：前提：内部类可以继承或实现一个外部类或者接口。
B：格式为：new 类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
C：简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。


(5)什么时候使用匿名内部类呢？
A：通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，
  可以将匿名内部类作为参数传递。增强阅读性。
匿名内部类的语法
三种形式：
　　匿名类是定义在赋值语句中。
　　匿名类是定义在方法调用语句中。
　　匿名类是定义在return语句中。
　　
　　A a = new A();//创建了一个A类的对象
　　A a = new A() {};//创建了一个A类子类的对象或一个接口，这个子类没名字或一个A 接口实现类的对象，这个实现类没名字！大括号后面为什么加分号， 因为这是个赋值语句。
　　1匿名类必须且仅能有一个父类或实现一个接口。
　　
　　2匿名类不能写构造器，因为构造器的名字必须与类名相同，匿名类没有名字，所以不  能写构造器。但是我们知道有个东西叫构造代码块，它可以用来代替构造器。
　　A a = new A() {
　　  private int a = 10;
　　  public void fun() {
　　　}
　　　private void fun1() {}
　　};//大括号内是类体


　　
　　
　　因为匿名类必须向上转型，那么它自己独有的方法就不能被调用了。所以匿名类内的方法都是在重写  父类或接口中的方法，当然如果写一些非“重写”的方法，那么这些方法其实就是为“重写”方法服务的。也就可以定义为private，因为外界想使用也使用不了。
三种形式测试：
//匿名类是定义在赋值语句中。


import java.util.Comparator;


public class Test {
public static void main(String[] args) {


       Comparator c = new Comparator(){
public int compare(Object o1, Object o2) {
return 0;
}
};
     fun(c);
}
public static void fun(Comparator c) {
}


}


//匿名类是定义在方法调用语句中。


public class Test {
public static void main(String[] args) {


        
     Fun(new Comparator(){
public int compare(Object o1, Object o2) {
return 0;
}
};


public static void fun(Comparator c) {
}


}


//匿名类是定义在return语句中。(见方式二)


import java.util.Comparator;


public class Test {
public static void main(String[] args) {


}
public static void fun(Comparator c) {
      /*  方式一
Comparator c = new Comparator(){
public int compare(Object o1, Object o2) {
return 0;
}
};
     
        Return c;
*/
//方式二
          return new Comparator(){
public int compare(Object o1, Object o2) {
return 0;
}


}


























































2：异常


理解：编译错误  异常（受检异常，不受检查异常）


编译错误就是编译时有错误
运行时有错误就是异常。
受检查、不受检查只是指异常说的,受检查、不受检查与编译错误没有关系
编译器就是javac.exe，javac的工作就是把.java变成.class
编译错误就说明通不过javac的
，异常是生成.class后出现的
异常是方法返回的另一个途径




我们要分开讨论


你刚刚问的是编译错误和异常，我回答的是编译错误是在编译时产生、异常是在运行时产生。  
无论是受检查，还是不受检查，都是异常，都是运行时才会产生的。


在你写方法时，可能需要给方法声明异常，因为你的方法在运行时可能会出现异常。如果你的方法可能出现异常，而你没有声明，那么编译不通过。


但如果你的方法中可能出现的异常是不受检查的，那么就算不声明编译器也不会报错。


不受查检的异常编译器不管，但受查检的受编译器管


什么叫受检查？
所谓检查，是在编译时检查你的代码是否可以编译通过。
这是编译器对代码的检查。
在你写方法时，可能需要给方法声明异常，因为你的方法在运行时可能会出现异常。如果你的方法可能出现异常，而你没有声明，那么编译不通过。
但如果你的方法中可能出现的异常是不受检查的，那么就算不声明编译器也不会报错。
如果编译报错了，那当然不能生成.class了。


小结：
编译错误：语法已经错误  编译通不过的，不能生成.class
受检异常：语法是正确的，但你的语句存在一些安全隐患，如逻辑等问题，java语言是安全 语言，遇到安全问题就会提醒你，你要是不处理它不会让你编译通过
            不会生成.class，处理或声明，才会把这个安全提醒清除掉的，会生成.class（处理异常处理方式两种：声明，try、catch）


不受检查异常：不小心编码造成的；（RuntimeException及其他子类）（处理异常处理方式三 种：声明，try、catch,什么都不处理）


(1)就是程序运行过程中，遇到了问题，这就叫异常。
(2)异常的体系
Throwable
**Error(大错！)
***通常出现重大问题如：运行的类不存在或者内存溢出等。
   不编写针对代码对其处理。JVM内部出了问题！
**Exception (小错)
***在运行时运行出现的一些情况，可以通过try catch finally

举例：1：旅游，自行车爆胎，是因为你选择不好的路造成的，这个就叫异常。
如果山路给塌方了，这个问题你解决不了，那么，就是Error。
     2：感冒是可以治的好的，所以，感冒是异常。
2003 非典。一般不好治，那么这就是错误。
(3)Throwable
A：getMessage() ：返回此 throwable 的详细消息字符串。

B：toString()：获取异常类名和异常信息，返回字符串。
C：printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
异常涉及的关键字
　　throw（抛出）、throws（声明）、try（监控）、catch（抓捕）、finally（总是执行）


(4)处理异常处理方式：
A：try...catch...finally
格式：
try
{
需要检测的代码；
}
catch(异常类  变量)
{
异常处理代码；
}
...
finally
{
一定会执行的代码；//释放资源
}
变形：
**try...catch(...)
**try...finally
**try...catch(...)...finally


B：抛出 throws throw
throws:用于标识函数暴露出的异常。thorws用在函数上，后面跟异常类名(可以由多个，用,隔开)。


throw:用于抛出异常对象。throw用在函数内，后面跟异常对象。


C：到底用谁？
**你能处理，建议处理。try...catch...finally
**你处理不了，抛出。


D：自定义异常
自定义类继承Exception或者其子类(RuntimeException)



E：RuntimeException和Exception
区别：RuntimeException就是要你改代码的。你可以不处理。


声明异常


1　声明异常的语法
　　public void fun() throws 异常类名1, 异常类名2, …, 异常类名n {
　　}
　　
　　public String fun() throws RuntimeException {
　　}
　　 fun()方法在正常途径时，返回一个字符串；
　　fun()方法在异常途径时，返回一个RuntimeException对象
2　声明异常的方法说明什么
　　声明异常的方法说明这样的方法在不正常时会返回一个异常类的对象。


3　main也可以声明异常
　　可以！
　　因为这个方法是我定义的，我喜欢怎么定义就怎么定义！


抛出异常
在你认为应该抛时，来抛异常，这是你来定义的
1　使用throw语句抛出异常
　　public void setAge(int age) {
　　   if(age < 0) {
　　      RuntimeException e = new RuntimeException();
　　      throw e;//Throwable或其子类，与return一样，会使方法返回，不过就是返回一个异常而已。程序流程返回到调用处。谁调用了setAge()方法，就返回到谁那里。
　　　　}
　　   this.age = age;
　　}


2　执行了整数除以0的语句
　　public void fun() {
　　   int n = 10;
　　   n = n / 0;
　　}
算数异常
3　调用了声明异常的方法有可能抛出异常
　　调用一个声明异常的方法，只是有可能抛出异常，并不是一定抛出异常。


4　当方法抛出异常后
　　当方法真的抛出异常后，而且异常没有被捕获到，那么异常就抛出了。这个方法就返回了！但返回给调用者一个异常对象。




　　


处理异常


1　包含危险语句
整数除以0：必出异常
调用声明异常的方法：可能出现异常
throw语句：必出异常


2　声明异常
　　如果你的方法内存在危险语句，那么只能两条路可走。
声明异常：我们方法也声明异常，告诉调用者，我们这个方法也有危险！
处理异常：在方法内部把异常处理掉，外界不知道内部的问题，也不会让调用者出现异常。


3　捕获处理异常
　　try/catch
　　try {
　　　1
　　　2 – 出了异常，try下面的语句就不执行了。
　　　3
　　} catch(小偷异常 e) {
　　  处理异常
　　} catch(杀人异常 e) {
　　  
　　}
　　从catch出来，在从这里向下运行，异常已经没了。


抓捕异常


1　抓捕异常的格式
　　try…catch…finally
　　try {
　　} catch() {}
　　
　　try{
　　} finally {}
　　
　　try {
　　} catch() {
　　} finally() {}


2　try…catch格式的执行流程
　　 try块是监控区，在try中出现的异常会被捕获，然后送到catch之后，与catch所处理的异常类型进行比较，如果匹配，那么就把异常对象交给catch了，然后调用catch块。
　　注意，在try块中，出现了异常后，在出现异常的位置直接跳转到catch中，而try后面的语句就不会在执行了。


3　try…多catch格式及限制
　　如果多个catch处理的异常类型存在继承关系，那么Java要求子类在上，而父类在下。


4　try…catch…finally格式执行流程
　　如果try中没有抛出异常，那么不会执行catch，但无论有无异常都会执行finally
　　如果try有异常，那么会执行catch，但有异常，也会执行finally
　　如果在finally之前有返回语句（return和抛出异常语句），那么会在返回之前先执行finally，然后再继续返回。


5　finally中放什么样的代码
　　通常我们会用来断开外部资源绑定。
　　例如我们的程序绑定了一个磁盘上的文件，如果在方法返回之前，可以断开，那么就应该把断开的语句放到finally中，这样可以保证断开的语句总是执行。


6　当finally遇见System.exit(0)时
　　finally遇见了System.exit(0)时，就不会再执行了。原因是System.exit(0)会把JVM停止了。




异常类方法介绍


1　Throwable介绍
String getMessage()：获取异常的消息文本
String toString()：把异常转换成一个字符串返回
void printStackTrace()：向控制台打印异常调用栈信息


2　Exception介绍
Exception()：无参构造器
Exception(String msg)：带有消息文本的构造器
Exception(Throwable cause)：带有起因的构造器
Exception(String msg, Throwable cause)：有消息文本，也有起因的构造器。








受查检与不受检查


1　什么是受检查的，什么又是不受检查的
　　编译器只对受检查异常关心，不受检查的异常编译器不管。
　　当调用了一个声明异常的方法时，我们有两条路可选：
我们的方法也声明异常，告诉调用者我们的方法也有危险；
我们使用try/catch把异常给处理了，这样异常就不会再出现了。
如果我们调用的方法声明的不是受检查的异常，可以当没看见！


2　不用处理不受检查的异常
　　受检查异常必须处理：要么声明、要么抓捕。
　　不受检查异常可以什么都不做，也可以声明，也可以抓捕。


3　catch抓捕受检查异常
　　try中必须要存在这种可能！


常见异常
1　 OutOfMemoryError（内存溢出错误）
2　 StackOverflowError（调用栈溢出错误）
3　 NoSuchMethodError（没有这个方法错误）
4　 NoClassDefFoundError（没有找到类错误）
5　 ArithmeticException（算法异常）
6　 ArrayIndexOutOfBoundsException（数组下标越界异常）
7　ClassCastException（强制转换异常）
　　当试图将对象强制转换为不是实例的子类时，抛出该异常。
8　IllegalArgumentException (非法数据异常)
　　抛出的异常表明向方法传递了一个不合法或不正确的参数。
9　NullPointerException（空指针异常）
当应用程序试图在需要对象的地方使用 null 时，抛出该异常。