java内部类笔记

成员内部类

说明：内部类作为另一个类的成员

创建方式：外部类类名.内部类类名 变量名 = new 内部类类名().new 外部类类名()

public class Outer {
    private int age = 98;
    public static String s = "外部类变量";

    public class Inner {
        private String name;
        private int age = 88;

        public void innerFunction() {

            // 访问就近原则：打印88
            System.out.println("变量访问就近原则：" + age);
            // 外部类变量可以访问
            System.out.println("外部类变量：" + s);

            int age = 78;
            // 访问就近原则：打印78
            System.out.println("age：" + age);
            // 访问内部类变量，使用【this.变量名】：打印88
            System.out.println("this.age：" + this.age);
            // 访问外部类变量，使用【外部类类名.this.变量名】：打印98
            System.out.println("Outer.this.age：" + Outer.this.age);
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

	// 创建成员内部类对象【外部类类名.内部类类名 变量名 = new 内部类类名().new 外部类类名()】
	Outer.Inner in = new Outer().new Inner();
	
	in.innerFunction();

静态内部类

说明：在成员内部类的基础上，把内部类用static修饰

创建方式：外部类类名.内部类类名 变量名 = new 外部类类名.内部类类名()

public class Outer {
    private int age = 99;
    public static String schoolName = "外部类变量可以访问";

    public static class Inner {
        public void innerFunction() {
            System.out.println(schoolName);
            // 静态内部类访问外部类的静态变量，可以
            // 静态内部类访问外部类的实例变量，不行
            //System.out.println(age);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        // 创建静态内部类【外部类类名.内部类类名 变量名 = new 外部类类名.内部类类名()】
        Outer.Inner in = new Outer.Inner();
        in.innerFunction();
    }
}

局部内部类

说明：内部类定义在方法里面

使用方式：创建外部类，调用其方法

public class Outer {
    public void function() {
        System.out.println("外部类方法");
        class Inner {
            public void innerFunction() {
                System.out.println("内部类方法");
            }
        }

        // 局部内部类只能在方法中创建对象，并使用
        Inner in = new Inner();
        in.innerFunction();
    }
}

// 创建外部类并使用其方法调用内部类的相关代码
new Outer().function();

匿名内部类（喜闻乐见）

说明：对于一个不能直接new的，特殊的类（抽象类/接口），new类名的同时，实现其抽象方法。使其实现的抽象方法某种程度上成为抽象类/接口的一个实现类

/**
 * 动物抽象类
 */
public abstract class Animal {
    /**
     * 动物的抽象方法
     */
    public abstract void cry();
}

public class Test {
    public static void main(String[] args) {
        // new 后面的部分，相当于Animal的子类对象
        // 可以理解为： Animal a = new Animal子类对象
        Animal a = new Animal() {
            @Override
            public void cry() {
                System.out.println("猫的叫声~~~~~~");
            }
        };
        // 调用cry()方法
        a.cry();
    }
}

其实在JVM中，还是创建了一个实现类对象，把{}中的那部分当做是一个“类”来看了。

首次发布

hezhongying.blog.csdn.net/article/det…