Java 内部类,成员类,局部类,匿名类等

时间：2019-11-30 16:20:15 阅读：74 评论：0 收藏：0 [点我收藏+]

根据内部类的位置不同，可将内部类分为
1. 成员内部类
2. 局部内部类

class C{
    //成员内部类
    class B{
    }

    public void show1() {
    //局部内部类
        class D{
        }
    }
}

成员内部类

成员内部类的访问格式：

1 外部类名.内部类名 对象名=外部类对象.内部类对象

 1 class C{ 
 2 
 3 　　//成员内部类
 4  　　class B{
 5          public void show() 
 6          { 
 7             System.out.println("你好"); 
 8 　　　　　} 
 9  } 
10 } 
11 public class niming { 
12   public static void main(String[]args) { 
13 
14 //创建对象访问对应内部类函数成员 
15 C.B b=new C().new B(); 
16 b.show(); } 
17 }

虽然内部类可以以上述方式访问，但实际开发中，常将内部设为私有成员，以保护数据的安全，不让外部直接使用
1. 将内部类设为私有成员

 1 class C{
 2  //成员内部类,设为私有
 3  private class B{
 4      public void show() 
 5      { 
 6         System.out.println("你好"); } 
 7     }
 8    public void show1() { 
 9      B b=new B(); 
10      b.show(); } 
11    } 
12   public class niming { 
13       public static void main(String[]args) {
14          //创建对象访问对应内部类函数成员
15          C c=new C();
16         c.show1(); 
17        } 
18    }
19

2. 将内部类设为静态类

特定：静态内部类访问外部类成员时，只能访问外部类的静态成员

 1 class C{ 
 2     //静态成员变量 
 3     private static int num=20; 
 4     //静态成员方法 
 5     public static void show2() { 
 6         System.out.println("hello world");
 7      } 
 8     //成员内部类,设为私有静态 
 9     private static class B{ 
10     public void show() { 
11         System.out.println(num); 
12         show2(); 
13         } 
14     } 
15     public void show1() {
16      B b=new B();
17      b.show(); 
18     } 
19 }
20  public class niming {
21      public static void main(String[]args) {
22      //创建对象访问对应内部类函数成员 
23     C c=new C(); 
24     c.show1(); 
25     } 
26 }

Private 保证了数据的安全
Static 让数据访问更方便

 1 class Outer { 
 2 public int num = 10; 
 3 class Inner { 
 4 public int num = 20; 
 5 public void show() {
 6  int num = 30; 
 7 //三个变量对应的变量名相同
 8  //访问的是本方法中的num变量，满足就近原则 
 9 System.out.println(num); 
10 //通过this变量，访问方法外，本类中的变量，this代表Inner类对象 
11 System.out.println(this.num); 
12 //通过外部类名加this，返回外部类对象，访问对象外部类的
13 num System.out.println(Outer.this.num);
14 //通过创建对象的方式访问外部成员变量不推荐 
15 //System.out.println(new Outer().num); }
16 }
17  } 
18  public class niming { 
19 public static void main(String[]args) { 
20  Outer.Inner inner=new Outer().new Inner(); 
     inner.show(); 
21 } 
22 }

局部内部类

可以直接访问外部类的成员

public class Outer{ 
    public void inner(){

	System.out.println("局部内部类"); 
        final int num = 5; 
     	class InnerClass{ 
        
	    private int num = 4; //内部类的类体中不可以声明类变量和类方法
            public void testNum()
	    { 
               System.out.println(this.num); 
            }
        }
        
         InnerClass a=new InnerClass();
          a.testNum();
        
    
   }
   public static void main(String[]args) {

	Outer c= new Outer();
        c.inner();
       
  }
}

public class Outer{ 

     int num = 5; 
    public void inner(){

	System.out.println("局部内部类"); 
        
     	class InnerClass{ 
        
	    private int num2 = 4; 
            public void testNum()
	    { 
               System.out.println(num); 
            }
        }
        
         InnerClass a=new InnerClass();
          a.testNum();
        
    
   }
   public static void main(String[]args) {

	Outer c= new Outer();
        c.inner();
       
  }
}

输出：

技术分享图片