把一个private内部灯的成员定义为public或private是没什么区别的，那能不能忽略private内部类中实例变量和方法的修饰词public或private呢？
请教各位前辈```

内部类是可以使用private权限的.内部类可以正常调用其它类的方法，属性,也可以正常调用其它类的方法，属性。别人也正常调用它，它的使用和普通的方法，属性一致，我们就把它看做一个普通的方法就行了..  这是我的理解， 我也是刚学没多久。

1. public class Main{
   
2.         public static void main(String[] args) {
   
3.                 //T.Y y = t.new Y();Y不可见
   
4.                 T t = new T();
   
5.                 //t.TI();TI方法不可见
   
6.                 t.h();//此方法可见，这个方法里调用了这里不可见的内部类的方法，这就是内部类!
   
7.         }
   
8. }
   
9. class T{
   
10.         public void h(){
    
11.                 Y y = new Y();
    
12.                 y.f();//对此类来说，内部类永远可见
    
13.                 y.ff();//内部类中的私有方法在这里也可见
    
14.         }
    
15.         private void TI(){
    
16.                 System.out.println("T private function");
    
17.         }
    
18.         private class Y{
    
19.                 public void f(){
    
20.                         System.out.println("dd");
    
21.                 }
    
22.                 private void ff(){
    
23.                         System.out.println("fff");
    
24.                 }
    
25.         }
    
26. }
    
27. //输出：
    
28. //dd
    
29. //fff

复制代码

注意使用范围，如果是缺省内部类，只能在包内使用使用，如果是public或者是protected则可以在任何子类内使用内部类，如果是public static,则内部类上升为外部类。如果仅仅只是static则内部类上升为包内范围的外部类。  所以  内部类是可以被外面其他类所使用的  既然可以被其他类所使用  你当然可以使用private来保护你内部类中的东西  结论：不能忽略内部类中的private 和 public

1. 
   
2. class Outer
   
3. {
   
4.         private int size=3;
   
5.          class Inner
   
6.         {
   
7.                  void dostuff()
   
8.                 {
   
9.                         size++;
   
10.                         System.out.println(size);
    
11.                         PrivateText t= new PrivateText();
    
12.                         t.dostuff1();
    
13.                        
    
14.                 }
    
15.         }
    
16.         private class PrivateText//内部类使用了private权限之后，内部类中的成员不可以被其他类进行访问
    
17.         {
    
18.                 private  void dostuff1()//加上private与不加private，一个内中的类部类均可以进行访问，所以这里private是可以忽略的
    
19.                 {
    
20.                         size++;
    
21.                         System.out.println(size);
    
22.                 }
    
23.         }
    
24. }
    
25. class TextInner
    
26. {
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 Outer o=new Outer();
    
30.                 Outer.Inner oi=o.new Inner();
    
31.                 oi.dostuff();
    
32.         }
    
33. }
    
34. /*输出结果为
    
35. 4
    
36. 5
    
37. */
    

复制代码