|
锁定老帖子 主题：Java的内部类——你知道多少？
精华帖 (0) :: 良好帖 (1) :: 新手帖 (5) :: 隐藏帖 (6)
|
|
|---|---|
| 作者 | 正文 |
|
发表时间：2011-03-04
haiwoo 写道 最后一个问题就是：怎样写一个匿名的内部类？如果大家搞过Java Swing或者Android开发，这个问题对你来说很简单，因为在随便的一些事件里，你就可以定义一个匿名的内部类，然后实现它的方法。
内部类最大好处 就是保持跟外部类的生命周期一致，可以通过管理一个类的生命周期来维护俩个类的生命周期在线成池 ，连接池 ，通信套接字 是必然用到的。 这些要求内存管理很高的时候，对类的生命是必须负责的 ，但过多的类不好维护，通常为便于方便维护，就将归纳 并放在一起 学习了 |
| 返回顶楼 | |
|
发表时间：2011-03-04
yangguo 写道 天下本不需内部类，庸人自扰之。
同意 貌似最近也被javaeye扣分了... 
|
| 返回顶楼 | |
|
发表时间：2011-03-04
最后修改：2011-03-04
hehez 写道 ricoyu 写道 引用 如果这样写的话，会报编译错误。那么为什么会报错呢？因为在Java的设计中，如果想访问一个类的内部类，你必须通过宿主类去取它，然后，再对它进行操作，Java就是想这样把内部类给封闭起来的，好吧，正确的写法，我给大家贴出来：
以下是内部类的写法： 1 public class MainClass { 2 public InnerClass getInnerClass() { 3 return new InnerClass(); 4 } 5 6 public class InnerClass { 7 public String name = "name"; 8 9 public String getName() { 10 return name; 11 } 12 13 public void setName(String name) { 14 this.name = name; 15 } 16 } 17 } 如果你想访问Java内部类，你必须先拿到它的宿主类，这样你才能对内部类进行操作： 1 public class CheckClass { 2 public static void main(String[] args) { 3 MainClass mainClass = new MainClass(); 4 System.out.println(mainClass.getInnerClass().getName()); 5 } 6 } 这样的话，编译就不会报错了。 不用这么麻烦非要在外围类里面通过方法返回一个内部类的实例吧？ 因为你的内部类是public的， 所以可以这样子写 1 public class CheckClass { 2 public static void main(String[] args) { 3 MainClass main = new MainClass(); 4 MainClass.InnerClass inner = main.new InnerClass(); 5 } 6 } 好的，谢谢 好啥好啊？这样写的话，还要内部类干嘛？直接放在外面分成两个类好了。 这种不伦不类的写法，分明是为了使用内部类而使用内部类。 内部类一般两种用法： 1、内部类为private类型，目的是不被外部发现你用了内部类。 2、static类型，直接 MainClass.InnerClassName 调用。 |
| 返回顶楼 | |
|
发表时间：2011-03-04
内部类在初学java的时候，还好好了解了一下，不过在实际开发中，几年来也没使用过这种！不了解内部类的实用价值
|
| 返回顶楼 | |
|
发表时间：2011-03-04
8830417 写道 xutao5641745 写道 楼主：我觉得你讲这么多还是没有讲清楚到底何时用内部类，何时用静态内部类，何时用匿名内部类，何时用局部类。
能不能讲解下？？？谢谢 我的博客里面写了一篇，但不是很详细，希望对你有帮助！ |
| 返回顶楼 | |
|
发表时间：2011-03-04
最后修改：2011-03-04
1.外部类（非主类）通过怎样的方式访问内部类？
前提是内部类，必须不能被定义成private的，否则外部类无法访问(这跟类里的其他普通属性一样)
public class OuterClass {
public class InnerClass {
}
public static class StaticInnerClass {
}
}
public class TestClass {
public static void main(String[] args) {
OuterClass.InnerClass innerObj = new OuterClass().new InnerClass();
System.out.println(innerObj);
OuterClass.StaticInnerClass staticInnerObj = new OuterClass.StaticInnerClass();
System.out.println(staticInnerObj);
}
}
2.内部类能不能访问主类私有的属性，为什么？ 可以
public class OuterClass {
private String privateOuterField;
private static String privateStaticOuterField;
public class InnerClass {
//访问外部类的非静态变量
public String innerField1 = privateOuterField;//直接访问
public String innerField2 = OuterClass.this.privateOuterField;
//访问外部类的静态变量
public String innerField3 = privateStaticOuterField;//直接访问
public String innerField4 = OuterClass.privateStaticOuterField;
}
public static class StaticInnerClass {
//访问外部类的非静态变量
public String innerField1 = privateOuterField;//不能直接访问（此行编译会报错）
public String innerField2 = new OuterClass().privateOuterField;
//访问外部类的静态变量
public String innerField3 = privateStaticOuterField;//直接访问
public String innerField4 = OuterClass.privateStaticOuterField;
}
}
3.内部类能不能继承别的类和接口？ 肯定能继承别的类，因为所有类首先都是Object的子类 实际上，只要是在宿主类里能访问到的类和接口，都可以让内部类来继承或实现（前提是被继承的类不能使用final定义） public class SupperClass {
}
public interface SuperInterface {
}
public class OuterClass {
public class InnerClass extends SupperClass implements SuperInterface {
}
}
4.内部类能不能是static的？ 可以，见1,2 5.在主类的方法里面可不可以定义内部类？ 这个问题我和LZ理解的有点不一样 LZ理解成能否在主类方法中使用内部类了 我的理解是在在主类function里可不可以有类的定义？答案是可以的 public class OuterClass {
public class InnerClass {
}
public void function() {
class FunctionInnerClass {
}
FunctionInnerClass funInnerClassInstance = new FunctionInnerClass();
System.out.println(funInnerClassInstance);
}
}
public class TestClass {
public static void main(String[] args) {
new OuterClass().function(); // 执行结果：OuterClass$1FunctionInnerClass@1fb8ee3
}
}
6.初始化主类的时候是不是也把内部类给初始化了？为什么？ 比较同意LZ的观点 7.怎样写一个匿名的内部类？ 举个小例子 public class SupperClass {
}
public class OuterClass {
public SuperInterface superInterface = new SuperInterface() {
@Override
public void fun() {
System.out.println(this.getClass());
}
};
}
public class TestClass {
public static void main(String[] args) {
new OuterClass().superInterface.fun(); // 执行结果：class OuterClass$1
}
}
在Swing编程，处理事件的时候，匿名内部类的用法比较常见。 其实多线程里也有这样的用法： public class TestClass {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(this.getClass());
}
}).run(); //运行结果：class TestClass$1
}
}
|
| 返回顶楼 | |
|
发表时间：2011-03-04
ricoyu 写道 每个内部类都能独立地继承自一个实现， 所以无论外围类是否已经继承了某个实现， 对于内部类都没有影响。 即内部类有效地实现了多重继承
谢谢指点 |
| 返回顶楼 | |
|
发表时间：2011-03-04
引用 好啥好啊？这样写的话，还要内部类干嘛？直接放在外面分成两个类好了。
这种不伦不类的写法，分明是为了使用内部类而使用内部类。 你不知道内部类是了解它的外围类的吗？ 为什么说“了解”？ 因为即便是外围类的private字段， 内部类照样可以访问到，所以请教一下把他们分成两个类以后， 拆分出来的内部类如何去访问外部类的属性？ 假设外部类处于安全原因没有提供任何getter/setter方法？ |
| 返回顶楼 | |
|
发表时间：2011-03-04
不够详细，希望能再扩展点.
|
| 返回顶楼 | |
|
发表时间：2011-03-04
akunamotata 写道 yangguo 写道 天下本不需内部类，庸人自扰之。
同意 貌似最近也被javaeye扣分了... 同意 +1 and 扣分 +1 
|
| 返回顶楼 | |
