1.内部类定义

定义在一个类类体当中的类，被称为内部类

public class 内部类{
    public static void main(String[] args){
        Animal an = new Animal();
        an.Bird bird = an.new Animal();
        //不想新建animal对象则可以
        Animal.Cat cat = new Animal().new Cat();
        cat.catch();
        bird.fly();
    }
}

class Animal{
    Object animal = new Object();
    class Bird{
        public void fly(){
            System.out.println("鸟会飞");
        } 
    }
    class Cat{
        public void catch(){
            System.out.println("猫会抓老鼠");
        }
    }
}

2.内部类作用

为了共享数据。

2.1数据共享方式

静态变量，内部类，参数传递

3.内部类分类 *

根据能够共享外部类的哪些内容分为四类

1.静态内部类，仅能共享外部类的静态成员（属性+方法），但因为即使不是内部类也能共享静态成员，因此静态内部类是为了描述类与类之间关系的。

public class TestStaticInnerClass{
	public static void main(String[] args){
		A.C c = new A.C();
		c.test();
	}
}

class A{
	static int i = 10086;
	int j = 1;
	static class C{
		public void test(){
			System.out.println(i);
			//System.out.println(j);调用不了外部类的非静态成员
		}
	}
}

2.成员内部类，可以共享外部类的所有（静态和非静态）成员（属性+方法）

public class TestMemberInnerClass{
	public static void main(String[] args){
		A.C cc = new A().new C();
		cc.test();
	}
}
class X{
	int i = 7;
}
class A{
	int i = 3;
	private void print(){
		System.out.println("abc");
	}

	class C extends X{
		int i = 5;
		A a = new A();
		public void test(){
			System.out.println(i);//5
			System.out.println(this.i);//5
			System.out.println(C.this.i);//5

			System.out.println(A.this.i);//3

			System.out.println(super.i);//7
			System.out.println(C.super.i);//7
			a.print();//私有的也能共享
		}
	}
}

3.局部内部类，如果存在于静态方法中，则共享外部类的静态成员。如果存在于非静态方法中，则共享外部类所有（静态+非静态）成员（属性+方法）。此外，它们都可以共享外部类那个方法的局部变量，但是JDK8.0之前必须加以final修饰，JDK8.0之后不需要，因为默认是final的。

*:有位置限定： 定义完成之后 其所在方法结束之前!

public class TestLocalInner{
	public static void main(String[] args){
		Outer o = new Outer();
		o.test1(100);
		System.out.println("=============");
		o.test2(50);
	}
}
class Outer{
	int a = 3;
	static int b = 5;
	public static void test1(int c){
		class Inner{
			public void test(){
				//System.out.println(a);无法调用非静态成员
				System.out.println(b);
				System.out.println(c);
			}
		}
		Inner in = new Inner();
		in.test();
	}

	public void test2(int c){
		int d = 7;
		class Inner{
            d = 11;
			int x = 9;
			public void test(){
				System.out.println(a);//true (取决于外部类方法是否是非静态的)
				System.out.println(b);//true
				System.out.println(c);//true (取决于JDK版本 8.0之前必须加final)
				System.out.println(d);//true (取决于JDK版本 8.0之前必须加final)
				System.out.println(x);//true
			}
		}
		Inner in = new Inner();
		in.test();
	}
}

4.匿名内部类（这个匿字手写的时候忘了咋写，就很尴尬）

匿名内部类能共享的数据取决于其所在的位置，也就是它是上面三种的某一种。

匿名内部类同样可以产生.class文件，但是其名字是由数字编号命名的。

匿名内部类如何实现接口：
        new 接口(){
            完成抽象方法的具体实现~
        };

    匿名内部类如何继承父类：     
        new 父类(给父类构造方法传参){
            完成抽象方法的具体实现~
        };

public class TestAnonyInner{
	public static void main(String[] args){
		Person p = new Person("张三"){
			@Override
			public void eat(){
				System.out.println("张三吃午饭");
			}
		};
		p.eat();
	}
}
abstract class Person{
	String name;
	public Person(String name){
		this.name = name;
	}
	public abstract void eat();
}