内部类Day10

内部类分四类
（1）成员内部类：在类里面的类；
（2）局部内部类：在方法里面的类；（比较少用）
（3）静态内部类：与成员内部类相似，多了static关键字；
（4）匿名内部类：内部类的简化写法；
本质是继承了该类或者实现了该接口的子类匿名对象。

（1）成员内部类例子：
package 内部类;
特点：
1.内部类可以直接访问外部类的成员，包括私有。
2.外部类要访问的内部类的成员，必须创建对象。
外部类名.内部类名 对象名 = new 外部对象().new 内部类对象();
import 内部类.Outside.Inside;

class Outside{//外部类
	
	private int num=10; //成员变量
	
	public void method1() {//成员方法
		System.out.println(num);
		//外部类能够可以调用内部类的成员方法和成员变量(包括私有)，但是必须要创建对象；
		Inside in=new Inside();
		System.out.println(in.num2);
		in.method();
	}
	
	public void show(){
		System.out.println("小样");
	}
	
	class Inside{//成员内部类
		private int num2=100;
		public void method() {//内部类可以直接访问外部类的成员变量和成员方法(包括私有)；
			System.out.println(num2);
			show();
		}
	}
	
}
public class Practice1 {
	public static void main(String[] args) {
		Outside out = new Outside();
		out.method1();
		System.out.println("-------------------------------");
		//其他类调用内部类---->外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
		Outside.Inside in=new Outside().new Inside();//引用内部类
		in.method();
	}
}

（2）局部内部类例子：

package 局部内部类;

class Outer{

	public void function() {
		System.out.println("外部类的成员方法");
	}
	public void method() {
		int num=10;
		class Damn{
			public  void show() {
				System.out.println("内部类的方法"+num);
			}
		}
		Damn damn=new Damn();
		damn.show();
	}
	/*public void show1() {       		//局部内部类只能在其所在的方法中访问
		Damn damn=new Damn();
		damn.show();
	}*/
}
public class Inner {
	public static void main(String[] args) {
		Outer out = new Outer();
		out.function();
		out.method();
	}
}

（3）静态内部类例子：
特点：
静态类只能调用外部类的静态方法和静态变量
其他成员方法可以通过类名直接调用静态内部类
格式：
类名.方法名或变量名();
其他类可以通过类名调用静态内部类
格式：
外部类名.内部类名.方法名或变量名();

package 静态内部类;

class Outer{
	private static int num=10;
	private int num2=30;
	
	
	
	public void show() {
		System.out.println("Out的show方法"+num);
	}
	public void method() {
		System.out.println("Outer的method方法"+num);
	}
	public static void function() {
		System.out.println("Outer的静态function方法"+num);
	}
	
	
	
	static class Inner1{
		static int num3=100;
		int num=20;
		public void method() {
			System.out.println("Inner1 method方法"+Outer.num);
//			静态内部类只能访问外部类的静态成员（方法或变量）
//			System.out.println(num2);
//			show();
			function();
		}
	}
	static class Inner2{
		public static void print() {
			System.out.println("Inner2 print");
		}
	}
	//成员方法可以用类名直接调用静态内部类，或者是用对象名调用
	public void useInner() {
		//对象名调用
		Inner1 i1=new Inner1();
		System.out.println(i1.num);
		i1.method();
		//类名直接调用
		Inner2.print();
	}
}
public class Practice1 {
	public static void main(String[] args) {
		Outer out=new Outer();
		out.show();
		out.method();
		out.function();
		System.out.println("----1-1-----");
		Outer.Inner1 in=new Outer.Inner1();
		in.method();
		//内部类的静态变量和方法可以直接调用
		System.out.println(Outer.Inner1.num3);//斜体表示静态成员的变量或方法
		Outer.Inner2.print();
		System.out.println("----2--2-----");
		out.useInner();
	}
}

（4）匿名内部类：
1.匿名内部类
就是内部类的简化写法；
2.前提是要存在一个类或者方法
类是指具体类也可以是抽象类；
通常只用借口和抽象类（接口的方法都是抽象方法）
3.格式：
new 类名或者接口名(){
重写方法；
}
4.本质：是一个继承了该类或者实现了改接口的子类匿名对象；
例子：
package 匿名内部类;
//使用接口
interface inter{
void print1();
void print2();
}

class Out{
	public void method() {
/*		//匿名内部类只针对重写一个方法的时候使用，多个则不适合
		new inter() {

			@Override
			public void print1() {
				System.out.println("print1");
				
			}

			@Override
			public void print2() {
				// TODO 自动生成的方法存根
				System.out.println("print2");
			}
		}.print2();
*/		
		//用对象名接收这个内部类
		//适用于调用内部类的多个方法的时候
		inter a=new inter() {
			public void print1() {
				System.out.println("print1");
			}
			public void print2() {
				System.out.println("print2");
			}
		};
		a.print1();
		a.print2();
	}
}
public class Pratice1 {
	public static void main(String[] args) {
		Out out = new Out();
		out.method();
	}
}