Java——匿名内部类

布满荆棘的人生 2021-06-24 13:58 456阅读 0赞

### 目录 ###

*  1. 匿名内部类浅析
 *  2. 定义匿名内部类
 *  3.访问作用域内的局部变量、定义和访问匿名内部类成员
 *  4. 匿名内部类中不能定义静态属性、方法；

# 1. 匿名内部类浅析 #

从重构的角度来看，匿名内部类可以使你少些一些重复代码，案列如下：

首先我们来看一个代码，计算一个方法执行了多少秒! 其实大多数人都会写。像这样：

public static void test() { 
        long start = System.currentTimeMillis();
        //执行打印的业务逻辑
        for (int i = 0; i < 10; i++) { 
            System.out.println(i);
        }
    
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

可以将这段代码抽取成一个类，或者一个**接口**的方法。像这样：  
（接口：不知道函数具体实现，程序也可以正常运行，便于协作编程）

public static void test(MyService myService) { 
        long start = System.currentTimeMillis();
        //执行打印的业务逻辑
        myService.invoke();
    
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

这段代码抽取成了MyService的invoke()方法:

public interface MyService { 
    
        public void invoke();
    
    }

调用：

//使用匿名内部类调用test（MyService myService）
    public static void main(String[] args) { 
         test(new MyService() { 
             @Override
             public void invoke() { 
                 for (int i = 0; i < 10; i++) { 
                     System.out.println(i);
                 }
             }
         });
    }

# 2. 定义匿名内部类 #

首先看下官方文档中给的例子：

public class HelloWorldAnonymousClasses { 
    
        /** * 包含两个方法的HelloWorld接口 */
        interface HelloWorld { 
            public void greet();
            public void greetSomeone(String someone);
        }
    
        public void sayHello() { 
    
            // 1、局部类EnglishGreeting实现了HelloWorld接口
            class EnglishGreeting implements HelloWorld { 
                String name = "world";
                public void greet() { 
                    greetSomeone("world");
                }
                public void greetSomeone(String someone) { 
                    name = someone;
                    System.out.println("Hello " + name);
                }
            }
    
            HelloWorld englishGreeting = new EnglishGreeting();
    
            // 2、匿名类实现HelloWorld接口
            HelloWorld frenchGreeting = new HelloWorld() { 
                String name = "tout le monde";
                public void greet() { 
                    greetSomeone("tout le monde");
                }
                public void greetSomeone(String someone) { 
                    name = someone;
                    System.out.println("Salut " + name);
                }
            };
    
            // 3、匿名类实现HelloWorld接口
            HelloWorld spanishGreeting = new HelloWorld() { 
                String name = "mundo";
                public void greet() { 
                    greetSomeone("mundo");
                }
                public void greetSomeone(String someone) { 
                    name = someone;
                    System.out.println("Hola, " + name);
                }
            };
    
            englishGreeting.greet();
            frenchGreeting.greetSomeone("Fred");
            spanishGreeting.greet();
        }
    
        public static void main(String... args) { 
            HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
            myApp.sayHello();
        }
    }

运行结果为：  
1 Hello world  
2 Salut Fred  
3 Hola, mundo

该例中用局部类来初始化变量englishGreeting，用匿名类来初始化变量frenchGreeting和spanishGreeting，两种实现之间有明显的区别：

*  局部类EnglishGreetin继承HelloWorld接口，有自己的类名，定义完成之后需要再用new关键字实例化才可以使用；
 *  frenchGreeting、spanishGreeting在定义的时候就实例化了，定义完了就可以直接使用；
 *  匿名类是一个表达式，因此在定义的最后用分号";"结束。

# 3.访问作用域内的局部变量、定义和访问匿名内部类成员 #

匿名内部类与局部类对作用域内的变量拥有相同的的访问权限。

*  匿名内部类可以访问外部内的所有成员；
 *  JDK1.8之前匿名内部类不能访问外部类未加final修饰的变量（**注意**：JDK1.8即使没有用final修饰也可以访问）；
 *  属性屏蔽，与内嵌类相同，匿名内部类定义的类型（如变量）会屏蔽其作用域范围内的其他同名类型（变量）：

public class Hello { 
    	public static void main(String[] args) { 
    		String str="haha";
    		new Thread() { 
    			@Override
    			public void run() { 
    				System.out.println(str);		//将会报错，不能编过
    			}
    		}.start();
    	}
    }

**匿名内部类的属性屏蔽：**

public class ShadowTest { 
        public int x = 0;
    
        interface FirstLevel { 
         void methodInFirstLevel(int x);
        }
    
        FirstLevel firstLevel =  new FirstLevel() { 
    
            public int x = 1;
    
            @Override
            public void methodInFirstLevel(int x) { 
                System.out.println("x = " + x);
                System.out.println("this.x = " + this.x);
                System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
            }
        };
    
        public static void main(String... args) { 
            ShadowTest st = new ShadowTest();
            ShadowTest.FirstLevel fl = st.firstLevel;
            fl.methodInFirstLevel(23);
        }
    }

输出结果为：  
x = 23  
this.x = 1  
ShadowTest.this.x = 0

# 4. 匿名内部类中不能定义静态属性、方法； #

public class ShadowTest { 
        public int x = 0;
    
        interface FirstLevel { 
         void methodInFirstLevel(int x);
        }
    
        FirstLevel firstLevel =  new FirstLevel() { 
    
            public int x = 1;
    
            public static String str = "Hello World";   // 编译报错
    
            public static void aa() {         // 编译报错
            }
    
            public static final String finalStr = "Hello World";  // 正常
    
            public void extraMethod() {   // 正常
                // do something
            }
        };
    }