Java 内部类的几种分类

目录

一，内部类

二，普通内部类

三，私有内部类 

四，静态内部类

五，局部内部类

六，匿名内部类

---

一，内部类

概述：

内部类可以直接访问外部类的成员，包括私有的；外部类要访问内部类的成员，必须先创建对象；

内部类创建对象：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

二，普通内部类

没有static修饰，且定义在外部类的类体中

特点：

1.普通内部类中的方法可以直接使用外部类的实例变量和实例方法。

2.在常规内部类中可以直接用内部类创建对象

public class OuterClass {
	private int num = 100;
	public static void main(String[] args) {
		OuterClass.InnerClass in = new OuterClass().new InnerClass();
		in.test();
		
	}
	
	private void print(){
		System.out.println("外部类的私有方法");
		
	}
	
	private void makeInner(){
		//在外部类方法中创建内部类实例
		InnerClass in2 = new InnerClass();
		in2.test();
	}
	
	class InnerClass {
		public void test(){
			print();
			System.out.println(num);
			System.out.println("普通内部类");
		}
	}
}

三，私有内部类 

内部类使用private修饰

public class OuterClass2 {
	private int num = 10;

	private class InnerClass2{
		public void test(){
			System.out.println(num);
			System.out.println("普通内部类");
		}
	}
	//私有内部类的使用
	public void outerMethod(){
		InnerClass2 ic = new InnerClass2();
		ic.test();
	}
}

使用私有内部类：

public class Demo {
	public static void main(String[] args) {
		OuterClass2 oc =new OuterClass2();
		oc.outerMethod();
	}
}

四，静态内部类

内部是使用static修饰，不能直接访问外部类的实例变量与实例方法，只有通过对象引用才能访问。

public class OuterClass3 {
	
	public void print(){
		System.out.println("外部类OuterClass3");
	}
	
	public static void hello(){
		System.out.println("外部类的静态方法");
	}
	/*由于static内部类不具有任何对外部类实例的引用，
      因此static内部类中不能使用this关键字来访问外部类中的实例成员，
      但是可以访问外部类中的static成员。这与一般类的static方法相通*/
	static class InnerClass1{
		public void test1(){
			System.out.println("内部类InnerClass1");
			new OuterClass3().print();
			
			hello();
		}
	}
	
	static class InnerClass2{
		public static void test2(){
			System.out.println("内部类InnerClass2");
			new OuterClass3().print();
			
			hello();
		}
	}
}

静态内部类的使用：

public static void main(String[] args) {
	
	OuterClass3.InnerClass1 ic1 = new OuterClass3.InnerClass1();
	ic1.test1();
		
	//使用静态内部类中静态方法
	OuterClass3.InnerClass2.test2();
}

五，局部内部类

在方法体或语句块（包括方法、构造方法、局部块或静态初始化块）内部定义的类

定义局部内部类是需注意以下几点：

1，方法定义局部内部类同方法定义局部变量一样，不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和  abstract修饰

2，方法中的内部类可以访问外部类成员。对于方法的参数和局部变量，必须有final修饰才可以访问。原因：当调用有局部内部类的方法时，局部变量或者方法参数没有final修饰，它的生命周期和方法的生命周期一样，当方法弹栈时这个局部变量也会消失，那么如果局部内部类对象还没有马上消失，想使用这个局部变量或者方法参数，就没有了；如果使用final修饰会在类加载的时候进入常量池，即使方法弹栈常量池中的常量还在，也可以继续使用；

3，static方法中定义的内部类可以访问外部类定义的static成员

public class OuterClass4 {
	
	public void method(){
		//局部内部类不能加任何访问修饰符，因为它只对局部块有效。
		class Inner{
			public void test(){
				System.out.println("局部内部类中的方法");
			}
		}
		//局部内部类的使用
		Inner i = new Inner();
		i.test();
	}

}

六，匿名内部类

类似内部类的简化写法，格式：new 类名或者接口名(){};

public class OuterClass5 {
	class InnerClass implements Inter{
		public void print() {
			// TODO Auto-generated method stub
			System.out.println("内部类");
		}
	}
	
	public void test(){
		//实现Inter接口的匿名内部类
		new Inter() {
			public void print() {
				// TODO Auto-generated method stub
				System.out.println("实现了一个接口的匿名内部类");
			}
		}.print();
		
		//继承User类的匿名内部类
		new User(){
			public void login() {
				// TODO Auto-generated method stub
				System.out.println("继承一个类的匿名内部类");
			}
			
		}.login();
		
		//父类引用指向子类对象，把匿名内部类对象赋值实现的接口
		Inter i = new Inter() {
			public void print() {
				// TODO Auto-generated method stub
				System.out.println("实现接口的匿名内部类对象，并赋值给Inter接口");
			}
		};
		
		i.print();
	}
}

class User{
	public void login(){
		System.out.println("用户登录");
	}
}

interface Inter{
	public void print();
}

匿名内部类当作参数使用

public class OuterClass6 {
	public static void main(String[] args) {
		DemoBook db = new DemoBook();
		db.readBook(new Book() {
			public void read() {
				// TODO Auto-generated method stub
				System.out.println("Android类的书");
			}
		});//匿名内部类当作参数使用
	}
}

abstract class Book{
	public abstract void read();
}

class DemoBook{
	public void readBook(Book b){
		b.read();
	}
}