内部类 详解:匿名内部类 成员内部类 静态内部类 私有内部类 局部内部类

内部类

类中定义类,就是内部类
 *     当一个类中成员,也是另一个事物,这个时候就可以把这个事物定义为内部类
 * 
 *     分类:
 *         成员内部类
 *         静态内部类
 *         私有内部类
 *         局部内部类
 *         匿名内部类  ***

成员内部类

 *         当内部类作为外部类的成员的时候,就是成员内部类
 *         特点:
 *             是成员就具有成员的特点,就是可以使用成员修饰符来修饰
 *             是类就有类的特点,可以继承,实现...
 *             内部类中可以使用外部的类的内容,包括私有的
 *             在外部类中可以通过内部类的对象使用其成员
 *             成员内部类中不能定义静态的内容,除了静态的常量

public class Outer01 {
	//成员变量
	//private int a=5;
	int haha=1;
	
	//成员内部类
	class Inner extends Fu implements A{
		String name="靳东";
		static final int age=35;
		int haha=5;
		
		public void inner(){
			int haha=10;
			System.out.println("我是内部类中的成员方法");
			System.out.println(name);
			//System.out.println(a);
			
			//外部类中的
			System.out.println(Outer01.this.haha);
			
			//内部类中的
			System.out.println(this.haha);
			
			//局部的
			System.out.println(haha);
		}
	}
	
	public void outer(){
		System.out.println("我是外部类中的成员方法");
		//通过内部类对象使用
		Inner in=new Inner();
		System.out.println(in.name);
		System.out.println(Inner.age);
	}
}

class Fu{}
interface A{}

私有内部类

 *     私有内部类中可以使用外部类中的私有内容
 *     外部类中可以使用私有内部类中的私有内容,需要通过内部类对象使用
 *     私有的内部类中只能在外部类中使用,其他类中无法使用
 */ 

public class Outer02 {
	private int a=5;
	
	//私有内部类
	private class Inner{
		private int b=10;
		
		private void inner(){
			System.out.println("我是私有内部类中的私有方法");
			System.out.println(a);
			outer();
		}
		
	}
	
	private void outer(){
		System.out.println("我是外部类中的私有方法");
		Inner in=new Inner();
		in.inner();
		System.out.println(in.b);
	}
}

静态内部类

 *     只有静态内部类中可以定义静态的内容,除了静态的常量
 *     静态内部类中使用外部类中的成员,通过外部类对象使用,因为内部类是静态的

public class Outer03 {
	private static String haha="外部类中的静态变量";
	private String hehe="外部类中的成员变量";
	
	//静态内部类
	static class Inner{
		static int a=5;
		int b=10;
		//静态内部类中的静态方法
		static void inner(){
			System.out.println(a);
			System.out.println(new Inner().b);
			System.out.println(haha);
			System.out.println(new Outer03().hehe);
		}
		//静态内部类的成员方法中
		void inner2(){
			System.out.println(a);
			System.out.println(b);
			System.out.println(haha);
			//通过外部类对象使用外部类成员
			System.out.println(new Outer03().hehe);
			
		}
	}
	
	public void outer(){
		System.out.println(Inner.a);
		System.out.println(new Inner().b);
	}
}

局部内部类

 *     方法中的内部类
 *     不能使用成员修饰符 pubic...static..(final可以)
 *     局部只能在它当前定义的方法中使用,通过对象使用
 *     如果想要在局部内部类中使用当前方法的参数,这个参数必须被final修饰,在jdk1.8中final可以省略,但是默认

public class Outer04 {
	static String name="杨洋";
	public static void test(final int args) {
		//args=100;
		
		int a=5; //局部变量
		//局部内部类
		class Inner{
			int b=5;
			
			public void inner(){
				System.out.println(b);
				System.out.println(a);
				System.out.println(name);
				System.out.println(args);
			}
		}
		
		Inner in=new Inner();
		in.inner();
	}
	
	public void outer(){
	}
}

测试类:

public class Test {
	public static void main(String[] args) {
		//其他类使用成员内部类中的内容
		/*Outer01 outer01=new Outer01();
		Outer01.Inner in=outer01.new Inner();*/
		Outer01.Inner in=new Outer01().new Inner();
		in.inner();
		
		//其他类中使用私有内部类中的内容  无法使用
		//Outer02.Inner in2=new Outer02().new Inner();
		
		//其他类中使用静态内部类中的内容
		System.out.println(Outer03.Inner.a); //静态内部类中的静态内容
		//静态内部类中的成员内容
		Outer03.Inner in3=new Outer03.Inner();
		in3.inner();
	}
}