Java内部类

一 概念

　　　　　　内部类，顾名思义，就是一个类的内部有其他的类，比如下面这种，一个最简单的内部类示例，内部类又分为 静态内部类和非静态内部类，非静态内部类又分为 1.普通内部类（也称为成员内部类）  在一个类（外部类中直接定义的内部类），这个外部类是相对于内部类来说的，2. 匿名内部类  3.方法内部类（在一个方法，外部类的方法）或代码块中定义的内部类。

　　　　　　内部类仍是一个独立的类，在编译后内部类会被编译成独立的class文件，但是前面冠以外部类的类名和$符号。

　　　　　　内部类可以使用修饰符(private ,public ,protected,default)（方法内部类除外）

public class TestClass {
	// 普通内部类
	class testone {
	}

	// 静态内部类
	class statictest {
	}

	public void getTest() {
		// 方法内部类
		class methodTest {
		}
	}

	// 匿名内部类
	Runnable run = new Runnable() { // 并不是new接口，而是定义了一个内部类的类体，
		// 同时继承runnable接口 ,new出来了一个实例对象,new对象的动作和定义内骨类的动作放在了一起
		@Override
		public void run() {
			// TODO Auto-generated method stub
		}
	};
}

　　静态内部类基本用法

　　　静态内部类 1.可以包含静态，非静态成员 ，2.可以直接调用外部类的静态属性和方法，但是普通属性和方法不能调用不能调用，因为无法从一个静态类中发出对非静态类的请求。3. 在不相关类中 可以直接创建静态内部类的对象（需要通过所在外部类）4. 静态内部类实际上和外部类联系很少，也就是命名空间上的关系。

public class Test {
	public static void main(String[] args) {
		MyClass.Statictest st = new MyClass.Statictest();// 通过外部类new出静态内部类的实例对象
		st.printStatictest();
	}
}

class MyClass {
	static String str = "静态内部类测试";
	int d = 20;

	static class Statictest {

		void printStatictest() {
			// System.out.println(d); 无法调用普通成员变量
			System.out.println(str);// 调用静态变量
		}

	}
}

　　普通内部类（成员内部类）

　　　1 成员内部类就像一个成员变量一样存在于外部类中 ，静态内部类也像一个静态成员变量一样存在于外部类中

　　　2 成员内部类可以访问内部类的所有成员（包括 private ） 静态内部类只能访问 外部类的静态成员

        3 成员内部类的this是指内部类本身，要拿到外部类可以使用 外部类名+this 成员内部类的对象一定要绑在一个外部类对象上，因此，创建内部类对象需要有持有外部类兑现的引用，因此，要先有外部类对象，才能有内部类对象。

　　

public class Test {
	public static void main(String[] args) {
		MyClass m = new MyClass();// 要访问内部类对象，需要先new出外部类，因为内部类需要外部类的引用
		MyClass.test mt = m.new test();
		mt.printlnd();
	}
}

class MyClass {// 内部类就是为了服务外部类，如果服务于多了类，就会将其设置成一个公共类
	static String str = "静态内部类测试";
	int d = 20;

	void printstr() {
		System.out.println(str);
		test t = new test();
		System.out.println(t);
	}

	class test {
		void printlnd() {
			printstr();// 调用外部类方法
			System.out.println(str);// 访问外部类的静态和非静态成员
			System.out.println(d);
		}
	}

}

　　方法内部类

　　　

　　　　

    

public class TestClass {
	int a = 10;

	public void printlnt() {
		int b = 50;
		final int c = 45;
		class metodnClass {
			// int a=b;//内部类不可访问所在方法局部变量，除非该变量设为final
			// 原因 ：方法内部类和局部变量声明周期不一致
			int e = c;

			// static int p=10;//方法内部类只能包含非静态成员
			void printlp() {
				System.out.println(e);
			}
		}
		metodnClass mc = new metodnClass();// 方法内部类只能在方法内部可见
		mc.printlp();
	}
	// metodnClass mc=new metodnClass();//方法内部类只能在方法内部可见,放在方法外部不可行
}

　　匿名内部类

　　　　　如果匿名内部类定义在方法体内部，那么它既是方法内部类也是匿名内部类，匿名内部类只能使用一次，因为没有类名，无法调用。

　　

　　`

　　　　

　　　　

package compiler;

public class Ntest {
			public static void main(String[] args) {
				nitest n=new nitest();
				n.printcar();				
			}
}
class nitest{
	
		   void test01(car c){
			c.printcar();
		}		
	
		void runtest(){
			//接口方式，接口是不能被new的这是new了一个匿名内部类并实现了Runnable接口
			Runnable run=new Runnable() {				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("接口式");
				}
			};			
		}		
		
		void printcar(){
			//继承式内部类
			car c=new car(){
				@Override
				void printcar() {
					// TODO Auto-generated method stub
					System.out.println("继承式，打印子类的骑车，重写了父类的printcar方法");
				}
			};
			c.printcar();			
		}
		
		void printtest01(){
			//参数式匿名内部类   因为参数是car对象， 直接new一个car继承并重写printcar()方法  
			//和继承式匿名内部类比较相似
			test01(new car(){
				@Override
				void printcar() {
					// TODO Auto-generated method stub
					System.out.println("参数式匿名内部类");
				}
			});
			
		}
	
}
class car{
	void printcar(){		
		System.out.println("打印汽车");
	}
	
}