Java——内部类

1. 静态内部类

import java.io.*;
import java.util.*;

import org.omg.CORBA.PRIVATE_MEMBER;

public class Hello {
	//静态变量
	private static String s1="A";
	//成员变量
	private String s2="B";
	
	//静态方法
	private static void m1(){
		System.out.println("m1 method execute!");
	}
	
	//成员方法
	private void m2(){
		System.out.println("m2 method execute!");
	}
	
	//静态内部类
	static class Customer{
		//静态方法
		public static void m3(){
			System.out.println(s1);
			//System.out.println(s2);//成员变量无法用静态访问（即使创建了Customer对象也是用类去访问的）
			m1();
			//m2();//成员方法无法用静态访问
		}
		
		//成员方法
		public void m4(){
			System.out.println(s1);
			//System.out.println(s2);//成员变量无法用静态访问
			m1();
			//m2();//成员方法无法用静态访问
		}
	}
	public static void main(String[] args){
		//静态内部类虽然无法访问成员，但可以访问外部类内的私有
		Hello.Customer.m3();
		Customer customer =new Hello.Customer();
		customer.m4();
		//Hello.Customer.m4();//编译出错，别搞混了，是静态的可以直接用类名访问，也可以用对象访问；成员必须用对象访问
	}
}

2. 成员内部类

public class OuterClass {
	//静态变量
	private static String s1="A";
	//成员变量
	private String s2="B";
	//静态方法
	private static void m1()
	{
		System.out.println("m1 method executed!");
	}
	//成员方法
	private void m2(){
		System.out.println("m2 method executed!");
	}
	
	class InnerClass{
		//public static String s3="hhh";//非法 非静态内部类中不能出现静态成员
		public String s4="hihi";
		public void m3()
		{
			//可以访问外部类的一切成员
			System.out.println(s1);
			System.out.println(s2);
			m1();
			m2();
		}
		//非法  非静态内部类中不能出现静态成员
//		public static void m4(){
//			System.out.println("kkk");
//		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OuterClass outerClass =new OuterClass();
		InnerClass innerClass =outerClass.new InnerClass();
		innerClass.m3();
		//System.out.println(InnerClass.s3);
		System.out.println(innerClass.s4);
	}

}

3. 局部内部类

public class OuterClass {
	//局部内部类可存在于成员方法中
	public void m1()
	{
		final int i=10;
		
		class InnerClass{
			public String s1="A";
			//public static String s2="b";//非法  非静态内部类中不能出现静态成员
			public void m3(){
				System.out.println("m3 method executed");
				System.out.println(i);
			}
			//非法  非静态内部类中不能出现静态成员
//			public static void m4(){
//				System.out.println("m4 method executed");
//			}
		}
		InnerClass innerClass =new InnerClass();
		innerClass.m3();
		System.out.println(innerClass.s1);
	}
	//局部内部类也可存在于静态方法中
	public static void m2(){
		final int i=10;
		class InnerClass2{
			public String s3="A";
			//public static String s4="b";//非法  非静态内部类中不能出现静态成员
			public void m4(){
				System.out.println("m4 method executed");
				System.out.println(i);
			}
			//非法  非静态内部类中不能出现静态成员
//			public static void m5(){
//				System.out.println("m5 method executed");
//			}
		}
		InnerClass2 innerClass2 =new InnerClass2();
		innerClass2.m4();
		System.out.println(innerClass2.s3);
	}
	
	public static void main(String[] args) {
		OuterClass outerClass =new OuterClass();
		outerClass.m1();
		OuterClass.m2();
	}
}

4、匿名内部类

import java.io.*;
import java.util.*;

import org.omg.CORBA.PRIVATE_MEMBER;

public class Hello {
	public static void m1(Haha h)
	{
		h.logout();
	}
	public static void main(String[] args){
		m1(new A());
	}
}

interface Haha{
	void logout();//抽象方法必须使用public abstract修饰，只不过这里省略了
}

class A implements Haha{
	public void logout()//继承方法的访问权限不能比父类还低，所以不能漏掉public否则为缺省，降低了访问权限
	{
		System.out.println("welcome to the real world!");
	}
}

import java.io.*;
import java.util.*;

import org.omg.CORBA.PRIVATE_MEMBER;

public class Hello {
	public static void m1(Haha h)
	{
		h.logout();
	}
	public static void main(String[] args){
		m1(new Haha(){
			public void logout(){
				System.out.println("welcome to the real world");
			}
		});
	}
}
//new Haha(){
//	public void logout(){
//		System.out.println("welcome to the real world");
//	}
//}这是一个匿名内部类，实现接口所以{}内有重写的抽象方法
interface Haha{
	void logout();//抽象方法必须使用public abstract修饰，只不过这里省略了
}