目录

静态内部类：作为类的静态成员，存在于某个类的内部

成员内部类：作为类的成员，存在于某个类的内部

局部内部类：存在于某个方法的内部

匿名内部类：存在于某个类的内部，但是无类名的类

静态内部类：作为类的静态成员，存在于某个类的内部

1.静态内部类虽然是外部类的成员，但是在未创建外部类的对象的情况下，可以直接创建静态内部类的对象

2.静态内部类可以引用外部类的静态成员变量和静态方法，但不能引用外部类的普通成员

public class Outter1 {
static int a=1;
int b=0;
public static void test1(){
    System.out.println("外部类的静态方法");
}
public void test2(){
    System.out.println("外部类的非静态方法");
}

class Inner{
    public void test(){
        System.out.println("在成员内部类的方法中");
        test1();//调用外部类的静态方法
        test2();//调用外部类的非静态方法
        System.out.println(a+b);//访问外部类的静态成员变量和非静态成员变量
    }
}
public static void main(String[] args) {
    //Inner in=new Inner();成员内部类的对象不能直接创建，会报错
    Outter1 out=new Outter1();//先创建外部类的对象
    Inner in=out.new Inner();//注意：！！成员内部类的对象必须通过外部类的对象创建
}
}

成员内部类：作为类的成员，存在于某个类的内部

1.内部类直接访问外部类的成员，因为内部类对象中都隐藏了一个外部类对象；

2.外部类想访问内部类的成员，必须要创建对对象；

   实例成员内部列归外部类对象所有

package day8_10;
class Cat{
	private int weight;
	public Cat(int weight) {
		super();
		this.weight = weight;
	}
	//实例成员内部类
	class CatBody{	
		private String color;
		public CatBody(String color) {
			super();
			this.color = color;
		}
		public void show() {
			//内部类直接访问外部类成员，因为内部类对象中都隐藏了一个外部类对象
			//System.out.println("颜色："+color+Cat.this.weight);
			System.out.println("颜色："+color+weight);
		}
	}
	public void display() {
		System.out.println(weight);
		//外部类访问内部类的成员，用对象
		CatBody body = new CatBody("白色");
		body.show();
	}
}
public class TestCat1 {
	public static void main(String[] args) {
		Cat cat = new Cat(22);
		cat.display();
		//创建内部类对象
		//实例成员内部类归外部类对象所有
//		Cat.CatBody body = new Cat(33).new CatBody("黑色");
		Cat.CatBody body = cat.new CatBody("黑色");
		body.show();
	}
}

局部内部类：存在于某个方法的内部

  1.   局部内部类只能在方法内部中使用，一旦方法执行完毕，局部内部类就会从内存中删除。
  2.  可以直接访问外部类中的成员，因为还持有外部类中的引用
  3.   必须注意：如果局部内部类中要使用他所在方法中的局部变量，那么就需要将这个局部变量定义为final的
package xunhuan;
class Outer{
	int a =10;
	public void test() {
		final int c=5;
		System.out.println("在外部类的方法中");
		class Inner{
			int b=20;
			public void test1() {
				System.out.println("在外部类的方法中");
				System.out.println(Outer.this.a);
				System.out.println(b);
				System.out.println(c);//注意：如果局部内部类中要使用他所在方法中的局部变量，
				//那么就需要将这个局部变量定义为final的。
			}
		}
		Inner inner = new Inner();
		inner.test1();
	}
}
public class Jubu{
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.test();
	}
}

匿名内部类：存在于某个类的内部，但是无类名的类

  new 类或者接口的名字(){

大括号中是匿名内部类的主体，这个主体就是类或者接口的实现，如果是类，那么匿名内部类是该类的子类，如果是接口，匿名内部类需要完成接口的实现。

}

class Person{
    public void show(Message message){
        message.show();
    }
}

class Message{
    public void show(){
        System.out.println("在Message类中");
    }
}

public class Outter3 {
    public static void main(String[] args) {
        Person person=new Person();
        person.show(new Message(){
            public void show(){
                System.out.println("在匿名内部类中");
            }
        });
    }
}

}