内部类

基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

基本语法：

class Outer{

	class Inner{

	}

}

内部类的分类：

1.定义在外部类局部位置上(比如方法内)：

1）.局部内那类(有类名)

2）.匿名内部类(没有类名,重点);

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

1）成员内部类（没用static 修饰）

2）静态内部类（使用static 修饰）

局部内部类的使用：

局部内部类记住三点会比较好学：

（1）局部内部类定义在方法中/代码块

（2）作用域在方法体或者代码块中

（3）本质仍然是一个类

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

1.可以直接访问外部类的所有成员，包含私有的 如下演示

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);//可以直接访问到Outer类中的成员
				f1();//可以直接访问到Outer类中的成员
			}
		}
	}
	
}

2.不能添加访问修饰符，因为他的地位就是一个局部内部类，局部内部类是不能使用修饰符的，但是可以使用final修饰，因为局部变量也可以使用final

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
        class Inner{//正确写法
			public void k() {
				System.out.println(num);
				f1();
			}
		}
	 	final class Inner{}//正确写法
        public class inner01{}//错误写法
        //总结除final外的任何修饰符，都是错误写法
	}
	
}

3.作用域：仅仅在定义他的方法或代码块中。

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
        Inner inner =new Inner();//正确写法
	}
    Inner inner =new Inner();//错误写法
	//总结出了方法或者代码块的作用域，都是错误写法因为找不到
}

4.局部内部类—访问—>外部类的成员[访问方式：直接访问]

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);//内部类可以直接访问到外部类的成员
				f1();
			}
		}
	}
}

5.外部类—访问—>局部内部类的成员 访问方式：创建对象，在访问（注意：必须在作用域内）

public class Usb {
	public static void main(String[] args) {
	}
}
class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
        Inner inner=new Inner();//需要创建一个对象才可以访问内部类的成员，还必须时在他的作用域中创建
        inner.k();
	}
}

6.外部其他类–不能访问—>局部内部类（因为 局部内部类地位是一个局部变量）

public class Usb {
	public static void main(String[] args) {
        Inner inner=new Inner();//错误写法
	}
}
class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
	}
}

7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			private int num=9;
			public void k() {
				System.out.println(Outer.this.num);//类名.this可以找到这个类中的成员 this.可以找到类中的成员
				f1();
			}
		}
		Inner inner=new Inner();
		inner.k();
	}
}

匿名内部类：

匿名内部类的使用（重要）

（1）本质时类（2）内部类（3）该类没有名字（4）同时还时一个对象

说明：匿名内部类时定义在外部类的局部位置，比如方法中并且没有类名（表面没有名字，但是在底层系统还是给分配了名字的）

1.匿名内部类的基本语法

public class Test {
	public static void main(String[] args) {
		temp anonymous=new temp() {
			public void h1() {
				System.out.println("驱羊攻虎");
			}
		};
		anonymous.h1();
		System.out.println(anonymous.getClass());//输出匿名内部类的类名
	}
}
abstract class temp{
	public abstract void h1() ;
}

2.匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义同时他本身也是一个对象，因此从语法上看，他既有定义类的特征，也有创建对象的特征对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。

3.可以直接访问外部类的所有成员，包括私有的

public class Test {
    private static String str="以卵击石";
	public static void main(String[] args) {
		temp anonymous=new temp() {
			public void h1() {
				System.out.println("驱羊攻虎\r"+str);//可以直接访问外部类的所有成员，包括私有的
			}
		};
		anonymous.h1();
		System.out.println(anonymous.getClass());//输出匿名内部类的类名
	}
}
abstract class temp{
	public abstract void h1() ;
}

4.不能添加访问修饰符。因为他的地位就是一个局部变量而已。

5.作用域：匿名内部类与局部内部类一样 仅仅在定义它的方法或代码块中

6.匿名内部类----访问---->外部类成员[访问方式：直接访问]

7.外部其他类—不能访问---->匿名内部类（因为 匿名内部类地位是一个局部变量）

8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的化，默认遵循就近原则，如果想要访问外部类的成员，则可以使用（外部类名.this.成员）去访问 如Test.this.str

成员内部类：

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰

基本用法：

public class InnerClassTest {

    public class InnerClassA {
        
    }
}

1.可以直接访问外部类的所有成员，包含私有的

2.可以添加任意访问修饰符(public、protected、默认、private), 因为它的地位就事一个成员。

3.作用域：和外部类的其他成员一样，为整个类体，在外部类的成员方法中创建成员内部类对象，在调用方法。

4.成员内部类----访问---->外部类(比如：属性) [访问方式：直接访问]（说明）

5.外部类—>访问---->内部类 (说明) 访问方式：创建对象，在访问

6.外部其他类----访问---->成员内部类

7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就进原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

静态内部类的使用：

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

public class InnerClassTest {

    static class InnerClassA {
        
    }

}

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2.可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员

3.作用域：同其他成员，为整个类体

4.静态内部类—访问—>外部类（比如：静态属性）[访问方式：直接访问所有静态成员]

5.外部类—访问—>静态内部类 访问方式：创建对象、在访问

6.外部其他类—访问—>静态内部类

7.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问