内部类学习

成员内部类

public class Inner {

    	public class Heart{ //成员内部类

		}

}

Inner类是外部类

内部类可以无条件访问外部类的属性和方法，但是外部类想要访问内部类的属性和方法，必须先创建内部类的对象，通过它才能访问内部类的属性和方法

public class Inner {//这是一个外部类
	public int OutNum1 =1;
	protected int OutNum2 =2;	
	int OutNum3 =3;
	private int OutNum4 =4;
	
	public Inner() {
		
		Heart heart=new Heart();//访问内部类先要创建一个对象
		System.out.println("内部类InNum1是"+heart.InNum1);
		System.out.println("内部类InNum2是"+heart.InNum2);
		System.out.println("内部类InNum3是"+heart.InNum3);
		System.out.println("内部类InNum4是"+heart.InNum4);
		heart.name();
		
	}
	
	public class Heart{ //成员内部类
		
		public int InNum1 =1;
		protected int InNum2 =2;	
		int InNum3 =3;
		private int InNum4 =4;	
				
		public void name() {
			System.out.println("这是一个内部方法");
			System.out.println("外部类OutNum1是"+OutNum1);//直接访问外部类的属性和方法
			System.out.println("外部类OutNum1是"+OutNum2);
			System.out.println("外部类OutNum1是"+OutNum3);
			System.out.println("外部类OutNum1是"+OutNum4);
			
		}
	}

    public static void main(String[] args) {
    	
    	Inner inner=new Inner();
    }
}

输出结果如下 ：

调用内部类有两种方式：

    public static void main(String[] args) {
    	
    	Inner inner=new Inner();//间接调用内部类的方法
    	inner.name();
    	
    	Inner.Heart heart=new Inner().new Heart();//直接调用内部类的方法
    	heart.name();
    }

静态内部类

一个类的静态成员独立于这个类的任何一个对象存在，创建一个类的静态内部类对象不需熬依赖其外部类对象。

public class Inner {
	public int OutNum1 =1;
	protected int OutNum2 =2;	
	int OutNum3 =3;
	private int OutNum4 =4;
	
	public Inner() {
		
		Heart heart=new Heart();
		System.out.println("内部类InNum1是"+heart.InNum1);
		System.out.println("内部类InNum2是"+heart.InNum2);
		System.out.println("内部类InNum3是"+heart.InNum3);
		System.out.println("内部类InNum4是"+heart.InNum4);
		heart.name();
		
		StaticHeart staticHeart=new StaticHeart();
		System.out.println("静态内部类StaticNum1是"+staticHeart.StaticNum1);
		System.out.println("静态类StaticNum2是"+staticHeart.StaticNum2);
		System.out.println("静态类StaticNum3是"+staticHeart.StaticNum3);
		System.out.println("静态类StaticNum4是"+staticHeart.StaticNum4);
		heart.name();
		
	}

	static class StaticHeart{ //静态成员内部类
		
		public int StaticNum1 =1;
		protected int StaticNum2 =2;	
		int StaticNum3 =3;
		private int StaticNum4 =4;	
		static int StaticNum5=5;//可以定义static属性
				
		public void name() {
			System.out.println("这是一个静态内部类");
			//System.out.println("外部类OutNum1是"+OutNum1);

			
		}
	}

}

静态内部类无法访问外部类的非静态成员，外部了的非静态成员属于每一个外部类对，但是静态内部类独立于外部类对象存在，所以静态内部类不能访问外部类的非静态成员，但外部类可以访问静态内部类的所有访问权限的成员。

匿名内部类

接口的实现类或者父类的子类只需要使用唯一一次，那么可以省略该类的定义，而改为使用匿名内部类。

定义一个接口和它的实现类：

public interface MyIterface {
	
		public abstract void mewthod();
		
}

public class MyImpl implements MyIterface {

	@Override	
	public void mewthod() {
		// TODO 自动生成的方法存根
		System.out.println("实现类覆盖重写了方法");
		System.out.println("=================");
	}
	
}

普通写法：

	public static void main(String[] args) {
		MyImpl myImpl=new MyImpl();
		myImpl.mewthod();
		
		MyIterface myIterface=new MyImpl();//使用了向上转型
		myIterface.mewthod();

		}

匿名内部类的写法：

		//匿名内部类
		MyIterface obj=new MyIterface() {
			
			@Override
			public void mewthod() {
				// TODO 自动生成的方法存根
				System.out.println("匿名内部类实现了方法A");
			}
		};
		obj.mewthod();
		
		//使用了匿名内部类 而且省略了对象名称  也是匿名对象
		new MyIterface() {
			
			@Override
			public void mewthod() {
				// TODO 自动生成的方法存根
				System.out.println("匿名内部类实现了方法B");
			}
		}.mewthod();