Java 内部类

　　一、什么是内部类？

　　内部类就是把一个类写到另一个类的内部。

　　二、为什么要存在内部类这个东西？

　　这个我可以举个例子，例如现在有A类和B类

   class A{
        int num=10;

        public void methonA(){
            System.out.println("大家好，我是A方法");
        }

        //A类想调用B类，也得new一个对象出来
        B b=new B();
        

    }
    class B{
        A a=new A();

        public void methonB(){
            System.out.println(a.num);
            a.methonA();
        }
    }

可以看到，B类想要访问A类的变量和方法，必须new一个A类的对象出来。这当然是没问题的。那我的A类现在也想访问B类的一些成员，那我也new一个B类的对象？？？

B套A，A套B，这样不觉得很绕很麻烦吗，所以内部类应运而生，把B放在A类的内部，这样B类使用A类的成员的时候，就直接使用，A类使用B类的成员的时候，就new一个对象，相当于省了一步。

改进后的内部类的代码是这样的

package com.company;

public class Main {

    public static void main(String[] args) {
        System.out.println("大家好，我是Vae");
        A a =new A();
        a.methonA();

    }
}


//内部类可以直接访问外部类的所有成员，包括私有的
//外部类想要访问内部类，必须创建内部类的对象

class A{
    private int num=10;

    public void methonA(){
        System.out.println("大家好，我是A方法，外部类");
        B b=new B();
        b.methonB();
    }

    class B{

        public void methonB(){
            System.out.println("大家好，我是B方法，内部类");
            System.out.println("A类的变量："+num);
        }
    }

}

我们可以看到，B类作为内部类，直接调用了A类的变量num，运行结果如下：

内部类的总结：

1.内部类可以直接访问外部类的所有成员，包括私有的
2.外部类想要访问内部类，必须创建内部类的对象

下面来看一下，内部类调用变量的区别，代码如下：

package com.company;

public class Main {

    public static void main(String[] args) {
        System.out.println("大家好，我是Vae");
       Outer outer=new Outer();
       outer.methon();

    }
}


class Outer{
    int num=5;

    public void methon(){
        System.out.println("大家好，我是外部类方法");
        Inner inner=new Inner();
        inner.methon();
    }

    class Inner{
        int num=1;
        public void methon(){
            int num=4;
            System.out.println("大家好，我是内部类方法");
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }

}

输出结果：

　　三、局部内部类

 局部内部类，可以把内部类写到方法的里面。

package com.company;

public class Main {

    public static void main(String[] args) {
        System.out.println("大家好，我是Vae");
       Outer outer=new Outer();
       outer.methon();

    }
}


class Outer{
    int num=5;

    public void methon(){
        System.out.println("大家好，我是外部类方法");
        //局部内部类，可以把类写在方法里面，但是不能用修饰符public,private之类的修饰了
        class Inner{
            public void methon(){
                System.out.println("大家好，我是内部类方法");
                System.out.println(num);
            }
        }
        new Inner().methon();
    }



}

　　四、匿名内部类

　　匿名内部类就是没有名字的内部类......这里我举一个很好玩的例子。

例如，我在实现接口的时候，电脑上的接口都是实现了USB协议的，像鼠标，键盘之类的，都写了各自的类。但是某一个只用一次就不用的东西，就没必要去专门的写代码。例如打印机，假如打印机这个是几乎不怎么使用的东西。那我可以这样写代码

package com.JavaBoard;

public class Main {

    public static void main (String [] args){


        MotherBoard motherBoard=new MotherBoard();

        motherBoard.install(new Mouse());
        motherBoard.install(new InterUSB() {
            @Override
            public void Input() {
                System.out.println("我是匿名内部类");
            }
        });


    }

}

可以看到，我的电脑主板MotherBoard类的实例，第一次调用了鼠标的对象，然后下一个呢，我直接new了接口，接口是没办法去new的，这里使用的其实就是匿名内部类，这个匿名内部类继承了InterUSB接口，然后重写了Input方法，这样可以在穿参的时候，直接把想做的功能传进来，就不用去单独写类，去重新编译运行程序了。