Java 内部类、静态内部类、局部内部类、匿名内部类的区别

目录

一、内部类（类中->的普通类）

二、静态内部类（类中->的静态类）

三、局部内部类（方法->中的普通类）

四、匿名内部类（3中常用方法）

---

一、内部类（类中->的普通类）

public class TestInner {

	private static String name = "kobe bryant";
	private String num = "001";
	private String address = "GreenLand";

	class Person {
		private String address = "Los angeles";
		public String mail = "kobe@yahoo.com.cn";// 内部类公有成员

		public void display() {
			System.out.println(name);// 只能直接访问外部类的静态成员
			System.out.println(TestInner.this.address);//访问外部类的同名非静态成员变量
			System.out.println(address);// 访问本内部类成员。
		}

	}

	public static void main(String[] args) {
		TestInner test = new TestInner();
		//即使在本类中想要调用Person类，都必须这样写，而不能直接 new Person()
		new TestInner().new Person().display();
	}

}

 注意：

• 内部类中不能有静态成员
• 可以访问外部类的成员变量（外部类名.this.变量名）
• 可以定义在方法外（可以有访问修饰符）和方法内（不能有访问修饰符,这个就是匿名内部类了）

二、静态内部类（类中->的静态类）

public class MyMain{

   private static String name = "kobe bryant";
   private String num = "001";
 
   // 静态内部类可以用public,protected,private修饰 
   public static class Person {

        // 静态内部类中可以定义静态或者非静态的成员
        private String address = "Los angeles";
        private static String x = "Laker";
        public String mail = "kobe@yahoo.com.cn";// 内部类公有成员

        public void display() {

            //不能直接访问外部类的非静态成员
            // System.out.println(num);

            // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
            System.out.println(name);// 只能直接访问外部类的静态成员

            // 静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
            System.out.println("Inner " + address);// 访问本内部类成员。

        }
    }

    public void printInfo() {
        Person person = new Person();

        // 外部类访问内部类的非静态成员:实例化内部类即可
        person.display();

        // System.out.println(mail);//不可访问
        // System.out.println(address);//不可访问
        
        //访问内部类的成员，都要通过内部类的对象
        System.out.println(person.address);// 可以访问内部类的私有成员

        System.out.println(Person.x);// 外部类访问内部类的静态成员：内部类.静态成员
        System.out.println(person.x);// 这样也能访问,但是不推荐
        System.out.println(person.mail);// 可以访问内部类的公有成员
    }

   public static void main(String[] args) {
        MyMain staticTest = new MyMain();
        staticTest.printInfo();
    }
}

注意：

静态内部类，不能访问外部类的非静态成员
静态内部类 不需要创建外部类的对象就可访问（外部类名.内部类 比如new MyMain.Person().display();就创建了静态内部类对象）
静态内部类可以有public、protected、默认的、private等多种类型 （这个功能我倒是从来没听说,通过实验的确ok）

三、局部内部类（方法->中的普通类）

public class TestLocalInnerClass {
	public static void main(String[] args) {
		Outer outer = new  Outer();
		outer.method1();
	}
}

class Outer {

	int num1 = 111;
	
	//外部实例方法
	public void method1() {
		//与类和常量池、堆、栈的开始顺序和回收有关，这里必须是final
		//而jdk8提供默认为final，写不写都默认隐式存在
		final int num3 = 333;

		//局部内部类
		class Inner {
			int num2 = 222;
			public void method2() {
				System.out.println(Outer.this.num1);//访问外部类的num1
				System.out.println(this.num2);//访问内部类num2，内部类访问优先
				System.out.println(num3);
				System.out.println("This is Inner method");
			}
		}

		Inner inner = new Inner();//创建Inner对象
		System.out.println(inner.num2);//访问内部类num2
		inner.method2();//访问内部类方法
	}
}

四、匿名内部类（3中常用方法）

public class TestAnonymityInnerClass {
	public static void main(String[] args) {
        // 利用了两种方法来调用
		Lamp lamp = new Lamp();


		//1.利用了局部内部类
		class RedLight implements Light {
			public void shine() {
				System.out.println("shine in red");
			}
		}
		lamp.on(new RedLight());


		//2.利用了匿名内部类，没有类名，直接去new，去覆盖方法就OK
		lamp.on(new Light() {
			public void shine() {
				System.out.println("shine in yellow");
			}
		});


        //3. lambda表达式（只有一个方法的接口可以用lambda表达式来代替）
        lamp.on(()->{
            System.out.println("shine in blue");
        });

	}
}

interface Light {
	void shine();
}

class Lamp {
	public void on(Light light) {
		light.shine();
	}
}

原文链接 http://t.csdn.cn/nRmdt
原文链接：https://blog.csdn.net/whp404/article/details/89040811