Java系列课程笔记-Days18内部类

Days18内部类

概念

在一个类的内部声明的类被称之为内部类

特点

内部类可以直接使用外部类的私有成员

每个内部类将被单独编译成class文件

一般格式为：“外部类@内部类.class”或者“外部类@1.class”

注意

一个java文件中不可以同时声明两个以及以上的public修饰的类，除非其余的类都为内部类

就像一身不容二虎，除非一公和一母

分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

代码实现

Outter01.java

package com.james;

public class Outter01 {
	
	int num = 100;
	private String str ="abc";
	
	public void test() {
		System.out.println("test");
	}

	public class Inner01 {
		
		int num = 200;
		
		//	在非静态内部类中无法定义静态属性
		//	static int n2 = 300;
		
		public void test() {
			System.out.println("test inner" + num);
			System.out.println("test inner" + str);
			System.out.println("-----------");
			System.out.println("test inner" + this.num);
			System.out.println("-----------");
			System.out.println("test inner" + Outter01.this.num);
//			System.out.println("-----------");
			//	super指的是Object对象，没有num属性，所以无法调用
//			System.out.println("test inner" + super.num);
		}
		
		//	非静态内部类中无法定义静态方法，静态方法只能被定义在静态内部类中或者外部类中
//		public static void test2() {
//			
//		}
	}

	public class Inner02 {
	}
}

//class Outter02 {
//}

TestOutter01.java

package com.james;

public class TestOutter01 {

	public static void main(String[] args) {
		Outter01 o = new Outter01();
		
		System.out.println(o.num);
		o.test();
		
		System.out.println("===========");
		
		Outter01.Inner01 in01 = new Outter01().new Inner01();
		
		System.out.println(in01.num);
		in01.test();
	}

}

Outter02.java

package com.james;

public class Outter02 {

	private static String str1 = "abc";
	private String str2 = "xyz";
	static int num = 100;
	
	public static void test() {
		System.out.println("static test");
	}
	
	public static class Inner02{
		//	静态内部类可以定义静态属性
		static int num = 200;
		//	静态内部类可以定义非静态属性
		int n = 1000;

		//	静态内部类可以定义静态方法
		public static void test() {
			System.out.println("static test inner");
			System.out.println("static test inner" + str1);
			System.out.println("static test inner" + num);
			System.out.println("static test inner" + Outter02.num);
			System.out.println("static test inner" + new Inner02().n);
		}

		//	静态内部类可以定义非静态方法
		public void test2() {
			System.out.println("test inner");
			System.out.println("test inner" + new Outter02().str2);
			System.out.println("test inner" + num);
			System.out.println("test inner" + Inner02.num);
			System.out.println("test inner" + n);
			System.out.println("test inner" + this.n);
		}
	}
}

TestOutter02.java

package com.james;

public class TestOutter02 {

	public static void main(String[] args) {
		//	直接访问类中的静态属性
		System.out.println(Outter02.num);
		//	直接访问类中的静态方法
		Outter02.test();
		
		System.out.println("============");
		
		//	可以直接通过外部类的静态内部类来直接调用里面的静态属性
		System.out.println(Outter02.Inner02.num);
		//	可以直接通过外部类的静态内部类来直接调用里面的静态方法
		Outter02.Inner02.test();
		
		//	想要调用静态内部类中的非静态成员，必须创建内部类的对象
		Outter02.Inner02 in02 = new Outter02.Inner02();
		
		//	通过内部类的对象来调用静态内部的非静态属性
		System.out.println(in02.n);
		in02.test();
		//	通过内部类的对象来调用静态内部的非静态方法
		in02.test2();
	}

}

Outter03.java

package com.james;

public class Outter03 {

	public void test() {
		
		//	局部内部类，定义在某个方法中，作用范围仅限于当前方法，方法结束后，不再能访问该内部类
		class Inner01{
			
			public void test() {
				System.out.println("test in Inner01");
			}
		}
		
		Inner01 in = new Inner01();
		
		in.test();
	}
	
	public void test2() {
		//Inner01 in = new Inner01();
		
//		in.test();
	}
}

Outter04.java

package com.james;

public class Outter04 {

	public void test() {
		String str = new Object(){
			@Override
			public String toString() {
				
				return "toString in test Inner Object";
			}
		}.toString();
		
		System.out.println(str);
		
		System.out.println("========");
		
		System.out.println(new Object() {
			@Override
			public String toString() {
				return "hehe";
			}
		});
		
		System.out.println("==========");
		
		new MyInterface() {
			
			@Override
			public void test() {
				System.out.println("this is test in my interface inner");
			}
		}.test();
	}
}

TestOutter04.java

package com.james;

public class TestOutter04 {

	public static void main(String[] args) {
		new Outter04().test();
	}
}