全部展开
下段：见《内部类》
内部类是3231313353236313431303231363533 e 4b 893 e 5b 19e 3133262353462在外部类内部定义的另一个类。 内部类是外部类的成员，依赖于外部类而存在。 内部类是静态的，可以用protected和private限定。 另一方面，外部类只能使用公共和缺省包访问权限。 内部类主要包括成员内部类、本地内部类、静态内部类和匿名内部类
为什么需要内部班？
通常，内部类是从类或接口继承的，内部类的代码操作会创建其外围类的对象。 可以认为内部类为进入其周边类提供了窗口。 使用内部类最吸引人的原因是：
因为每个内部类都可以独立地继承一个(接口的)实现，所以无论是否继承了接口的(已经有外围类的)实现，内部类都没有影响。 如果不能继承内部类提供的多个具体或抽象类，一些设计和编程问题就很难解决。 从这个角度看，内部类完善多重继承的解决方案。 接口解决了部分问题，但内部类有效地实现了“多重继承”。
答：成员内部类
作为外部类的成员存在，与外部类的属性、方法并列。
公共类输出器{
私有状态=1；
私有Intj=10；
隐私in tk=20；
publicstaticvoidouter_f1 (
}
公共void outer _ F2 (
}
//成员内部类无法定义静态成员
//成员内部类允许访问外部类的所有成员
类inner {
//static int inner_i=100； //不允许在内部类中定义静态变量
intj=100； //内部类和外部类的实例变量可以共存
intinner_i=1；
void inner_f1 (
system.out.println(I；
//在内部类中访问内部类自身的变量时直接使用变量名
system.out.println(j；
//在内部类中访问内部类自身的变量也是this .变量名称
system.out.println(this.j )；
//要访问内部类中与外部类中的内部类同名的实例变量，请使用外部类名. this .变量名称
系统. out.println (outer.this.j；
//如果内部类中没有与外部类同名的变量，则可以通过变量名称直接访问外部类变量
system.out.println(k；
outer_f1 (；
outer_f2 (；
}
}
//外部类的非静态方法访问成员内部类
公共void outer _ F3 (
Inner inner=new Inner (；
inner.inner_f1 (；
}
//外部类的静态方法访问成员内部类与在外部类外部访问成员内部类相同
publicstaticvoidouter_f4 (
//step1创建外部类对象
Outer out=new Outer (；
//step2从外部类对象创建内部类对象
Inner inner=out.new Inner (；
//step3如何访问内部类
inner.inner_f1 (；
}
publicstaticvoidmain (字符串[ ] args ) {
//outer_f4 (； //此语句的输出结果与以下三个语句的输出结果相同
//如果要直接创建内部类的对象，当然不认为命名外围类的Outer就可以了。
//可以像通常那样生成内部类的对象，必须使用其周边类的一个对象来生成
//创建其内部类的对象：
//outer.inne routin=out.new inner (
//因此，除非您已经有外围类对象，否则无法生成内部类对象。 因为
//内部类中的对象将偷偷链接到创建该对象的外围类中的对象。 如果使用静态的内部类
//它不需要对其外围类对象的引用。
Outer out=new Outer (；
Outer.Inner outin=out.new Inner (；
outin.inner_f1 (；
}
}
注意：内部类是编译时的概念，成功编译后会形成两个完全不同的类。 对于名为outer的外部类及其内部定义的名为inner的内部类。 编译完成后将显示outer.clas
s和outer$inner.class两类。B:局部内部类
在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。
publicclass Outer {
privateints = 100;
privateintout_i = 1;
publicvoid f(finalint k) {
finalint s = 200;
int i = 1;
finalint j = 10;
//定义在方法内部
class Inner {
ints = 300;// 可以定义与外部类同名的变量
// static int m = 20;//不可以定义静态变量
Inner(int k) {
inner_f(k);
}
intinner_i = 100;
voidinner_f(int k) {
//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
System.out.println(out_i);
//可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
System.out.println(j);
//System.out.println(i);
//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
System.out.println(s);
//用this.变量名访问的也是内部类变量
System.out.println(this.s);
//用外部类名.this.内部类变量名访问的是外部类变量
System.out.println(Outer.this.s);
}
}
new Inner(k);
}
publicstaticvoid main(String[] args) {
// 访问局部内部类必须先有外部类对象
Outer out = new Outer();
out.f(3);
}
}
C：静态内部类(嵌套类)：(注意：前两种内部类与变量类似，所以可以对照参考变量)
如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类(nested class)。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：
1. 要创建嵌套类的对象，并不需要其外围类的对象。
2. 不能从嵌套类的对象中访问非静态的外围类对象。
publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
publicstaticvoidouter_f1() {
}
publicvoidouter_f2() {
}
// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
staticclass Inner {
staticintinner_i = 100;
intinner_j = 200;
staticvoidinner_f1() {
//静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
System.out.println("Outer.i" + i);
outer_f1();
}
voidinner_f2() {
// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
// System.out.println("Outer.i"+j);
// outer_f2();
}
}
publicvoidouter_f3() {
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}
publicstaticvoid main(String[] args) {
newOuter().outer_f3();
}
}
生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则)
已赞过
已踩过<
你对这个回答的评价是？
评论
收起