class Outer
{
        private class Inner
        {
                public  void show()
                {
                     System.out.println("Inner");
                }
        }
        public Inner getInner()
        {
            Inner in=new Inner();
                return in;
        }
}
class InnerTest
{
        public static void main(String[] args)
        {
             Outer out=new Outer();
                 out.getInner().show();
        }
}
问题：内部类被private修饰后，为什么这个小程序在编译时报错  求解

访问权限问题，你的内部类被private修饰了以后，只在本类内有效。当然不能在其他类中访问创建对象了。把内部类当作类中的成员对待，你就会明白了。

赵崇友 发表于 2013-5-29 19:19
访问权限问题，你的内部类被private修饰了以后，只在本类内有效。当然不能在其他类中访问创建对象了。把内 ...

我是在Outer中的getInner（）方法中创建Inner的实例对象的啊

java.exe 发表于 2013-5-29 19:25
我是在Outer中的getInner（）方法中创建Inner的实例对象的啊

嗯嗯，，按道理讲应该是可以的。我这编译的时候，提示Out.Inner 不可访问。就是访问权限的问题，具体啥原因我也跪了。。。。

楼主的程序main方法又重新定义了一个类，在另一个类中访问private成员，不管是成员变量还是类，都是不能实现的。
其实楼主要访问private内部类中的方法可以这样
class test
{
       private static class Inner
        {
                public static  void show()
                {
                     System.out.println("Inner");
                }
        }

        public static void main(String[] args)
        {
         Inner.show();
        }
}
可以如下实现
class test
{
       private static class Inner
        {
                public static  void show()
                {
                     System.out.println("Inner");
                }
        }
       public Inner get()
       {
        Inner in=new Inner();
        return in;
       }
//再定义一个访问内部类中方法的。。。。。方法
       public void getShow()
        {
                get().show();
        }
}

private在别的类中都是不可见的

我的理解是，Inner被私有后，外部其他类中是不能直接访问被私有的内部类方法。必须提供方法
下面是我的解决办法

1. class Outer
   
2. {
   
3.         private class Inner
   
4.         {
   
5.                 private void show()
   
6.                 {
   
7.                      System.out.println("Inner");
   
8.                 }
   
9.         }
   
10.         public Inner getInner()
    
11.         {
    
12.             Inner in=new Inner();                       
    
13.                 return in;
    
14.         }
    
15.                
    
16.         public void getShow()
    
17.         {
    
18.                 getInner().show();
    
19.         }
    
20.                
    
21. }
    
22. class InnerTest
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26.              Outer out=new Outer();
    
27.              out.getShow();
    
28.         }
    
29. }

复制代码

看看吧，这样可以！

1. package cn.edu.zzu.day1;
   
2. 
   
3. 
   
4. class Outer
   
5. {
   
6.         private class Inner
   
7.         {
   
8.                 public  void show()
   
9.                 {
   
10.                      System.out.println("Inner");
    
11.                 }
    
12.         }
    
13.         /*Inner getInner()
    
14.         {
    
15.             Inner in=new Inner();
    
16.                 return in;
    
17.         }*/
    
18.         
    
19.         public void getShow(){
    
20.                
    
21.                 new Inner().show();
    
22.         }
    
23. }
    
24. 
    
25. public class OuterIner {
    
26. 
    
27.         /**
    
28.          * @param args
    
29.          */
    
30.         public static void main(String[] args) {
    
31.                 // TODO Auto-generated method stub
    
32.                  Outer out=new Outer();
    
33.                  out.getShow();
    
34.         }
    
35.        
    
36. 
    
37. }
    

复制代码

注意：默认的构造函数修饰符和类的修饰符保持一致。此内部类为私有，则默认的构造函数私有，所以无法在类外创建该内部类的对象。

感觉说的都不是重点呢！！我回去翻翻书本看看有没有相关的解释！！这个问题还真头疼……

赵崇友 发表于 2013-5-29 23:45
感觉说的都不是重点呢！！我回去翻翻书本看看有没有相关的解释！！这个问题还真头疼…… ...

恩，一块儿再研究研究，有结果了分享一下啊

java.exe 发表于 2013-5-30 10:42
恩，一块儿再研究研究，有结果了分享一下啊

今天翻了下Thinking in Java那本书，不知道你又没有（P194，10.4 内部类与向上转型）。里面有涉及到这部分知识；我的理解是：当内部类对象被私有话了以后，仅在外部类中可以访问它，你的代码中是在外部类方法中实例化了一个内部类对象，返回的其实是内部类的一个引用。在外部其他类中引用内部类其实是Out.Inner，而Inner类被私有了以后，在外部其他类当中是看不到有Inner类存在的，即不能访问内部类的名字，所以在编译器的时候， 在InnerTest类中out.getInner()这个语句返回的是一个内部类的引用，而此时内部类不可见，这才报编译时错误。
回想一下单例设计，是将构造函数私有，我们在别的类中不能new一个此类对象，是因为这个构造函数对于其他类是不可见的，这时候我们只能同过一个getInstance方法返回一个此类对象，返回的其实也是一个引用，这个引用指向的是此类的对象，注意这个类的权限要么是public的要么就是默认包访问权限，所以这里通过getInstance方法可以返回此类对象的一个引用。
注意下这两种情况的不同之处，其实就是访问权限的问题。
总结，当一个内部类的访问权限为私有的时候，我们只可以在这个类的外部类中使用该对象的引用，而在别的外部其他类中是不能访问的。原因：在外部类其他类看来，根本看不到有这个内部类的存在，所以在外部其他类中使用这个内部类引用会出现Out.Inner不可访问提示。

薛飞 发表于 2013-5-29 20:41
注意：默认的构造函数修饰符和类的修饰符保持一致。此内部类为私有，则默认的构造函数私有，所以无法在类外 ...

构造函数私有，可以通过别的方法实例化内部类对象。看下面的代码：

1. interface Show{
   
2.         void show();
   
3. }
   
4. 
   
5. class Outer
   
6. {
   
7.          private class Inner implements Show
   
8.         {
   
9.                 public  void show()
   
10.                 {
    
11.                      System.out.println("Inner");
    
12.                 }
    
13.         }
    
14.        public Show getInner()
    
15.         {
    
16.             Inner in=new Inner();
    
17.                 return in;
    
18.         }
    
19. }
    
20. public class InnreTest
    
21. {
    
22.         public static void main(String[] args)
    
23.         {
    
24.              Outer out=new Outer();
    
25.                 out.getInner().show();
    
26.         }
    
27. }

复制代码

赵崇友 发表于 2013-5-30 17:36
今天翻了下Thinking in Java那本书，不知道你又没有（P194，10.4 内部类与向上转型）。里面有涉及到这部 ...

啊 明白了 高手！！谢了

赵崇友 发表于 2013-5-30 17:36
今天翻了下Thinking in Java那本书，不知道你又没有（P194，10.4 内部类与向上转型）。里面有涉及到这部 ...

OkOk，多谢，测试了一下，明白了，呵呵