有一个编程题:在第一个包中创建一个接口;再第二个包中创建一个类,并包含一个protected的内部类实现那个接口;在第三个包中继承这个类,并在一个方法中返回该pretected内部类的对象,并返回的时候向上转型为第一个包中的接口类型.
我写的代码如下:

第一个包:

1. package ch10.package01;
   
2. public interface QQ {
   
3. void f();
   
4. void u();
   
5. }

复制代码

第二个包:

1. package ch10.package02;
   
2. import ch10.package01.QQ;
   
3. public class Outer01 {
   
4. protected class Inter01 implements QQ{
   
5. public void f(){
   
6. System.out.println("Inter01.f()");
   
7. }
   
8. public void u(){
   
9. System.out.println("Inter02.u()");
   
10. }
    
11. 
    
12. }
    
13. public static void main(String[] args){
    
14. Outer01 o=new Outer01();
    
15. }
    
16. }

复制代码

第三个包:

1. package ch10.package03;
   
2. import ch10.package02.Outer01;
   
3. import ch10.package01.QQ;
   
4. public class Outer02 extends Outer01{
   
5. public QQ qq(){
   
6. return new Inter01();
   
7. }
   
8. }

复制代码

问题在于return new Inter01();这句话提示错误
The constructor Outer01.Inter01() is not visible
虽然内部类是protected的,但Outer02 extends Outer01 为什么还是不可以访问呢?

内部类是protected的，内部类的默认构造函数也是protected的。创建内部类对象调用其构造函数时，由于构造函数被限制起来了，所以创建不了。protected的访问权限是同一个包中被调用或者是该类的子类调用。本例中Outer02继承的是Outer01,而不是Inter01，又是在不同的包中，因此调用不了。

3:权限修饰符
                同一个类中          同一个包中           不同包中的子类中          不同包中
private        OK                               
(default)        OK                         OK
protected        OK                         Ok                            OK
public                OK                         OK                            OK                           OK
你这里的内部类的修饰符protected受保护的。在不同包中的。而且他没有被继承，所有在不同的包中不能用。
他继承的外部类，java中的类时单继承的。所有他虽然是继承了外部类但是并没有继承内部类。

外部类之外创建成员内部类对象
既然是外部类的非静态成员，就必须在外部类对象存在的情况下使用。
基本语法是
<外部类类名>.<内部类类名> 引用变量名称 = <外部类对象的引用>.new <内部类构造器>;
<外部类类名>.<内部类类名> 引用变量名称 = new <外部类构造器>.new <内部类构造器>;
(1)、创建内部类对象时对象引用必须是<外部类类名>.<内部类类名>
(2)、调用内部类的构造方法不能直接用new 而是要用<外部类对象的引用>.new调用
例子：
class Outter {
//非静态内部类
class Inner {
//内部类成员
int i = 12;
public void innerTest() {
System.out.println(“Inner Class Method”);
}
}
//外部类的普通成员
int j = 0;
}
class MainTest {
public static void main(String[] args) {
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();
inner.innerTest();
}
}
在外部类之外访问内部类时需要注意权限修饰符的限制，这点和类成员一样。

周玉龙 发表于 2012-7-24 01:01
3:权限修饰符
                同一个类中          同一个包中           不同包中的子类中          不同包中
private        OK                               

看来还是基本功不扎实啊，谢谢了。