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

根据内部类的位置不同，可将内部类分为 :成员内部类与局部内部类。

class outer{
    class inner{//成员内部类
    }
    public void method() {
  　　　　class local_inner{ //局部内部类
        }
    }
}

1、成员内部类

（1）访问格式：

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

//注意不要用中文全角空格，否则会出错！编译不通过！
class outer{ 
class inner{
public void show() 
         { 
            System.out.println("你好"); 
    } 
 } 
} 
public class niming{ 
  public static void main(String[]args) { 
    outer.inner b=new outer().new inner(); //创建对象访问对应内部类函数成员 
    b.show(); } 
}

 

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

class outer{
 //成员内部类,设为私有
private class inner{
  public void show() 
     { 
       System.out.println("你好"); } 
     }
  public void show1() { 
    inner b=new inner(); 
    b.show(); } 
   } 
 public class niming{ 
    public static void main(String[]args) {
         //创建对象访问对应内部类函数成员
        outer c=new outer();
           c.show1(); 
      } 
  }

 

（3）将内部类设为静态类

eg1:

class outer{ 
    //静态成员变量 
    private static int num=20; 
    //静态成员方法 
    public static void show2() { 
        System.out.println("hello world");
     } 
    //成员内部类,设为私有静态 
    private static class inner{ 
    public void show() { 
        System.out.println(num); //静态内部类访问外部类成员时，只能访问外部类的静态成员
        show2(); 
        } 
    } 
    public void show1() {
     inner b=new inner();
     b.show(); 
    } 
}
 public class niming {
     public static void main(String[]args) {
    　　outer c=new outer(); 
    　　c.show1(); 
    } 
}                     

 

 

eg2:

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

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

 

2、局部内部类

 

public class Outer{ 
    int num1 = 1; 
    static int num2=2;
    public void inner(){
    System.out.println("局部内部类"); 
    int num3 = 3; 
   // static int num4=4; //error,不能用static修饰
        class InnerClass{   

//局部内部类的类体中不可以声明类变量和类方法,局部内部类不能用static修饰。成员内部类不存在这个限制。
        private int num5 = 5;
    //private static int num6 = 6; //error
        private final static int num7 = 7; //ok
    private static final int num8 = 8; //ok
    public void testNum()
         { 
    System.out.println(num1);
    System.out.println(num2);
    System.out.println(num3);
    System.out.println(this.num5);//ok  
        }
     } 
    InnerClass a=new InnerClass(); 
    a.testNum(); 
   } 
public static void main(String[]args) { Outer c= new Outer(); c.inner(); } 
}

 

成员内部类的字节码文件会不一样。会变成外部类名$number内部类名

 3、匿名内部类

匿名类，就是没有名称的类，其名称由Java编译器给出，一般是形如：外部类名称+$+匿名类顺序，没有名称也就是其他地方就不能引用，不能实例化，只用一次，当然也就不能有显式声明的构造函数.

• 匿名类就是利用父类的构造函数和自身类体构造成一个类。

• 匿名类可以继承父类的方法，也可以重写父类的方法。
• 匿名类可以访问外部类的成员变量和方法，匿名类的类体不可以声明称static成员变量和static方法。
• 匿名类由于是一个new的结果，所以其实可以赋值给一个父类对象。因此可以分为两种匿名类，成员匿名类和局部匿名类（作为函数参数）
• 匿名类永远不能是抽象的。
• 匿名类总是隐式的final.
• 匿名类总是一个内部类；并且不能是static的

 

编译时的命名规则：

1. 内部类的class文件命名是：主类＋$＋内部类名
2. 匿名类的class文件命名是：主类＋$＋(1,2,3….)

 

实际使用中我们只需注意这几点儿：
1. 使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
2. 匿名内部类中是不能定义构造函数的。
3. 匿名内部类中不能存在任何的静态成员变量和静态方法。
4. 匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5. 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

访问权限
1. 访问外层Class里面的字段。
2. 不能访问外层方法中的本地变量。除非变量是final。
3. 如果内部类的名称和外面能访问的名称相同，则会把名称覆盖掉。
4. 不能定义静态初始化代码块
5. 不能在匿名类里面定义接口
6. 不能在匿名类中定义构造函数

实现接口方法的例子：

 

————————————————
版权声明：本文为CSDN博主「yin__ren」的原创文章，遵循undefined版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yin__ren/article/details/79177597