java中的内部类

一、内部类

之前类中可以有变量和方法，今天开始在类中再添加一个元素类。
内部类–包含在类中的类就是内部类
外部类–包含内部类的类就是外部类

内部类分为四个：
成员内部类、方法内部类、静态嵌套类、匿名内部类

二、内部类的使用

1.成员内部类
—-相当于是Java中的成员变量
基本结构：
public class TestClass{
public class InnerClass{ }
        }
        TestClass—外部类
        InnerClass—内部类
内部类编译后会形成一个新的字节码文件【外部类类名$内部类类名.class】
1.成员内部类可以使用任意的访问限制修饰符。
2.成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
3.成员内部类中的构造方法可以访问其他的构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法   ,this.实例变量/方法,可以省略对象/this】。
4.成员内部类中的实例方法可以访问构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法,this.实例变量/方法,可以省略对象/this】。
5.成员内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
6.成员内部类中的实例法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
7.外内部类中的构造方法/实例法可以访问成员内部类的构造方法，实例方法/变量，外内部类中的类方法不能访问成员内部类。
8.其他类中是可以访问成员内部类的，需要依赖外部类对象，注意访问限制修饰符。

例如：

package com.wangxing.test1;

public class testClass {
	//成员颞部类不能出现静态元素但是里面的方法可以访问外部类的实例和静态
	//创建外部类的变量
	public String name="fxt";//实例变量
	public static int int1=1001;//静态变量
	//7.外部类中的构造方法/实例法可以访问成员内部类的构造方法，实例方法/变量，
	//外部类中的类方法不能访问成员内部类。
	//创建外部类的方法
	public testClass(){
		new InnerClass();
	}//构造方法
	public  void testShiLi(){
		new InnerClass();
	}//实例方法
	public static void testJingTai(){
		//外部类中的类方法不能访问成员内部类。
		//new InnerClass();
	}//静态方法
	
	//1.成员内部类可以使用任意的访问限制修饰符。
	//class InnerClass1{}
	//protected class InnerClass2{}
	//private class InnerClass3{}
	//创建成员内部类
	public class InnerClass{
		//2.成员内部类可以有实例变量、实例方法、构造方法，不能有静态元素。
		///创建实例变量,不能出现静态元素
		public String testname="zhangsan";
		//static  int testint=1001;
		//创建构造方法
		public InnerClass(){
			//3.成员内部类中的构造方法可以访问其他的构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法	,
			//this.实例变量/方法,可以省略对象/this】。
			//访问成员内部类中的实例变量
			new InnerClass("testname");
			System.out.println(testname);
			System.out.println(this.testname);//此时this指向成员内部类的对象
			System.out.println(new InnerClass().testname);
			//访问成员内部类中的构造方法
			new InnerClass("fxt");
			//访问成员内部类中的实例方法
			new InnerClass().InnerShiLi2();
			//5.成员内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量。不能用this
			//成员内部类构造方法访问外部类的实例变量
			System.out.println(new testClass().name);
			//System.out.println(this.name);
			//成员内部类构造方法访问外部类的静态变量
			System.out.println(new testClass().int1);
			System.out.println(testClass.int1);
			//System.out.println(this.int1);
			//成员内部类构造方法访问外部类的构造方法
			new testClass();
			//成员内部类构造方法访问外部类的实例方法
			new testClass().testShiLi();
			//成员内部类构造方法访问外部类的静态方法
			new testClass().testJingTai();
		}
		public InnerClass(String str){}
		//创建实例方法
		public void InnerShiLi(){
			//4.成员内部类中的实例方法可以访问构造方法【new】,可以访问实例变量/方法【对象.实例变量/方法,
			//this.实例变量/方法,可以省略对象/this】。
			//访问成员内部类中的实例变量
			new InnerClass("string");
			System.out.println(testname);
			System.out.println(this.testname);//此时this指向成员内部类的对象
			System.out.println(new InnerClass().testname);
			//访问成员内部类中的构造方法
			new InnerClass("lisi");
			//6.成员内部类中的实例法可以访问外部类的构造方法，实例方法/变量，类方法/变量。
			//成员内部类实例方法访问外部类的实例变量
			System.out.println(new testClass().name);
			//System.out.println(this.name);
			//成员内部类实例方法访问外部类的静态变量
			System.out.println(new testClass().int1);
			System.out.println(testClass.int1);
			//System.out.println(this.int1);
			//成员内部类实例方法访问外部类的构造方法
			new testClass();
			//成员内部类实例方法访问外部类的实例方法
			new testClass().testShiLi();
			//成员内部类实例方法访问外部类的静态方法
			new testClass().testJingTai();
		}
		public void InnerShiLi2(){ }
		//不能有静态元素。
		//public static void InnerJingTai(){}
	} 
}

package com.wangxing.test1;
public class otherClass {
	//8.其他类中是可以访问成员内部类的，需要依赖外部类对象，注意访问限制修饰符。
	public void method(){
		//在其他类不能直接访问成员内部类
		//new InnerClass();
		//需要依赖外部类对象
		new testClass().new InnerClass();
		//相当于
		testClass tc=new testClass();
		tc.new InnerClass();
	}	
}

2.方法内部类
—-定义在方法中的类，相当于局部变量
基本结构：

package com.wangxing.test2;
public class testClass {
	// 创建构造方法
	public testClass() {
		// 在构造方法中创建方法内部类
		class InnerClass {
		}
	}

	// 创建实例方法
	public void testShiLi() {
		// 在实例方法中创建方法内部类
		class InnerClass2 {
		}
	}

	// 创建静态方法
	public static void testJingTai() {
		// 在静态方法中创建方法内部类
		class InnerClass3 {
		}
	}
}

1.方法内部类不能使用任何访问限制修饰
2.方法内部类可以有实例变量/方法，构造方法，不能有静态元素。
3.方法内部类的构造方法中可以访问本方法内部类中的构造方法，实例变量/方法【对象/this，也可以省略】
4.方法内部类的实例方法中可以访问本方法内部类中的构造方法，实例变量/方法【对象/this，也可以省略】
5.方法内部类中的构造方法/实例方法中可以访问本方法的局部变量，默认会使用final修饰局部变量【直接变量名称】
6.方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。
7.外部类是不能访问到方法内部类。

例如：

package com.wangxing.test2;

public class testClass {
	//创造外部类的方法和变量
	public String name="lisi";
	public static int num=1001;
	// 创建构造方法
	public testClass(int num){}
	//外部类是不能访问到方法内部类。
	//new InnerClass();错误
	//因为方法内部类相当于方法里的局部变量所以其他类不能访问
	
	public testClass(){
		//1.方法内部类不能使用任何访问限制修饰
		//public class InnerClas { }
		// 在构造方法中创建方法内部类
		class InnerClass {
			//2.方法内部类可以有实例变量/方法，构造方法，不能有静态元素。
			public String testname="zhangsan";
			//static  int testint=1001;
			//创建方法内部类的构造方法
			public  InnerClass(){
				int int1=1002;
				//3.方法内部类的构造方法中可以访问本方法内部类中的构造方法，
				//实例变量/方法【对象/this，也可以省略】
				//访问方法内部类中的实例变量
				System.out.println(testname);
				System.out.println(this.testname);//此时this指向成员内部类的对象
				System.out.println(new InnerClass().testname);
				//访问方法内部类中的构造方法
				new InnerClass(12);
				//访问方法内部类中的实例方法
				new InnerClass().InnerShiLi();
				//5.方法内部类中的构造方法/实例方法中可以访问本方法的局部变量，
				//默认会使用final修饰局部变量【直接变量名称】
				//in1="1003";//不能修改值默认方法内部类中方法的变量用final不可变声明
				System.out.println(int1);
				//6.方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。
				//方法内部类访问外部类的实例变量
				new testClass().name="lisisi";
				//this.name="lisisi";//此时this指向方法内部类对象，不能指向外部类对象
				//方法内部类访问外部类的静态变量
				new testClass().num=1003;
				testClass.num=1003;
				//nthis.num=1003;//错误
				//方法内部类访问外部类的构造方法
				new testClass(12);
				//方法内部类访问外部类的实例方法
				new testClass().testShiLi();
				//方法内部类访问外部类的静态方法
				new testClass().testJingTai();
				testClass.testJingTai();
			}
			public  InnerClass(int num){}
			//创建方法内部类的实例方法
			public void InnerShiLi(){
				//4.方法内部类的实例方法中可以访问本方法内部类中的构造方法，
				//实例变量/方法【对象/this，也可以省略】
				//访问方法内部类中的实例变量
				System.out.println(testname);
				System.out.println(this.testname);//此时this指向成员内部类的对象
				System.out.println(new InnerClass().testname);
				//访问方法内部类中的构造方法
				new InnerClass(12);
				//访问方法内部类中的实例方法
				new InnerClass().InnerShiLi();
			}
			//public static void InnerShiLi(){}
		}
	}
	
	// 创建实例方法
	public void testShiLi() {
		// 在实例方法中创建方法内部类
		class InnerClass2 {
		}
	}

	// 创建静态方法
	public static void testJingTai() {
		// 在静态方法中创建方法内部类
		class InnerClass3 {
		}
	}
}

3.静态嵌套类
—相当于是java类中的静态变量
基本结构;
                public class TestClass {
                    public static class InnerClass{
                    }
                }
1.静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。
2.静态嵌套类中构造方法/实例方法可以访问本静态嵌套类中的构造方法，实例变量/方法，类变量/方法。
3.静态内部类中类方法可以访问本静态嵌套类中的构造方法，实例变量/方法【只能对象】，类变量/方法.
4.静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例变量/方法   【只能对象】，类变量/方法。
5.静态嵌套类中不能有this.
6.外部类的构造方法/实例方法/类方法可以访问，静态内部类中构造方法，实例变量/方法【只能对象】，类变量/方法.
7.其他类中可以访问静态嵌套类【new 外部类类名.静态嵌套类名()】。注意访问限制修饰符

例如：

package com.wangxing.test3;

public class TestClass {
	//创建外部类的实例变量，静态(类)变量
	public String testname="lisi";	
	public static int testInt=101;
	//创建外部类的构造方法、实例方法、静态方法
	public TestClass(){
		//6.外部类的构造方法/实例方法/类方法可以访问，
		//静态内部类中构造方法，实例变量/方法【只能对象】，类变量/方法.
		//外部类访问静态嵌套类中的实例变量
		new InnerClass().Innername="zhangsansan";
		//外部类访问静态嵌套类中的实例变量
		new InnerClass().InnerNum=1002;
		InnerClass.InnerNum=1002;
		//外部类访问静态嵌套类中的构造方法
		new InnerClass();
		//外部类访问静态嵌套类中的实例方法
		new InnerClass().InnerJingTai2();
		//外部类访问静态嵌套类中的类方法
		new InnerClass().InnerJingTai2();
		//外部类访问静态嵌套类中的类方法不能使用类名访问
		//InnerClass.InnerJingTai2();
	}
	public TestClass(String str){}
	public void TestShiLi(){}
	public static void TestJingTai(){}
	
	//创建静态嵌套类--public可以省略
	public static class InnerClass{
		//1.静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。
		//创建静态嵌套类的实例变量，类变量
		public String Innername="zhagnsan";
		public static int InnerNum=1001;
		//5.静态嵌套类中不能有this.
		//创静态变量
		//创建静态嵌套类的构造方法
		public InnerClass(){
			//2.静态嵌套类中构造方法可以访问本静态嵌套类中的构造方法，
			//实例变量/方法，类变量/方法。
			//静态嵌套类中构造方法访问实例变量
			new InnerClass().Innername="zhagnsansan";
			this.Innername="zhagnsansan";
			//静态嵌套类中构造方法访问类变量
			new InnerClass().InnerNum=1002;
			this.InnerNum=1002;
			//静态嵌套类中构造方法访问构造方法
			new InnerClass(12);
			//静态嵌套类中构造方法访问实例方法
			new InnerClass().InnerShiLi2();
			this.InnerShiLi2();
			//静态嵌套类中构造方法访问类（静态）方法
			new InnerClass().InnerJingTai2();
			this.InnerJingTai2();
			//4.静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，
			//实例变量/方法【只能对象】，类变量/方法。
			//不能使用this，因为这个this指向的是静态嵌套类的对象
			//静态嵌套类中实例方法访问外部类的实例变量
			new TestClass().testname="lisisi";
			//静态嵌套类中实例方法访问外部类的类变量
			new TestClass().testInt=102;
			TestClass.testInt=102;
			//静态嵌套类中实例方法访问外部类的构造方法
			new TestClass("str");
			//静态嵌套类中实例方法访问外部类的实例方法
			new TestClass().TestShiLi();;
			//静态嵌套类中实例方法访问外部类的静态方法
			new TestClass().TestJingTai();
			TestClass.TestJingTai();
		}
		public InnerClass(int int1){}
		//创建静态嵌套类的实例方法
		public void InnerShiLi(){
			//2.静态嵌套类中实例方法可以访问本静态嵌套类中的构造方法，
			//实例变量/方法，类变量/方法。
			//静态嵌套类中实例方法访问实例变量
			new InnerClass().Innername="zhagnsansan";
			this.Innername="zhagnsansan";
			//静态嵌套类中实例方法访问类变量
			new InnerClass().InnerNum=1002;
			this.InnerNum=1002;
			InnerClass.InnerNum=1002;
			//静态嵌套类中实例方法访问构造方法
			new InnerClass(12);
			//静态嵌套类中实例方法访问实例方法
			new InnerClass().InnerShiLi2();
			this.InnerShiLi2();
			//静态嵌套类中实例方法访问类（静态）方法
			new InnerClass().InnerJingTai2();
			this.InnerJingTai2();
			//InnerClass.InnerJingTai();//不能使用类名访问类方法
		}
		public void InnerShiLi2(){}
		//创建静态嵌套类的静态方法
		public void InnerJingTai(){
			//3.静态内部类中类方法可以访问本静态嵌套类中的构造方法，实例变量/方法【只能对象】，类变量/方法.
			//静态嵌套类中类方法访问实例变量
			new InnerClass().Innername="zhagnsansan";
			this.Innername="zhagnsansan";
			//静态嵌套类中类方法访问类变量
			new InnerClass().InnerNum=1002;
			this.InnerNum=1002;
			InnerClass.InnerNum=1002;
			//静态嵌套类中类方法访问构造方法
			new InnerClass(12);
			//静态嵌套类中类方法访问实例方法
			new InnerClass().InnerShiLi2();
			this.InnerShiLi2();
			//静态嵌套类中类方法访问类（静态）方法
			new InnerClass().InnerJingTai2();
			this.InnerJingTai2();
			//InnerClass.InnerJingTai2();//不能使用类名访问类方法
		}
		public void InnerJingTai2(){}
	}
}

package com.wangxing.test3;
public class otherClass {
	public void testmethod(){
		//7.其他类中可以访问静态嵌套类【new 外部类类名.静态嵌套类名()】。注意访问限制修饰符
		new TestClass.InnerClass();
		//静态嵌套类不能使用外部类对象.内部类对象
		//new TestClass().new InnerClass();
	}
}

4.匿名内部类
— 没有名字的Java类，在不用创建新类的情况下，构建出当前类的子类，构建的子类子
        类没有名字，所以叫匿名内部类
基本格式：
                package com.wangxing.test4;
                public class Person {
                            public void personInfo(){
                                        System.out.println(“Person类的实例方法”);
                            }
                 }

                package com.wangxing.test4;
                public class Main {
                            public static void main(String[] args) {
                                        Person per=new Person(){
                                                    public void personInfo(){
                                                        System.out.println(“重写Person类的personInfo方法”);
                                                    }
                                        };
                                        per.personInfo();
                            }
                }

new Person(){
   public void personInfo(){
           System.out.println(“重写Person类的personInfo方法”);
   }
}
上面的代码就是一个匿名内部类的格式，就相当于Person类的子类，只是没有名字，所以叫匿名内部类。

继承式的匿名内部类
例如：

package com.wangxing.test4;
public class testClass {
	public void testinfo(){
		System.out.println("testClass类的实例方法");
	}
}

package com.wangxing.test4;
public class main {
	public static void main(String args[]){
		//1.没有名字的java类,在不用创建出新类的情况下，构建出当前类的子类，
		//构建的子类没有名字，所以叫匿名内部类
		//一般我们需要重写一个类时候需要继承这个类。为了不产生新类我们可以使用匿名内部类
		//得到意义上的父类
		testClass tc =new testClass(){
			public void testinfo(){
				System.out.println("重写testClass类的testinfo法");
			}
		};
		//调用testClass类的匿名内部类的重写方法
		tc.testinfo();
	}
}