内部类
之前类中可有变量和方法，今天开始在类中在添加一个元素类。
内部类---包含在类中的类就是内部类
外部类---包含内部类的类就是外部类
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 Test1;
public class TestClass {
//外部类构造方法
public TestClass(){
new InnerClass();
new InnerClass().shiLi();
//InnerClass.this.shiLi();//错误
//this.shiLi();//错误
//shiLi();//错误
new InnerClass().id=1000001;
//InnerClass.this.id=10001;//错误
//this.id=10001;//错误
//id=10001;//错误
}
//外部类实例方法
public void waibuShiLi(){
new InnerClass();
new InnerClass().shiLi();
//InnerClass.this.shiLi();//错误
//this.shiLi();//错误
//shiLi();//错误
new InnerClass().id=10000001;
//InnerClass.this.id=10001;//错误
//this.id=10001;//错误
//id=10001;//错误
}
//外部类静态方法
public static void waibuJingTai(){
//new InnerClass();//错误
//new InnerClass().shiLi();//错误
//InnerClass.this.shiLi();//错误
//this.shiLi();//错误
//shiLi();//错误
//new InnerClass().id=10000001;//错误
//InnerClass.this.id=10001;//错误
//this.id=10001;//错误
//id=10001;//错误
}
//外部类实例变量
public int num=100;
//外部类静态变量
public static String name="张三";
//成员内部类
public class InnerClass{
//实例变量
public int id=1001;
//static int id1=1002;//错误
//实例方法
public void shiLi(){}
//构造方法
public InnerClass(){}
//带参数构造方法
public InnerClass(String name){
//访问其他构造的方法
new InnerClass();
//访问实例变量/方法---对象.实例变量/方法，this.实例变量/方法【可以省略对象/this】
new InnerClass().id=1002;
this.id=1003;
id=1004;
new InnerClass().shiLi();
this.shiLi();
shiLi();
//成员内部类中的构造方法可以访问外部类的构造方法，实例方法/变量，类方法/变量
new TestClass();
new TestClass().waibuShiLi();
//TestClass.this表示外部类对象
TestClass.this.waibuJingTai();
//静态方法可以用类名调用
TestClass.waibuJingTai();
TestClass.this.num=1002;
TestClass.this.name="李四";
TestClass.name="王五";
}
//实例方法
public void shiLi2(){
//访问构造的方法
new InnerClass();
//访问其他实例变量/方法---对象.实例变量/方法，this.实例变量/方法【可以省略对象/this】
new InnerClass().id=1002;
this.id=1005;
id=1006;
new InnerClass().shiLi();
this.shiLi();
shiLi();
//成员内部类中的实例方法可以访问外部类的构方法，实例方法/变量，类方法/变量。
new TestClass();
new TestClass().waibuShiLi();
TestClass.this.waibuJingTai();
TestClass.waibuJingTai();
TestClass.this.num=1003;
TestClass.this.name="赵六";
}
}
}
package Test1;
public class OtherClass {
public OtherClass(){
TestClass tc=new TestClass();
TestClass.InnerClass inner1=tc.new InnerClass();
TestClass.InnerClass inner2=new TestClass().new InnerClass();
inner1.id=1001;
inner2.shiLi2();
}
public void testOther(){
TestClass tc=new TestClass();
TestClass.InnerClass inner1=tc.new InnerClass();
TestClass.InnerClass inner2=new TestClass().new InnerClass();
inner1.id=1001;
inner2.shiLi2();
}
public static void testOtherStatic(){
TestClass tc=new TestClass();
TestClass.InnerClass inner1=tc.new InnerClass();
TestClass.InnerClass inner2=new TestClass().new InnerClass();
inner1.id=1001;
inner2.shiLi2();
}
}
2.方法内部类---定义在方法中的类，相当于局部变量
基本格式：
package Test2;
public class TestClass {
public TestClass(){
class InnerClass1{
}
}
public void testMethod(String canshu){
class InnerClass2{
}
}
public static void testMethod2(String canshu){
class InnerClass3{
}
}
}
1.方法内部内不能使用认识访问限制修饰符
2.方法内部类可以有实例变量/方法，构造方法，不能有静态元素。
3.方法内部类的构造方法中可以访问本方法内部类中的构造方法，实例变量/方法【对象/this，也可以省略】
4.方法内部类的实例方法中可以访问本方法内部类中的构造方法，实例变量/方法【对象/this，也可以省略】
5.方法内部类中的构造方法/实例方法中可以访问本方法的局部变量，默认会使用final修饰局部变量和【直接变量名称】
6.方法内部类可以访问外部类的构造方法，实例方法/变量，类方法/变量。
7.外部类是不能访问方法内部类。
package Test2;
public class TestClass {
public TestClass(){}
public void testMethod1(){}
public static void testStatic(){}
String testname1="zhangsan";
static int idd=10001;
public void testMethod(String canshu){
String testname="张三";
//方法内部类---定义在方法中的类，相当于局部变量
//方法内部类不能使用认识访问限制修饰符
//方法内部类可以有实例变量/方法，构造方法，不能有静态元素。
class InnerClass{
private int id=1001;
//private static String name="zhangsan";//错误
public InnerClass(){}
public InnerClass(String name){
new InnerClass();
new InnerClass().id=1002;
this.id=1002;
new InnerClass().innerShili();
this.innerShili();
id=1003;
//方法内部类访问本方法的局部变量时，方法内部类会默认使用final修饰符修饰
//final修饰符修饰的变量不能被重新赋值
//testname="lisisi";//错误
System.out.println(testname);
//访问外部类实例变量
new TestClass();//访问外部类构造方法
new TestClass().testname1="lisi";
TestClass.this.testname1="wangwu";
testname1="zhaoliu";
//访问外部类静态变量
new TestClass();
new TestClass().idd=10002;
TestClass.this.idd=10003;
idd=10003;
//访问外部类实例方法
new TestClass().testMethod1();
TestClass.this.testMethod1();
testMethod1();
//访问外部类静态方法
new TestClass().testStatic();
TestClass.this.testStatic();
TestClass.testStatic();
testStatic();
}
public void innerShili(){}
//public static void innerJingtai(){}//错误
public void innerShili2(){
new InnerClass();
new InnerClass().id=1004;
this.id=1005;
id=1006;
new InnerClass().innerShili();
this.innerShili();
innerShili();
}
}
}
}
3.静态嵌套类---相当于java类中的静态变量
基本格式
package Test3;
public class TestClass {
public static class InnerClass{
}
}
1.静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法。
2.静态嵌套类中构造方法/实例方法可以访问本静态嵌套类中的构造方法，实例变量/方法，类方法/变量。
3.静态内部类中类方法可以访问本静态嵌套类中的构造方法，实例方法/变量【只能对象】，类变量/方法
4.静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例变量/方法【只能对象】，类变量/方法。
5.静态嵌套类中不能有this
6.外部类的构造方法/实例方法/类方法可以访问，静态内部类中构造方法，实例变量/方法【只能对象】，类变量/方法。
7.其他类中可以访问静态嵌套类【new 外部类类名.嵌套类类名()】。注意访问限制修饰符
例如：
package Test3;
public class TestClass {
//外部类实例变量
int idd=001;
//外部静态变量
static String name2="张三";
//外部类构造方法
public TestClass(){
new InnerClass();
new InnerClass().id=1002;
//InnerClass.this.id=1003;//错误
new InnerClass().name="李四";
InnerClass.name="李四";
//name="李四";//错误
new InnerClass().testShili();
new InnerClass().testJingtai();
InnerClass.testJingtai();
//testJingtai();错误
}
//外部类实例方法
public void testShili3(){
new InnerClass();
new InnerClass().id=1002;
//InnerClass.this.id=1003;//错误
new InnerClass().name="李四";
InnerClass.name="李四";
//name="李四";//错误
new InnerClass().testShili();
new InnerClass().testJingtai();
InnerClass.testJingtai();
//testJingtai();错误
}
//外部类静态方法
public static void testJingtai3(){
new InnerClass();
new InnerClass().id=1002;
//InnerClass.this.id=1003;//错误
new InnerClass().name="李四";
InnerClass.name="李四";
//name="李四";//错误
new InnerClass().testShili();
new InnerClass().testJingtai();
InnerClass.testJingtai();
//testJingtai();错误
}
//静态嵌套类中可以有构造方法，实例变量/方法，类变量/方法
public static class InnerClass{
//实例变量
int id=1001;
//静态变量
static String name="张三";
//构造方法
public InnerClass(){}
//实例方法
public void testShili(){}
//静态方法
public static void testJingtai(){}
//静态嵌套类中的构造方法/实例方法可以访问本静态嵌套类中的构方法，实例变量/方法，类变量/方法
//构造方法
public InnerClass(String name2){
new InnerClass();
new InnerClass().id=1002;
this.id=1003;
id=1004;
new InnerClass().name="李四";
this.name="王五";
name="赵六";
InnerClass.name="张三三";
new InnerClass().testShili();
this.testShili();
testShili();
new InnerClass().testJingtai();
this.testJingtai();
testJingtai();
//静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例方法/变量【只能对象】，类方法/变量
new TestClass();
new TestClass().idd=002;
//TestClass.this.idd=002;//错误
//idd=002;//错误
new TestClass().name2="李四";
//TestClass.this.name2="李四";//错误
name2="李四";
TestClass.name2="李四";
new TestClass().testShili3();
//TestClass.this.testShili2();//错误
//testShili3();//错误
new TestClass().testJingtai3();
//TestClass.this.testJingtai3();//错误
testJingtai3();
TestClass.testJingtai3();
}
//实例方法
public void testShili2(){
new InnerClass();
new InnerClass().id=1002;
this.id=1003;
id=1004;
new InnerClass().name="李四";
this.name="王五";
name="赵六";
InnerClass.name="张三三";
new InnerClass().testShili();
this.testShili();
testShili();
new InnerClass().testJingtai();
this.testJingtai();
testJingtai();
//静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例方法/变量【只能对象】，类方法/变量
new TestClass();
new TestClass().idd=002;
//TestClass.this.idd=002;//错误
//idd=002;//错误
new TestClass().name2="李四";
//TestClass.this.name2="李四";//错误
name2="李四";
TestClass.name2="李四";
new TestClass().testShili3();
//TestClass.this.testShili2();//错误
//testShili3();//错误
new TestClass().testJingtai3();
//TestClass.this.testJingtai3();//错误
testJingtai3();
TestClass.testJingtai3();
}
//静态方法
public static void testJingtai2(){
new InnerClass();
new InnerClass().id=10001;
//this.id=10002;//错误
//id=10002;//错误
new InnerClass().name="张三三";
//this.name="李四四";//错误
name="李四四";
InnerClass.name="王五五";
new InnerClass().testShili();
new InnerClass().testJingtai();
testJingtai();
InnerClass.testJingtai();
//静态内部类中的构造方法/实例方法/类方法可以访问外部类的构造方法，实例方法/变量【只能对象】，类方法/变量
new TestClass();
new TestClass().idd=002;
//TestClass.this.idd=002;//错误
//idd=002;//错误
new TestClass().name2="李四";
//TestClass.this.name2="李四";//错误
name2="李四";
TestClass.name2="李四";
new TestClass().testShili3();
//TestClass.this.testShili2();//错误
//testShili3();//错误
new TestClass().testJingtai3();
//TestClass.this.testJingtai3();//错误
testJingtai3();
TestClass.testJingtai3();
}
}
}
package Test3;
public class OtherClass {
//其他类可以访问静态嵌套类【new 外部类类名.静态嵌套类类名()】。注意访问修饰符
public void testMethod(){
TestClass.InnerClass ti=new TestClass. InnerClass();
ti.id=1001;
ti.testShili();
ti.name="张三";
ti.testJingtai();
TestClass.InnerClass.testJingtai();
TestClass.InnerClass.name="李四";
}
}
4.匿名内部类---没有名字的java类，在不用创建新类的情况下，构建出当前类的子类，构建子类没有名字，所以叫匿名内部类
基本格式
package Test4;
public class Person {
public void personInfo(){
System.out.println("Person类的实例方法");
}
}
package Test4;
public class TestMain {
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.printn("重写Person类的personInfo方法");
}
};
上面的代码就是一个匿名内部类的格式，就相当于Person类的子类，只是没有名字，所以叫匿名内部类。
继承式的匿名内部类
例如：
package Test5;
public abstract class Person {
public abstract void perinfo();
}
package Test5;
public class TestClass {
public void testClassSshili(Person per){
per.perinfo();
}
}
package Test5;
public class TestMain {
public static void main(String[] args) {
TestClass tc=new TestClass();
tc.testClassSshili(new Person(){
@Override
public void perinfo() {
System.out.println("重写抽象类的抽象方法");
}
});
}
}
接口式的匿名内部类
例如：
package Test6;
public interface Person {
void test1();
}
package Test6;
public class TestClass {
public void shiliMethod(Person name){
name.test1();
}
}
package Test6;
public class TestMain {
public static void main(String[] args) {
TestClass tc=new TestClass();
tc.shiliMethod(new Person(){
@Override
public void test1() {
System.out.println("重写接口的抽象方法");
}
});
}
}
优点：避免创建额外的独立子类
缺点：不易理解，不易阅读
