Java—匿名内部类、内部类

1.匿名内部类

1.1基于抽象类的匿名内部类

Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化。

主要是用于在我们需要的时候创建一个对象来执行特定的任务，可以使代码更加简洁。

匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。

匿名类语法格式：

new <类或接口>() {
    // 类的主体
};

下面这个是通过匿名出来的对象并在括号里重写抽象方法，来调用抽象类中抽象方法。

    abstract class Rabbit{
        public abstract void eat();
    }
    //一般来说，新建一个类去继承抽象类。
    // 然后实例化继承抽象类的类
public class Demo1 {
    public static void main(String[] args) {
        //匿名内部类：在实例化对抽象类的同时并重写抽象方法
        Rabbit animal = new Rabbit() {
            @Override
            public void eat() {
                System.out.println("兔子吃胡萝卜");
            }
        };
        animal.eat();
    }
}

上面代码我们创建了一个抽象类，并在测试类里通过匿名内部类来重写抽象类的方法，最后通过对象来调用。 

还可以通过没有名字的内部类来直接调用抽象中的方法

   abstract class Rabbit{
        public abstract void eat();
    }
    //一般来说，新建一个类去继承抽象类。
    // 然后实例化继承抽象类的类
public class Demo1 {
    public static void main(String[] args) {
        //匿名内部类：在实例化对抽象类的同时并重写抽象方法
        new Rabbit() {
            @Override
            public void eat() {
                System.out.println("兔子吃胡萝卜");
            }
            //直接用大括号.方法
        }.eat();
    }
}

1.2基于接口的匿名内部类

案列1：

    interface Computer{
        void test();
    }
public class Demo2 {
    public static void main(String[] args) {
        new Computer(){
            @Override
            public void test() {
                System.out.println("电脑性能检测");
            }
        }.test();
    }
}

 案列二：TreeSet集合里存对象，并且在TreeSet有参构造里声明了new Comparator()

class Student{
       int age ;
       String name;

       public Student( String name,int age) {
           this.age = age;
           this.name = name;
       }

       @Override
       public String toString() {
           return "Student{" +
                   "age=" + age +
                   ", name='" + name + '\'' +
                   '}'+"\n";
       }
   }
public class Demo2 {
    public static void main(String[] args) {
         //通过在内部细写就不用再写一个类去实现Comparator了
        Set set = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.age - o2.age;
                if (num == 0){
                    return o1.name.compareTo(o2.name);
                }
                return num;
            }
        });
        set.add(new Student("张三",22));
        set.add(new Student("李四",20));
        set.add(new Student("张勇",25));
        set.add(new Student("刘科",23));
        System.out.println(set);
    }
}

2.内部类

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部类的用法。

2.1成员内部类

案列分析：

    class BB{
        String name = "外部类";
        int age = 22;
        class BBa{
            String name = "内部类";
            public  void test(){
                //打印外部类的名字
                System.out.println(BB.this.name);
                //打印外部类的年龄
                System.out.println(BB.this.age);
                //打印内部类的名字
                System.out.println(name);
            }
        }
    }
public class Demo3 {
    public static void main(String[] args) {
        BB bb = new BB();
        //通过BB来创建BBa的对象
        BB.BBa bba = bb.new BBa();
        //通过内部类调用内部类的方法，判断打印是否正确
        bba.test();
    }
}

我们在一个类里面写了名字和年龄的属性，然后在这个类里面有创建了一个类叫内部类，内部类又声明了名字，并创建了一个方法，方法里通过外外部类.this.属性名来调用外部类属性。然后内部类直接打印属性。在实例化的时候，需要先实例外部类，然后通过外部类名字.内部类名字 内部类对象名  = 外部类对象名.new 内部类名字来实例化内部类。最后通过内部类对象调用内部类方法。 

结果：