内部类

内部类：在类中定义的类

一、成员内部类

成员内部类：内部类定义在外部类的成员位置

（一）、规则

1. 成员内部类中不能有静态的内容，除静态变量外。
2. 内部变量、外部标量、局部变量同名问题，局部变量–>i ; 内部变量–>this.i ; 外部变量–>外部类名.this.i 。
3. 在外部类中使用内部类的内容需要创建一个内部类的对象（私有内容也可以在外部类中使用）。
4. 使用成员内部类中的内容,要根据外部类的对象使用。
5. 成员内部类具有成员的特性也具有类的特性。
6. 可以使用成员修饰符修饰。

（二）、定义

public class Person{
	int a=25;
	public class Student{//可以使用成员修饰符修饰。
		//成员内部类中不能有静态的内容，除静态变量外。
		private static final int age = 10 ;
		int a=20;
		private void study(){
			System.out.println("正在学习");
		}
		public void one(){
			int a=15;
			study();
			System.out.println(age);
			//区分外部类,内部类,局部的同名变量
			System.out.println(a);  //局部
			System.out.println(this.a);  //内部类
			System.out.println(Person.this.a);  //外部类
		}
	}

	public void Teacher(){
	//在外部类中使用内部类的内容需要创建一个内部类的对象（私有内容也可以在外部类中使用）
		System.out.println("我是教师");
		Student s=new Student();
		System.out.println(s.age);//私有内容age
	}
}
public class Test {
	public static void main(String[] args) {
	//使用成员内部类中的内容,要根据外部类的对象使用。
		//方法1
		Person.Student s=new Person().new Student();//只能使用内部类中的内容
		
		//方法2
		Person p = new Person;
		Person.Student s=p.new Student();//可以使用内部类中的内容，也可以使用外部类中的内容

		s.one();
		Teacher();
	}
}

二、静态内部类

静态内部类：只有静态内部类中可以使用静态成员，除静态变量外

（一）、规则

1. 静态内部类中使用外部类中的成员内容，必须通过外部类对象，因为内部类是静态的
2. 外部类中可以直接通过内部类类名使用内部类中静态的内容，通过静态内部类的对象使用成员
3. 在其他类中使用静态内部类中的内容，通过静态内部类的对象使用

（二）、定义

public class Person{
	int b=25;
	static class Student{//可以使用成员修饰符修饰。
		//成员内部类中不能有静态的内容，除静态变量外。
		static int age = 10 ;
		int a=20;
		private void study(){
			System.out.println("正在学习");
		}
		public void one(){
			System.out.println(age);
			System.out.println(new Person().b);//静态内部类中使用外部类中的成员内容，必须通过外部类对象
			syudy();
			System.out.println(new study().a);//a为成员变量，通过静态内部类的对象使用
		}
		}
	}

	public void Teacher(){
	//外部类中可以直接通过内部类类名使用内部类中静态的内容，通过静态内部类的对象使用成员
		System.out.println(Student.age);
		System.out.println(new Student().a);
	}
}
public class Test {
	public static void main(String[] args) {
	//在其他类中使用静态内部类中的内容，通过静态内部类的对象使用
		Person.Student s=new Person.Student ();
		s.one();
	}
}

三、局部内部类

局部内部类：定义在外部类中的方法中

（一）、规则

1. 局部内部类只能在当前所定义的方法中通过对象使用
2. 如果局部内部类中使用所在的方法的参数，这个参数必须被final修饰，jdk1.8默认省略final

（二）、定义

public class Person{
//如果局部内部类中使用所在的方法的参数，这个参数必须被final修饰，jdk1.8默认省略final
	public String student(final String name){
		int age=20;
		class na(){
			String name = "张三"
		}
		//局部内部类只能在当前所定义的方法中通过对象使用
		System.out.println(new na().name);
	}
}

四、匿名内部类

（一）、定义

1. new 抽象类|接口名 () {类体} . 重写方法名() ;
2. 抽象类|接口名 对象 = new 抽象类|接口名(){类体}
   对象.重写方法名()
3. 匿名内部类作为方法的参数使用

（二）、使用

interface Swim{
	void swimming();
}
public static void main(String[] args) {
	//方法1
	new Swim(){ 
		@Override
		public void swimming() {
			System.out.println("游泳");
		}
	}.sleep();
		
	//2.方法2
	Swim s=new Swim(){
		@Override
		public void swimming() {
			System.out.println("游泳");
		}
	};
	s.swimming();
		
	//方法3 匿名内部类作为方法的参数使用
	test(new Swim(){
		@Override
		public void swimming() {
			System.out.println("游泳");
		}
	});
	static void test(Swim s){
		s.swimming();
	}