内部类（成员内部类、局部内部类、匿名内部类）、匿名对象

内部类：写在其他内部的类为内部类，如生物类中包含植物类、动物类等，则植物类就可以定义为内部类，而生物类为外部类。

1、成员内部类

创建Animal内部类，外部类为Biology

class  Biology{
    public int age;
    public String name;

    public class Plants {
        public String colour;

        public Plants(int a, String n, String c) {
            age = a;// 外部类的成员变量
            name = n;
            colour = c;// 内部类的成员变量
        }

        public void display() {
            System.out.println("植物的名字是:" + name + "
" + "颜色为:" + colour);
        }
    }
}

创建测试类：

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

Biology.Plants plants = new Biology().new Plants(1, "蒲公英", "黄色");// 内部类的访问

 plants.display(); } }

2、局部内部类

局部内部类（放在方法里面的类），调用规则为：

public class Outer {
        public void out{
        class Inner{
            public void Inner(){
                System.out.println()
                }
        }
    }
}

只有out（）方法能够使用局部内部类Inner。

3、匿名内部类

（1）如果用普通方法創建一个动物抽象类，再创建一个Dog类，继承动物类，过程如下：

动物类：

abstract class Animal {
    String name;
    String colour;

    abstract void show();
}

Dog类：

public class Dog extends Animal {
    public Dog(String name, String colour) {
        this.name = name;
        this.colour = colour;
    }

    void show() {
        System.out.println("狗的名字是" + name + ", 它是" + colour + "的");

    }
}

测试类：

public class Test {
public static void main(String[] args) {
    Dog d=new Dog("Tom","黑色");
    d.show();
    
}
}

（2）如果用匿名内部类，操作过程如下：

创建Animal抽象类：

abstract class Animal {
    String name;
    String colour;

    abstract void show(String n,String a);
}

创建测试类：

public class Test {
public static void main(String[] args) {
     Animal a=new Animal(){
        public void show(String n,String c) {
            name=n;
            colour=c;
            System.out.println("狗的名字是" + name + ", 它是" + colour + "的");

        }
    };
    a.show("Jack","灰色");
}
}

 可以看出，我们直接将抽象类的子类隐藏常在了测试类中，没有用到抽象类的实现类，减少了代码的书写。但是匿名内部类只能使用一次。

 （3）匿名内部类举例：定义一个按钮，按钮被按下的时候触发事件

public class SwingTest {
    public static void main(String[] args) {
        JFrame jFrame=new JFrame("My JFrame");
        JButton jButton=new JButton("My JButton");
        jButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Button Pressed!!");
            }
        });
        jFrame.add(jButton);
        jFrame.pack();
        jFrame.setVisible(true);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

（4）总结

匿名内部类没有名字，所以匿名内部类只能使用一次，可以简化代码。它不能extends（继承）其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

前提：必须继承一个父类或实现一个接口，匿名内部类必须实现接口或抽象类的所有方法

可以继承其他类或实现其他接口，在Swing编程中常用此方式来实现事件监听和回调。

可以访问创建它的外部类对象的成员，包括私有成员

4、匿名对象

（1）概念：即隐藏了对象的名字。

（2）创建方式：

         如建立普通对象：Person p=new Person();

         建立匿名对象：new Person();

（3）适用场景：只使用一次对象，用完之后就变成了垃圾，被回收。如;new person().run();

（4）好处：节省代码量

5、普通外部类与内部类的区别

（1）在编译之后内部类会被编译成独立的 .class 文件，但是前面有外部类的类名和 $ 符号。

（2）在外部类的静态方法和外部类以外的其他类中，必须通过外部类的实例创建内部类的实例。在内部类内，可以直接创建内部类的实例。

6、内部类的优点：

（1）可以实现隐藏，普通的类不能被private和protected修饰，但是内部类可以被private和protected声明，来隐藏一些信息。

（2）可以访问外部类的元素，因为内部类是外部类的一个成员。