JAVA学习*内部类
内部类
内部类就是在类中在定义一个类。内部类分为四种。
实例内部类
代码展示：
public class OutClass {
public int num1 = 1;
private int num2 = 2;
public static final int NUM3 = 3;
public void test() {
System.out.println("调用OutClass类的test方法");
}
//定义内部类
class InnerClass {
public int num1 = 1111;
public int num4 = 4;
private int num5 = 5;
public static final int NUM6 = 6;
public void innertest1() {
System.out.println("调用InnerClass类的innertest1普通方法");
System.out.println(num1);
System.out.println(this.num1);
System.out.println(OutClass.this.num1);
System.out.println(num2);
System.out.println(OutClass.NUM3);
System.out.println(num4);
System.out.println(num5);
System.out.println(InnerClass.NUM6);
System.out.println(OutClass.InnerClass.NUM6);
}
public static void innertest2() {
System.out.println("调用InnerClass类的innertest2静态方法");
}
}
}
public class Test {
public static void main(String[] args) {
OutClass.InnerClass.innertest2();
System.out.println("--------------");
OutClass outClass = new OutClass();
//实例化 实例内部类的对象；需要外部类对象进行引用outClass.new InnerClass()
OutClass.InnerClass innerClass = outClass.new InnerClass();
//OutClass.InnerClass innerClass = new OutClass().new InnerClass();
innerClass.innertest1();
}
}
输出：
调用InnerClass类的innertest2静态方法
--------------
调用InnerClass类的innertest1普通方法
1111
1111
1
2
3
4
5
6
6
代码解释：
1、创建实例内部类对象
实例内部类依赖于外部类的实例存在，所以要先创建外部类的对象（new OutClass()）。通过外部类实例来创建成员内部类的对象。
OutClass outClass = new OutClass();
OutClass.InnerClass innerClass = outClass.new InnerClass();
OutClass.InnerClass innerClass = new OutClass().new InnerClass();
2、实例内部类的成员与外部成员
根据输出结果我们知道：
1、调用实例内部类的静态成员，需要引用两次。
外部类名.内部类名.成员
OutClass.InnerClass.innertest2();
2、当实例内部类成员名与外部类重名时，在内部类调用是优先访问内部类的成员。
System.out.println(num1);
System.out.println(this.num1);
这里单纯用this是无法访问外部类同名成员。
为了访问外部类的成员，还需要加上外部类类名。
System.out.println(OutClass.this.num1);
3、实例内部类也受public、private等访问修饰限定符的约束。
静态内部类
代码展示：
public class OuterClass {
public int num1 = 1;
private int num2 = 2;
public static final int NUM3 = 3;
public void test() {
System.out.println("调用OuterClass类的test方法");
}
//静态内部类
static class InnerClass {
public int num1 = 1111;
public int num4 = 4;
private int num5 = 5;
public static final int NUM6 = 6;
public void innertest1() {
System.out.println("调用InnerClass类的innertest1普通方法");
System.out.println(num1);
System.out.println(this.num1);
//System.out.println(OuterClass.this.num1);//报错
//System.out.println(num2);//报错
System.out.println(OutClass.NUM3);
}
}
}
public class Test {
public static void main(String[] args) {
test2();
}
public static void test2() {
OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
innerClass.innertest1();
}
}
输出：
调用InnerClass类的innertest1普通方法
1111
1111
3
代码解释：
1、创建内部类实例对象
创建静态内部类对象时，不需要先创建外部类的对象，可直接通过外部类名来访问静态内部类并创建其对象。
OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
2、静态内部类的成员与外部成员
因为是静态的，所以不能访问外部类当中非静态的成员变量。
3、静态内部类也受public、private等访问修饰限定符的约束。
匿名内部类
代码展示：
interface ID {
void TEST();
}
public class Anonymous {
public static int a=10;
public void test() {
System.out.println("Anonymous类的test方法被调用");
a = 20;
}
public static void main(String[] args) {
Test1();
System.out.println("---------");
Test2();
}
public static void Test2() {
//定义匿名内部类
new ID(){
@Override
public void TEST() {
System.out.println("重写接口的方法");
}
}.TEST();
}
public static void Test1() {
//定义匿名内部类
new Anonymous(){
public static int b = 10;
//b = 1;//报错
@Override
public void test() {
a = 20;//没报错
b = 20;//没报错
System.out.println("重写的test方法被调用");
}
}.test();
}
}
代码解释：
1、它没有类名，在声明的同时完成实例化。通常用于创建只需要使用一次的类的实例。
2、上述代码我们可以简单理解为 new Anonymous(){};继承了Anonymous这个类，所以可以重写test方法。
Anonymous a = new Anonymous(){
@Override
public void test() {
System.out.println("重写的test方法被调用");
}
};
a.test();
这样写也是可以的。
3、也可以是接口使用。上述代码我们可以简单理解为 new ID(){};实现了ID接口，所以要重写TEST方法。
4、在 Java 匿名内部类中，若要访问局部范围数据，只能是常量和未被改变的量（即使没有显式声明为 final，只要局部变量在匿名内部类使用前未被重新赋值，也可访问）。
局部内部类
代码展示：
public class Out {
public int num1 = 1;
public void test() {
//定义局部内部类
class innerClass {
int num2 = 10;
void func() {
System.out.println("调用局部内部类func方法");
}
}
innerClass innerclass = new innerClass();
System.out.println(innerclass.num2);
innerclass.func();
}
}
public class Test {
public static void main(String[] args) {
test3();
}
public static void test3() {
Out out = new Out();
out.test();
}
}
代码解释：
1、局部内部类只能在外部类的成员方法中定义、使用。
2、不能被public、static等修饰符修饰
3、使用的很少
原文地址：https://blog.csdn.net/2401_87791120/article/details/146439972
免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！