黑马程序员___Java基础[05-内部类和异常]

一、内部类

1、内部类：被定义到另一个类里面的类，又称内置类或嵌套类。

2、什么时候使用内部类？

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事务在使用外部事物的内容。

3、内部类的访问规则：

1）内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

2）外部类要访问内部类，必须建立内部类对象。

访问格式：

A：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

     可以直接建立内部类对象。

     格式：

外部类名.内部类名  变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

B：当内部类在成员位置上，就可以被成员修饰符所修饰。

比如：

private：将内部类在外部类中进行封装。

static:内部类就具备static的特性。

• 当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

• 在外部其他类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

• 在外部其他类中，如何直接访问static内部类的静态成员呢？

Outer.Inner.function();

注意：

当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

4、内部类间的区别：

内部类分别有：1）非静态成员内部类　　2）静态成员内部类　　3）局部内部类　　4）匿名内部类

1）成员内部类

A：定义：在一个外部类中有成员变量和成员方法，那么成员内部类就是把整个一个类当成了外部类的成员对待了。

B：访问方式:

内部类访问外部类，内部类可以直接访问外部类，包括私有成员，因为内部类持有外部类的引用——外部类名.this

外部类访问内部类，外部其他类访问内部类的成员，必须要建立内部类的对象

格式：外部类名.内部类名 = 外部类对象.内部类对象;

Outer.Inner oi = new Outer().new Inner();//outer代表外部类,Inner代表内部类

C：定义位置:在外部类里,在外部类的成员方法以外.

D：修饰符:final、abstract、public、private、protected和static等，那么被static修饰的就是下面所说的静态内部类。

2）静态内部类

A：定义，就是在成员内部类的基础上加上static

B：格式:外部类名.内部类名 = 外部类名.内部类对象;

Outer.Inner oi = new Outer.Inner();

C：定义位置:和成员内部类一样，就是多了个static修饰

3）局部内部类

A：定义,在外部类成员方法中定义的内部类,他更像局部变量（局部内部类不能再被成员修饰符修饰，局部内部类中也不能有静态成员）。

B: 注意：

第一：方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

第二：方法内部类对象不能使用该内部类所在方法的非final局部变量。

因为方法的局部变量位于栈上，只存在于该方法的生命期内。

当一个方法结束，其栈结构被删除，局部变量成为历史。

但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！

例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。

正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。

第三：方法内部类的修饰符。与成员内部类不同，方法内部类更像一个局部变量。可以用于修饰方法内部类的只有final和abstract。

第四：静态方法内的方法内部类。静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员。

4）匿名内部类：没有名字的内部类。它是内部类的简化写法。

A：前提：内部类可以继承或实现一个外部类或者接口。

B：格式为：new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

C：简单理解：就是建立一个带内容的外部类或者接口的子类的匿名对象。

D：匿名内部类的种类

a、继承式的匿名内部类

b、接口式(也可以叫实现式)的匿名内部类

c、参数式的匿名内部类

多加一句:我的理解,其实与其说是匿名内部类,我个人认为说是匿名内部类对象更确切一点。

代码：有名字的内部类和匿名内部类示例

interface Inter {
    public abstract void show1();
    public abstract void show2();
}
            
//有名字的内部类
class Outer {
    public void method(){
        class Inner implements Inter {
            public void show1(){
                System.out.println("show1");
            }
            public void show2(){
                System.out.println("show1");
            }
        }
    }
    public void show() {
        Inter in = new Inner();//父类引用指向子类对象
        in.show1();
        in.show2();
    }
}

//匿名内部类(重点,android里面用的多,awt的监听器用的多)
class Outer {
    public void method() {
        //匿名内部类对象调用方法
        new Inter() {
            public void show1() {
                System.out.println("show1");
            }
            
            public void show2() {
                System.out.println("show1");
            }
        }.show1();

        new Inter() {
            public void show1() {
                System.out.println("show1");
            }

            public void show2(){
                System.out.println("show1");
            }
        }.show2();

        //匿名内部类对象的另一种调用方式,父类引用指向子类对象
        Inter in = new Inter() {
            public void show1() {
                System.out.println("show1");
            }

            public void show2() {
                System.out.println("show1");
            }
        };
        in.show1();
        in.show2();
    }
}

5）什么时候使用匿名内部类呢？

A：通常在使用方法是接口类型参数，并该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。

二、异常

1、异常

1）编程错误：

错误分为三类：语法错误、运行错误、逻辑错误。

• 语法错误：

定义：在编译过程中出现的错误，也叫编译错误。

原因：没有遵循语言的规则。

特点：容易发现并纠正，因为编译器会指出出错的位置和原因。

解决方法：从编译器错误报告中的第一个错误开始调试，在程序中从上向下调试（排除了前面的，可能就改掉了后面的）。

• 运行错误：

定义：在程序运行过程中出现的错误。

原因：当环境检测到一个不可能执行的操作时就会出现运行错误。

特点：会引起程序非正常中断，也不难找，因为Java解释器在程序异常终止时会将其显示出来。

解决方法：由异常处理来解决。

• 逻辑错误：

定义：如果程序没有按照预期的方案执行就会发生逻辑错误，也称为"bug"。

原因：逻辑发生错误或不够严谨。

特点：程序的执行结果不是我们想要的结果。

解决方法：通过手工跟踪、插入输出语句、使用调试工具等调试技巧查找定位，并纠正。

2）异常的由来：

A：就是程序在运行时出现不正常的情况，叫做异常。

B：由来：异常就是程序运行时出现的问题，而问题也是日常生活中的一个具体事物，java对这种事物以类的形式进行了描述并封装成对象。这也是java中"万物皆对象"的体现。

2、异常体系

1）异常体系由来：

问题(严重的 Error 和非严重的 Exception)有一些共性内容，如不正常情况的信息，引发原因等，这些共性内容向上抽取形成一个基本体系，抽取出来的父类就叫做 Throwable

2）异常的体系

Throwable 其实应该分两种：

Error

通常出现重大问题如：运行的类不存在或者内存溢出等。

不编写针对代码对其处理。

Exception 

A：除了 RuntimeException 和其所有子类,其他所有的异常类都是在编译的时候必须要处理的。

要么try,要么抛

B：RuntimeException

RuntimeException 和其所有的子类，都不会在编译的时候报异常，而是在运行时报异常，

这时候我们就需要回头看看我们的代码是否有问题，比如角标越界，空指针等。

3）Throwable Runnable

A：getMessage() ：返回此 throwable 的详细消息字符串。

class Throwable {

String detailMessage;

Throwable(){}

Throwable(String message) {

this.detailMessage = message;

}

public String getMessage() {

return detailMessage;

}

}

B：toString()：获取异常类名和异常信息，返回字符串。

C：printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。

jvm默认异常处理机制就是调用此方法。

3、异常的处理方式：

A：try...catch...finally

格式：

try {

需要检测的代码；

}

catch(异常类  变量) {

处理异常的代码；(处理方式)

}

...

finally {

一定会执行的代码；

}

可以有下面三种搭配形式：

a、try...catch(...)

b、try...finally

c、try...catch(...)...finally

B：抛出 throws throw

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

throw:用于抛出异常对象。throw用在函数内，后面跟异常对象。new Exception();throw后面的语句执行不到，作用同return

C：到底用谁？

a、你能处理，建议处理。try...catch...finally

b、你处理不了，抛出。

c、在实际开发中，是分层开发，底层代码是能抛出尽量抛出，到顶层那是会把一些不友好的异常转换成友好的异常

用日志记录住异常信息，并提供解决方案。

D：自定义异常

自定义类继承Exception或者其子类(RuntimeException)

class MyException extends Exception{
    MyException(){}
    
    MyException(String message){
        super(message); //将信息传递给父类,调用父类封装好的构造方法
    }
}

class Student {
    public void giveAge(int age) throws MyException {
        if(age>40 || age<16) {
            //throw new MyExcetpion("建议不学了");
            MyExcepiont my = new MyExcetpion("建议不学了");
            throw my;
        }else {
            System.out.println("可以学习Java");
        }
    }
}

E：RuntimeException和Exception

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