内部类

内部类

将一个类定义在另一个类里面，里面的那个类就称为内部类。内部类的出现，再次打破了Java单继承的局限性。

访问特点：

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必须要建立内部类的对象。

成员内部类

• 成员内部类是定义在类中方法外的类；
• 创建对象的格式为：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
• 成员内部类之所以可以直接访问外部类的成员，那是因为内部类中都持有一个外部类对象的引用：*外部类名.this*；
• 成员内部类可以用的修饰符有final，abstract，public，private，protected，static.

静态内部类

• 静态内部类就是成员内部类加上静态修饰符static，定义在类中方法外。

在外部类中访问静态内部类有两种场景：

• 在外部类中访问静态内部类中非静态成员：外部类名.内部类名 对象名 = 外部类名.内部对象，需要通过创建对象访问；
• 在外部类中访问静态内部类中的静态成员：同样可以使用上面的格式进行访问，也可以直接使用*外部类名.内部类名.成员*。

局部内部类

局部内部类是定义在方法中的类。

• 方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
• 方法内部类对象不能使用该内部类所在方法的非final局部变量。

可以用于方法内部类的修饰符有final，abstract；

静态方法中的方法内部类只能访问*外部的静态成员*。

class Outer {
    private int a = 1;

    public void method1(){
        String name = "阿巴阿巴";
        class Inner{    //成员内部类
             public void show(){
                 System.out.println(a);
                 System.out.println(name);
                 System.out.println("我是成员内部类");
             }
        }
        Inner i = new Inner();
        i.show();
    }

    private class OpInner{  //局部内部类(private)
        public void show(){

            System.out.println(a+1);
            System.out.println("我是局部内部类(private)");
        }
    }

    class OInner{   //局部内部类
        public void show(){
            System.out.println(a+2);
            System.out.println("我是局部内部类");
        }
    }

    public void method2(){
        OpInner oi = new OpInner();
        oi.show();
    }
}
public class Demo {
    public static void main(String[] args) {

        Outer.OInner oInner = new Outer().new OInner();
        oInner.show();  //我是局部内部类
        System.out.println("----------------");

        Outer o = new Outer();

        o.method2();    //我是局部内部类(private)
        System.out.println("----------------");

        o.method1();    //我是成员内部类
    }
}

匿名内部类

• 匿名内部类是内部类的简化写法，(本质)是建立一个带内容的外部类或者接口的子类匿名对象。
• 前提：
  内部类可以继承或实现一个外部类或者接口。
• 格式：
  new 外部类名或者接口名(){重写方法};
  通常在方法的形式参数是接口或者抽象类，并且该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。

public interface Inner {
    void show();
}
class Outer {
    int num = 12;
    public void method(){
        int age = 23;
        new Inner(){
            @Override
            public void show() {
                System.out.println(age);
                System.out.println(num);
                System.out.println("我是匿名内部类");
            }
        }.show();

        Inner inner = new Inner(){
            @Override
            public void show() {
                System.out.println("I'm 匿名内部类");
            }
        };
        inner.show();
        inner.show();
    }
}
public class Demo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();	/*23
						  12
						  我是匿名内部类
						  I'm 匿名内部类
						  I'm 匿名内部类*/
    }
}

匿名内部类在开发中的使用

public interface Jumping {
    void Jump();
}

public class JumpOperator {
    public void method(Jumping j){
        j.Jump();
    }
}

public class demo {
    public static void main(String[] args) {
        JumpOperator jo = new JumpOperator();

        jo.method(new Jumping() {
            @Override
            public void Jump() {
                System.out.println("接着奏乐，接着舞");
            }
        });
    }
}