JavaSE_day29(接口例子，成员内部类的创建对象以及如何调用方法，成员内部类的修饰符，局部内部类的定义以及特点，匿名内部类的定义以及如何调用方法、其实现接口继承时？作为参数又如何传递-多态)

1 A_Animal

public interface A_Animal {
	public abstract void eat();
}

A_Cat

public class A_Cat implements A_Animal{

	@Override
	public void eat() {
	System.out.println("猫吃鱼！");
		
	}

}

A_Dog

public class A_Dog implements A_Animal{

	@Override
	public void eat() {
	System.out.println("狗吃骨头！");
		
	}

}

2 A_InnerDemo

 * 常规类：---A_InnerDemo
 * 
 * 内部类： 内部类是一个单独存在的类，只不过是在另外一个类的内部而已----Outer
 * 
 * 成员内部类：【关键：成员内部类更多的是趋向于“成员”这个概念.】
 *         在类的成员的位置，和成员变量以及成员方法所在的位置是一样的  -----Inner
 *         在成员内部类中，可以直接访问外部类的成员。包括私有成员
 * 

public class A_InnerDemo {
	public static void main(String[] args) {
		
		Outer o=new Outer();
		o.method();
//		o.method1();用不了 ，私有的成员只能在Outer本类中使用！
		System.out.println("-----");
		Outer.Inner i = new Outer().new Inner();
			i.function();
	}
}

class Outer{
	private int num=9;
	public void method(){
		System.out.println("你是真的6");
	}
	private void method1(){
		System.out.println("彩笔");
	}
	
	//成员内部类
	class Inner{
		public void function(){
			System.out.println("num:"+num);
			method();
		}
	}
}

3 A_InnerDemo2

 * 成员内部类的修饰符：
 *         我们可以使用权限修饰符，修饰成员内部类，但是如果使用私有private来修饰，则无法再其他类中访问内部类
 *         我们可以使用static修饰成员内部类，不用再创建外部类对象了
 *         
 *     还可以使用final，abstract来修饰成员内部类！
 * 
 * 
 * 知识点：
 *         1.如何常规创建成员内部类对象。Outer2.Inner2 i2=new Outer2().new Inner2();
 *         2.当使用static修饰成员内部类时，又该如何调用。Outer2.Inner2.function();  
 *         3.当使用private修饰成员内部类时，无法通过常规方法创建成员内部类对象！Outer2.Inner2 i2=new Outer2().new Inner2();是用不了的！【因为当成员是私有时，无法在外面的类中使用，当成员是静态时，用类名直接调用即可】
 * 

public class A_InnerDemo2 {
	public static void main(String[] args) {
//		Outer2.Inner2 i2=new Outer2().new Inner2();  //当使用static，private时报错
//		i2.function();

		
/*
		Outer2 o= new Outer2();
		o.method();
*/

		//当使用static时，static::静态关键字，他是一个关键字，用来修饰成员变量和成员方法+可以修饰成员内部类	
		Outer2.Inner2.function();  //比较常用！
		/*static特点：被所有的对象所共享！
		  			可以直接使用类名来调用*/
		
	}
}


class Outer2{
	
	public void method(){
		Inner2 i = new Inner2();
		i.function();
	}
	static class Inner2{
		public static void function(){
			System.out.println("function");
		}
		
	}
}

3 A_InnerDemo3

 * 局部内部类：
 *         在方法内，出了方法之后就无法使用了

public class A_InnerDemo3 {
	public static void main(String[] args) {
	Outer3 o = new Outer3();
	o.method();
	
	
	}
}
	
class Outer3{
	public void method(){
		
		class Inner3{
			public void function(){
				System.out.println("inner function ...");
			}
		}
		Inner3 i = new Inner3();
		i.function();
	}
	
	public void test(){
//		Inner3 i = new Inner3();//报错了，出了方法无法使用
	}
	
}
	

4 A_InnerDemo4

 * 匿名内部类：
 *         可以把匿名内部类看成是一个没有名字的局部内部类
 *         定义在方法内
 *         必须在定义匿名内部类的时候创建他的对象
 * 
 * 格式：
 *         new 类/接口(){
 *             如果是创建了继承这个类的子类对象，我们可以重写父类的方法
 *             如果是创建实现这个接口的子类对象，我们必须重写接口的所有方法
 *         };
 *     原理：创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象 
 *         
 * 

public class A_InnerDemo4 {

	
	public static void main(String[] args) {
		Outer4 o=new Outer4();
		o.method();
		
	}
	
}
interface Inner{
	public  void function();
	
}

class Outer4{
	public void method(){
//		第一种方法
/*	  	new Inner(){  //本质是类

			@Override
			public void function() {
				System.out.println("function.啊啊...");
			}
			
		}.function();//注意;符号别忘了，然后这里要调用function方法，才可以输出function...的值
		*/
		
//		第二种方法
		Inner i = new Inner(){
			@Override
			public void function() {
			System.out.println("function ....a...");
				
			}
		};
				i.function();  //直接使用对象调用！ 
				i.function();
				i.function();
	}
}
	

 

5 A_InnerDemo5

 * 匿名内部类的使用场景：
 *         作为参数进行传递

public class A_InnerDemo5 {

		public static void method(A_Animal animal){//多态的引用
			animal.eat();
		}
		
		
	public static void main(String[] args) {  
/*		第一种方法：常用！
 * 		method(new A_Dog());//多态的使用！
		method(new A_Cat());*/
		
//		第二种方法：
		method(		
			new A_Animal(){

			@Override
			public void eat() {
				System.out.println("猫池月");
				
			}
			
		});
		
	}
	

}