内部类、匿名类、异常类

一、内部类

1.定义：内部类就是定义在一个类里面的类

public class People{
//内部类
    public class heart{
    }
}

2.内部类的分类
2.1静态内部类

• 有static修饰，属于外部类本身
• 它的特点与使用普通类是完全一样的，类有的成分它都有，只是位置在别人里面

public class Outer{
//静态成员内部类
public static class Inner{
    }
}

• 静态内部类创建对象的格式

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

• 访问特点

1.内部类可以直接访问外部类的静态成员
2.静态内部类不可以直接访问外部类的实例成员

/**
 * 外部类
 */
public  class Outer {
    /**
     * 学习静态成员内部类
     */
    public static int a=100;
    private String hobby;
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName;
        Inner(){

        }
        Inner(String name,int age){
            this.name=name;
            this.age=age;
        }
        public void show(){
            System.out.println("名称"+name);
            System.out.println(Outer.a);//内部类可以直接访问外部类的静态成员
           // System.out.println(hobby);//静态内部类不可以直接访问外部类的成员
            Outer o=new Outer();
            System.out.println(o.hobby);
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public static String getSchoolName() {
            return schoolName;
        }
        public static void setSchoolName(String schoolName) {
            Inner.schoolName = schoolName;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner in=new Outer.Inner();
        in.setName("张三");
        in.show();
    }
}

2.2成员内部类

• 无static修饰，属于外部类的对象
• JDK16之前，成员内部类不能定义静态成员，JDK16开始可以定义静态成员了

public class Outer{
//成员内部类
   public class Inner{
   }

}

• 成员内部类创建对象的格式

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

• 访问特点：
  成员内部类可以直接访问外部类的静态成员
  成员内部类的实例方法可以直接访问外部类的实例成员

/**
 * 外部类
 */
public class Outer {
    public static int number=111;
    private String hobby;


    /**
     * 成员内部类
     */
    public class Inner{
        private String name;
        private int age;
        public static int a=100;//从JDK16开始允许定义静态成员

        public void show(){
            System.out.println("名称"+name);
            System.out.println(number);// 成员内部类可以直接访问外部类的静态成员
            System.out.println(hobby);//成员内部类的实例方法可以直接访问外部类的实例成员

        }
        public static void test(){
            System.out.println(a);
        }
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner in=new Outer().new Inner();
        in.setName("张三");
        in.show();
        Outer.Inner.test();//访问内部类的静态成员
    }
}

2.3局部内部类(了解)

• 局部内部类放在方法、代码块、构造器等执行体中
• 局部内部类的类文件名为：外部类$N内部类.class

2.4匿名内部类（重点）

• 本质是一个没有名字的局部内部类，定义在方法中，代码块中等
• 作用：方便创建子类对象，最终目的为了简化代码编写
• 格式：

Employee a=new Employee(){
public void work(){
    }
};
a.work();

• 特点

1.匿名内部类是一个没有名字的内部类
2.匿名内部类写出来就会产生一个匿名内部类的对象
3.匿名内部类的对象类型相当于是当前new的那个类型的子类型

public class Test {
    public static void main(String[] args) {
        Animal a=new Animal(){
            @Override
            public void run(){
                System.out.println("老虎跑得快");
            }
        };
        a.run();
    }
}
abstract class Animal{
    public abstract void run();
}
//class Tiger extends Animal{
//    public void run(){
//        System.out.println("老虎跑得快");
//    }
//}

• 匿名内部类常见的使用形式

/**
 * 目标：掌握匿名内部类的使用形式（语法）
 */
public class Test2 {
    public static void main(String[] args) {
        Swimming s=new Swimming(){
            public void swim(){
                System.out.println("学生爱游泳");
            }
        };
        go(s);
        go(new Swimming(){
            public void swim(){
                System.out.println("老师爱游泳");
            }
        });
    }
    /**
     * 学生、老师、运动员一起参加由于比赛
     */
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
}

interface Swimming{
    void swim();
}

3.异常类

public class Test {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //假设捕获多个异常：从小到大去捕获
        try{//try监控区域，可能出现异常的语句
            System.out.println(a/b);
        }catch(Exception e){//catch(想要捕获的异常类型)//捕获异常
            System.out.println("Error");
        }finally{
            System.out.println("finally");
        }
        //1.程序中可以没有finally但一定要有try-catch
        //2.程序中可以有多个catch，但只能有一个try和一个finally
    }

}

public class Test2 {
    public static void main(String[] args) {
        int a=1;
        int b=0;
        //按住输出语句，在按快捷键ctrl+alt+t可生成try-catch-finally语句
        try {
            new Test2().test(1,0);
        } catch (ArithmeticException e) {

        }
    }
    //假设这个方法处理不了异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();//主动抛出异常，一般用在方法中使用
        }
    }
}