局部内部类

package innerclass;

public class localinnerclass {
    private int a = 10;
    void method(){
        final int x = 1;
        final int[] y = {1};
        int[] z = {1};
        //1.局部内部类是定义在外部类的局部位置，通常是方法。
        //3.不能添加访问修饰符，但是可以使用final 修饰
        //4.作用域：仅仅在定义它的方法或代码块中
        class Innerclass{
            //2.可以直接访问外部类的所有成员，包括私有的
            public int b=20;
            private int c =30;
            int a = 0;
            void innermethod(){
                System.out.println(localinnerclass.this.a);
                System.out.println(a);
                System.out.println(x);
                //不可以x=2
                //但是可以
                y[0] = 2;
                System.out.println("x=="+x);
                System.out.println("y[0]=="+y[0]);
                System.out.println(z[0]);
                z[0] = 2;
                System.out.println(z[0]);
            }
        }
        //6.内部类所在外部类的方法中，可以通过new,调用
        Innerclass innerclass = new Innerclass();
        System.out.println(innerclass.b);
        innerclass.innermethod();
        //不可System.out.println(innerclass.a);
    }

    public static void main(String[] args) {
        new localinnerclass().method();
    }
}

20
10
0
1
x==1
y[0]==2
1
2

*笔记在注释

局部内部类可以访问方法中的局部变量

什么时候需要用final修饰呢？

package innerclass;

public class localinnerclass {
    private int a = 10;
    void method(){
        final int x = 1;
        final int[] y = {1};
        //1.局部内部类是定义在外部类的局部位置，通常是方法。
        //3.不能添加访问修饰符，但是可以使用final 修饰
        //4.作用域：仅仅在定义它的方法或代码块中
        class Innerclass{
            //2.可以直接访问外部类的所有成员，包括私有的
            public int b=20;
            private int c =30;
            int a = 0;
            void innermethod(){
                System.out.println(localinnerclass.this.a);
                System.out.println(a);
                System.out.println(x);
                //不可以x=2
                //但是可以
                y[0] = 2;
                System.out.println("x=="+x);
                System.out.println("y[0]=="+y[0]);
            }
        }
        //6.内部类所在外部类的方法中，可以通过new,调用
        Innerclass innerclass = new Innerclass();
        System.out.println(innerclass.b);
        innerclass.innermethod();
        //不可System.out.println(innerclass.a);
    }

    public static void main(String[] args) {
        new localinnerclass().method();
    }
}

匿名内部类

是没名字的，是类，是内部类

接口的情况：

package innerclass;

public class AnonymousInnerClass {
    void m1(){
        //接口时的匿名内部类
        //想写一个类，但是这个类只用一次就好了的情况，简化开发
        //a的编译类型时A（接口）
        //a的运行类型是这个匿名内部类
        //这个匿名内部类创建一次就不能再找到了
        A a = new A(){
            @Override
            public void cry() {
                System.out.println("I am anonymous!");
            }
        };
        a.cry();
        a.cry();
        System.out.println(a.getClass());
        //输出：
        //I am anonymous!
        //I am anonymous!
        //class innerclass.AnonymousInnerClass$1
    }
    public static void main(String[] args) {
        new AnonymousInnerClass().m1();
    }
}

interface A{
    public void cry();
}

继承的情况

package innerclass;

class outer{
    void m1(){
				//注意，这个Jack会自动传给 构造器
        Dog dog = new Dog("Jack");
        Dog anonyDog = new Dog("Jack"){
            void wow(){
                System.out.println("I am anoy");
            }
        };
        anonyDog.wow();

				//new的时候只用一次的情况：
				new Dog("Jack"){
            void wow(){
                System.out.println("I am anoy");
            }
        }.wow();

    }

    public static void main(String[] args) {
        new outer().m1();
    }
}
class Dog{
    String name;
    Dog(String name){
        this.name = name;
    }
    void wow(){
        System.out.println("wow");
    }
}

也可以继承 抽象类写匿名内部类，但是必须实现所有的抽象方法。

匿名类的时候不能有构造器，但是可以写一个对象初始化代码块