成员内部类

内部类：一个类定义在另一个类的内部，该类就被称为内部类。
内部类的class文件名：外部类$内部类。 优点：便于区分该内部类是属于那个外部类的
内部类的类别：
一、成员内部类：
成员内部类的访问方式：
方式一：在外部类提供一个方法创建内部类的对象进行访问
方式二：在其他类直接创建内部类的对象。
格式：外部类.内部类 变量名=new 外部类().new 内部类();
例：Outer.Inner inner=new Outer().new Inner();
注意：如果是一个静态内部类，那么在其他类创建的格式是：
外部类.内部类 类名 = new 外部类.内部类（）；
Outer.Inner inner = new Outer.Inner();

内部类的应用场景：我们在描述事物A的时候，发现描述的事物A中还存在另外一个比较复杂的事物B的时候，而且这个比较复杂的事物B还需要访问A事物的属性等数据，那么这个时候我们就可以使用内部类描述B事物

比如：人------->心脏

内部类的好处： 内部类可以直接访问外部类的所有成员

内部类要注意的细节：
1.如果外部类与内部类存在同名的成员变量时，在内部类中默认情况下是访问内部类的成员变量
可以通过外部类.this.成员变量名 指定访问外部类的成员变量
2.私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能再其他类在创建对象了
3.成员内部类一旦出现了静态的成员，那么该类也必须用static修饰

class Outer{
	//成员变量
	int x= 100; 	//Outer.class文件被加载到内存的时候存在内存中。	静态的成员数据是不需要对象存在才能访问
	// 内部类
	static class Inner {
		static int i = 10;
		public void print(){
			System.out.println("这个是成员内部类的print方法"+i);
		}
	}
	
	public void instance(){					//在外部类创建一个方法，创建内部类的对象，进行访问
		Inner inner = new Inner();
		inner.print();
	}
}

class Demo8 {
	public static void main(String[] args) {
		/*
		Outer outer = new Outer();
		outer.instance();
		
		Outer.Inner inner = new Outer().new Inner();
		inner.print();
		*/
		Outer.Inner inner = new Outer.Inner();			//有静态内部类时，new这个静态内部类的格式
		inner.print();
		System.out.println(Outer.Inner.i);
	}
}

二、局部内部类：
在一个类的方法内部定义另外一个类，那么另外一个类就称作为局部内部类

局部内部类要注意的细节：
1.如果局部内部类访问了一个局部变量，那么该局部变量必须使用final修饰；

class Outer1 {
	String name = "外部类的name";
	
	public void test(){
		final int y = 100;
		//局部内部类
		class Inner{
			int x = 10;
			public void print(){
				System.out.println("这个是局部内部类的print方法"+y);	//如果局部内部类访问了一个局部变量，则该局部变量必须使用final修饰
			}
		}
		Inner inner = new Inner();
		inner.print();
	}
}

class Outer{
	public static void main(String[] args) {
		Outer1 outer = new Outer1();
		outer.test();
	}
}

三、匿名内部类
没有类名的类，就称作为匿名内部类
好处：简化书写
匿名内部类的使用前提：必须存在继承或者实现关系才能使用
匿名内部类只是没有类名，其他的一概成员都是具备的

格式

new 父类类名（）{
	成员
};

new 父类类名（）{
	成员
	public void print(){
		方法内容
	}
}.print();//调用内部成员方法

例题：

abstract class Animal{
	public abstract Animal run();
	public abstract void sleep();
}

class Outer{
	public void print(){
		//需求：在方法内部定义一个类，继承Animal类，然后调用run方法
		/*
		//局部内部类
		class Dog extends Animal{
			public void run(){
				System.out.println("狗在跑。。。");
			}
		}
		//创建对象
		Dog d = new Dog();
		d.run();
		*/
		
		//匿名内部类：匿名内部类只是没有类名，其他的一概成员都是具备的（借用了父类的名字）
		//匿名内部类与Animal是继承的关系
		/*
		new Animal(){
			//匿名内部类的成员
			public Animal run(){
				System.out.println("狗在跑。。。");
				return this;	//在未声明对象时，返回一个Animal值，以便于调用匿名内部类的方法
			}
			public void sleep(){
				System.out.println("狗在睡觉。。");
			}
		//调用匿名内部类的方法
		}.run().sleep();
		*/
		Animal a = new Animal(){	//多态，在父类中新建对象指向子类（只是子类没有名字）
			//匿名内部类的成员
			public Animal run(){
				System.out.println("狗在跑。。。");
				return this;	//在未声明对象时，返回一个Animal值，以便于调用匿名内部类的方法
			}
			public void sleep(){
				System.out.println("狗在睡觉。。");
			}
			/*
			//特有的方法
			public void bite(){	//若声明了对象，这时候再有特有的方法，这时候就不能再使用匿名内部类了，只能使用局部内部类
				System.out.println("狗在咬人。。");
			}
			*/
		};	//比较特殊的地方，大括号后需加分号
		a.run();
		a.sleep();
	}
}
class Demo {
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.print();
	}
}

实现关系下的匿名内部类：

//实现关系下的匿名内部类
interface Dao{
	public void add();
}
class Outer1{
	public void print(){
		//创建一个匿名内部类的对象
		new Dao(){		//新建的是接口的匿名实现类对象，不是接口对象，接口不能新建对象
			public void add(){
				System.out.println("添加成功");
			}
		}.add();
	}
}
class Demo5 {
	public static void main(String[] args) {
		Outer1 outer = new Outer1();
		outer.print();
	}
}

匿名内部类一般是用于实参的
例题：

//实现关系下的匿名内部类
interface Dao{
	public void add();
}
class Outer1{
	public void print(){
		//创建一个匿名内部类的对象
		new Dao(){		//新建的是接口的匿名实现类对象，不是接口对象，接口不能新建对象
			public void add(){
				System.out.println("添加成功");
			}
		}.add();
	}
}
class Demo5 {
	public static void main(String[] args) {
		Outer1 outer = new Outer1();
		outer.print();
		test(new Dao(){	//调用主类的test方法，匿名内部类作为实参传递，简化书写
			public void add(){
				System.out.println("添加员工成功");
			}
		});
	} 
	public static void test(Dao d){
		d.add();
	}
}