Java内部类

Java内部类，简单来说就是将一个类定义在另一个类或者方法里面，主要分为成员内部类，局部内部类，匿名内部类和静态内部类。

成员内部类

将一个类定义在另一个类中，看起来像是该类的成员一样。如下：

class Fruit {
    int kinds;
    static int weight;
    private void harvest() {
        Apple ap = new Apple();
        ap.sweet();
        System.out.println("Good Harvest!" + ap.red);
    }

    class Apple {
        int red;
        public void sweet() {
            harvest();
            System.out.println("so sweet" + weight);
        }
    }
}

将外部的fruit类称为外部类，定义在其中的apple类称为内部类。内部类可以访问外部类的所有成员，包括静态成员和私有成员。但是外部类想访问内部类的成员就必需先实例化。
成员内部类是内部类中最基础的一种。
内部类对象的创建
在外部类的外部，创建内部类的对象必须先创建对应的外部类。

public static void main(String[] args) {
        Fruit fruit = new Fruit();
        Fruit.Apple apple = fruit.new Apple();

    }

或者在外部类的内部写一个实例化内部类的方法，然后调用。

Class Fruit {
/**
此处省略
**/
public Apple getAppleInstance() {
        Apple apple = new Apple();
        return apple;
    }
}

public class InnerClassTest {
    public static void main(String[] args) {
        Fruit fruit = new Fruit();
        Fruit.Apple apple = fruit.new Apple();
        Fruit.Apple apple1 = fruit.getAppleInstance();
    }
}

内部类可以有多种权限修饰，private，protected，public。如果用private修饰，则只能在外部类的内部访问，如果是protected修饰，只能在同一个包或者继承外部类的时候访问，如果是public则可以在任何地方访问。如果是默认权限，则只能在同一个包下。而外部类只能有public和包访问权限。所以，成员内部类就像外部类的一个成员一样，可以有多种权限修饰。

局部内部类

局部内部类定义在一个方法或者一个局域内，访问权限也仅限于方法内或者局域内。就像方法的一个局部变量一样，没有各种private等修饰符。

public class InnerClassTest {
    public static void main(String[] args) {
        class Man {
            int age;
            void grow() {
                System.out.println("grow up");
            }
        }
        Man man = new Man();
        man.grow();
    }
}

匿名内部类

匿名内部类一般用于事件监听

scan_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });
         
        history_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });

为两个按钮设置监听器，代码中需要给按钮设置监听器对象，使用匿名内部类能够在实现父类或者接口中的方法情况下同时产生一个相应的对象，但是前提是这个父类或者接口必须先存在才能这样使用。

静态内部类

静态内部类也是定义在另一个类中的类，但是多了一个static修饰符。所以它不需要依赖外部类，但是不能使用外部类中的非静态变量和方法。

示例代码

public class InnerClassTest{
    public static void main(String[] args){
        // 初始化Bean1
        InnerClassTest innerClassTest = new InnerClassTest();
        Bean1 bean1 = innerClassTest.new Bean1();
        bean1.I++;

        // 初始化Bean2
        Bean2 bean2 = new Bean2();
        bean2.J++;

        //初始化Bean3
        Bean bean = new Bean();
        Bean.Bean3 bean3  = bean.new Bean3();
        bean3.k++;
    }
    class Bean1{
        public int I = 0;
    }

    static class Bean2{
        public int J = 0;
    }
}

class Bean{
    class Bean3{
        public int k = 0;
    }
}

public class InnerClassTest {
    public static void main(String[] args)  {
        Outter outter = new Outter();
        outter.new Inner().print();
    }
}


class Outter
{
    private int a = 1;
    class Inner {
        private int a = 2;
        public void print() {
            int a = 3;
            System.out.println(a); 
            System.out.println(this.a); 
            System.out.println(Outter.this.a);  
        }
    }
}

参考链接