java匿名类

今天在学习的时候发现我对Java的匿名类理解是错误的，今天特意借鉴一篇博文来梳理这些知识点。

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

 1 class C{
 2     //成员内部类
 3     class B{
 4     }
 5     public void show1() {
 6         //局部内部类
 7         class D{
 8         }
 9     }
10 }

成员内部类

成员内部类的访问格式：外部类名.内部类名对象名=外部类对象.内部类对象

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

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

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

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 
21 public class niming {
22     public static void main(String[]args) {
23         //创建对象访问对应内部类函数成员
24         C c=new C();
25         c.show1();
26     }
27 }

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，返回外部类对象，访问对象外部类的num
13             System.out.println(Outer.this.num);
14             //通过创建对象的方式访问外部成员变量不推荐
15             //System.out.println(new Outer().num); 
16         }
17     }
18 }
19 
20 public class niming {
21     public static void main(String[]args) {
22         Outer.Inner inner=new Outer().new Inner();
23         inner.show();
24     }
25 }

局部内部类

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

内部类访问的外部变量必须定义为 final 或 static 类型

 1 public class Outer{
 2     public void inner(){
 3         final int num = 5;
 4         class InnerClass{
 5             private int num = 4;
 6             public void testNum(){
 7                 System.out.println(this.num);
 8             }
 9         }
10      }
11 }

首先，内部类和外部类其实是处于同一个级别，内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了，如果外部类的方法中的变量不定义final，那么当外部类方法执行完毕的时候，这个局部变量肯定也就被GC了，然而内部类的某个方法还没有执行完，这个时候他所引用的外部变量已经找不到了。如果定义为final，java会将这个变量复制一份作为成员变量内置于内部类中，这样的话，由于final所修饰的值始终无法改变，所以这个变量所指向的内存区域就不会变。

匿名内部类

概念：即内部类的简化写法
前提：存在一个类（可以是具体类也可以是抽象类）或接口
格式：new 类名或接口名{重写的方法}
本质：创建的是继承了类或实现了接口的子类匿名对象。

Java语言规范上是这么描述匿名类的：

匿名类的声明：

匿名类的声明是由java编译器自动派生自一个类实例创建表达式。
匿名类永远不能是抽象的。
匿名类总是隐式的final。
匿名类总是一个内部类；并且不能是static的。

匿名构造函数：

匿名类不能有显式声明的构造函数。相反的，Java编译器必须为这个匿名类自动提供一个匿名构造函数。匿名类Ｃ继承于父类Ｓ那么匿名构造函数是下面的形式：

如果Ｓ不是一个内部类或者Ｓ是一个静态上下文中的局部类，那么这个匿名构造函数有一个形参为每一个在Ｃ的类实例创建表达式中的实际参数。
类的实例创建表达式的实际参数用来确定S的一个构造函数cs，使用方法调用相同的规则。
每一个匿名构造函数的形参必须和cs中的相关形参一致。
这个构造函数中显式的包括super(…)构造函数调用，这个实际参数是构造函数的形参，按它们声明的顺序。

否则，Ｃ的构造函数第一个形参描述了这个值，直接包围实例ｉ相对于Ｓ。参数的类型是Ｓ的class类型。
构造函数有一个额外的形参为每一个类实例创建语句声明在匿名类中的实际参数。第n个形参和第n-1个实际参数相关。
类的实例创建表达式的实际参数用来确定S的一个构造函数cs，使用方法调用相同的规则。
每一个匿名构造函数的形参必须和cs中的相关形参一致。
这个构造函数中显式的包括super(…)构造函数调用，这个实际参数是构造函数的形参，按它们声明的顺序。

在所有的情况下，匿名构造函数的throws语句必须列出所有的检查异常，包括父类构造函数显式调用语句抛出的和匿名类的实例初始化或者变量初始化抛出的异常。

注意：匿名构造函数的签名涉及到了一个不可达类型是可能的(例如，出现在父类构造函数中的类型)，这不会导致任何编译时和运行时错误。

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

编译时的命名规则：

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

匿名类的语法

1 Runnable hello = new Runnable() {  
2     public void run() {  
3         System.out.println("hello");  
4     }  
5 };

一个匿名类由以下几个部分组成：

new操作符
Runnable：接口名称。这里还可以填写抽象类、普通类的名称。
()：这个括号表示构造函数的参数列表。由于Runnable是一个接口，没有构造函数，所以这里填一个空的括号表示没有参数。
{…}：大括号中间的代码表示这个类内部的一些结构。在这里可以定义变量名称、方法。跟普通的类一样。
访问权限
1. 访问外层Class里面的字段。
2. 不能访问外层方法中的本地变量。除非变量是final。
3. 如果内部类的名称和外面能访问的名称相同，则会把名称覆盖掉。
4. 不能定义静态初始化代码块
5. 不能在匿名类里面定义接口
6. 不能在匿名类中定义构造函数

因为匿名类没有名字，而构造函数需要把类名作为方法名才能看成构造函数。
匿名类中可以包含的东西有：

字段
方法
实例初始化代码
本地类

匿名内部类方法的访问:

 1 //方法1：直接在new A内部类后边加点加方法，这样访问，如果方法多了，调用太麻烦
 2 new D(){
 3     @Override
 4     public void ShowContext() {
 5         System.out.println("hello");
 6     }
 7 }.ShowContext();
 8 
 9 //方法2：通过创建对象来访问，多态思想
10 D a=new D(){
11     @Override
12     public void ShowContext() {
13         System.out.println("hello");
14     }
15 };
16 a.ShowContext();

匿名内部类在开发中的使用，一般是方法参数为接口的情况

 1 interface D{
 2     void ShowContext();
 3 }
 4 class B{
 5     //参数为接口对象
 6     public void show(D d) {
 7         d.ShowContext();
 8     }
 9 }
10 
11 public class niming {
12     public static void main(String[]args) {
13         B b=new B();
14         //调用时使用匿名类创建匿名对象
15         b.show(new D(){
16             @Override
17             public void ShowContext() {
18                 System.out.println("hello");
19             }
20         });
21     }
22 }

原文链接：https://blog.csdn.net/yin__ren/article/details/79177597

成员内部类

局部内部类

匿名内部类

猜你喜欢