inner_class内部类

内部类分为
1.成员内部类
2.静态内部类
3.局部内部类
4.匿名局部类

内部类里面不能又静态声明

重点掌握匿名内部类以及局部内部类

关于静态内部类
1.静态内部类可以等同看作静态变量

2.内部类重要的作用：可以访问外部类中私有的数据。

public class OuterClass{
	
	//静态变量
	private static String s1 = 'A';
	
	//私有成员变量
	String s2 = 'B';

	//静态方法
	private static void m1(){
		System.out.println("static m1()");
	} 
	//成员方法
	private void m2(){
		System.out.println(" m2()");
	}
	//静态内部类
	//可以用访问控制权限的修饰符修饰
	//public,protected,private，缺省
	static class InnerClass{   //在类内里面还有一个类

		
		//静态类中的静态方法
		public static void m3(){
		System.out.println(s1);  //因为是内部类故可以访问内部的私有变量，
		m1();				//同时也因为是静态类，所以只能访问静态的变量或者静态的方法

		//System.out.println(s2)	//变量s2虽然是私有的，但是不是静态的，所以无法访问
		//m2();					//方法m2()，同样由于不是静态方法，无法被静态类访问
	} 


		//静态类中的成员方法
		public void m4(){
			System.out.println(s1);
			m1();
		}
	}
	

	public static void main(String[] args){		//写一个主函数去测试一下静态类
	//执行m3（）
	OuterClass.InnerClass.m3();				//执行静态类中的静态方法

	//执行m4（）； m4为成员方法，需要创建对象来访问
	InnerClass c1 = new OuterClass.InnerClass(); //InnerClass c1 = new InnerClass() 现在的版本	也可以这样写
	c1.m4();
	}
}

2.成员内部类

1.关于成员内部类可以等同看作成员变量

2.当看作成员变量后具有与成员变量相同的性质，可以访问类内部静态与非静态的变量以及方法

public class OuterClass{
	private static  int c1 = 2;
	private String name = "abc";

	private static void m3(){
	System.out.println(c1;)
	}
	
	//成员内部类写法如下，Class前不加修饰的东西
	class InnerClass{
	public void m1(){
		System.out.println(s1);
		m3();
	}
	}
	
	public static void main(String[] args){
		InnerClass c1 = new InnerClass();

		c1.m3=1();
	}

}

局部内部类等同于局部变量

重点：局部内部类在访问局部变量的时候，局部变量必须用final 修饰

public class OutInner{

	public void m1(){
		//局部变量，在方法内的局部变量
		final int i = 10;

		//在方法里的局部内部类
		//局部内部类前不能加权限修饰符，这类比于局部变量，前面是没有访问控制权限访问符修饰
		class InnerClass{	//内部类内部都不能有静态声明
			//成员方法是可以有的
			public void m2(){
			System.out.println(i); //这样访问i，如果i没有被final修饰则会报错
								//局部内部类想要访问前面的局部变量时，该局部变量需要用final修								饰
								//因为防止后续有程序想修改 i的值，但是我们在局部类中输出的必									须要是一个确定的值
			}
		}
		//调用m2，需要在有局部类的方法里就创建这个内部类，因为外部是无法直接定义局部内部类的
		InnerClass inner= new Innerclass();
		 /*i = 5;  //这样程序会报错，所以这里是为什么需要i的类型要定义为final的原因*/
		 inner.m2();
	}

	//执行m2的方法，即执行局部类的方法
	public static void main(String[] args){
		OuterInner o1 = new OutInner();
		o1.m1();//这样就可以实现内部类里的方法
	
	}
	

}

匿名内部类：指的是类没有名字.
优点：可以少定义一个类
缺点：无法重复使用

public class Test{	
	public static void t(CustomerService cs){
	cs.logout();
	}

//入口	
public static void main(String[] args)
{
	t(new CustomerServiceImp()); //这是不用匿名的实现方法，将接口先用类来实现，再实例化

	//用匿名内部类的方法来实现，可以不用创建新的类去实现接口
	t(new CustomerService(){
		public void logout(){
			System.out.println("system quit success!");
		}
	})
}


interface CustomerService{
	void logout();
}

class CustomerServiceImp implements CustomeService{
	public void logout(){	//一个类去实现一个接口时，需要将接口里所有的抽象方法重写
	
		System.out.println("system quit success");
	}
}