JAVA匿名内部类语法分析及实例详解

1.前言

匿名内部类在我们JAVA程序员的日常工作中经常要用到,但是很多时候也只是照本宣科地用,虽然也在用,但往往忽略了以下几点:为什么能这么用?匿名内部类的语法是怎样的?有哪些限制?因此,最近,我在完成了手头的开发任务后,查阅了一下JAVA官方文档,将匿名内部类的使用进行了一下总结,案例也摘自官方文档。感兴趣的可以查阅官方文档(https://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html)。

2.匿名内部类

匿名内部类可以使你的代码更加简洁,你可以在定义一个类的同时对其进行实例化。它与局部类很相似,不同的是它没有类名,如果某个局部类你只需要用一次,那么你就可以使用匿名内部类

(Anonymous classes enable you to make your code more concise. They enable you to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Use them if you need to use a local class only once.)

本节包括以下几个方面:

  1. 定义匿名内部类
  2. 匿名内部类的语法
  3. 访问作用域的局部变量、定义和访问匿名内部类成员
  4. 匿名内部类实例

2.1定义匿名内部类

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

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();
  }
}

运行结果为:

Hello world
  Salut Fred
  Hola, mundo

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

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

2.2 匿名内部类的语法

如上文所述,匿名类是一个表达式,匿名类的语法就类似于调用一个类的构建函数(new 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);
  }
 };

案例二,匿名子类(继承父类):

public class AnimalTest {

  private final String ANIMAL = "动物";

  public void accessTest() {
    System.out.println("匿名内部类访问其外部类方法");
  }

  class Animal {
    private String name;

    public Animal(String name) {
      this.name = name;
    }

    public void printAnimalName() {
      System.out.println(bird.name);
    }
  }

  // 鸟类,匿名子类,继承自Animal类,可以覆写父类方法
  Animal bird = new Animal("布谷鸟") {

    @Override
    public void printAnimalName() {
      accessTest();          // 访问外部类成员
      System.out.println(ANIMAL); // 访问外部类final修饰的变量
      super.printAnimalName();
    }
  };

  public void print() {
    bird.printAnimalName();
  }

  public static void main(String[] args) {

    AnimalTest animalTest = new AnimalTest();
    animalTest.print();
  }
}

运行结果:

运行结果:
匿名内部类访问其外部类方法
动物
布谷鸟

从以上两个实例中可知,匿名类表达式包含以下内部分:

  1. 操作符:new;
  2. 一个要实现的接口或要继承的类,案例一中的匿名类实现了HellowWorld接口,案例二中的匿名内部类继承了Animal父类;
  3. 一对括号,如果是匿名子类,与实例化普通类的语法类似,如果有构造参数,要带上构造参数;如果是实现一个接口,只需要一对空括号即可;
  4. 一段被"{}"括起来类声明主体;
  5. 末尾的";"号(因为匿名类的声明是一个表达式,是语句的一部分,因此要以分号结尾)。

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

匿名内部类与局部类对作用域内的变量拥有相同的的访问权限。
(1)、匿名内部类可以访问外部内的所有成员;
(2)、匿名内部类不能访问外部类未加final修饰的变量(注意:JDK1.8即使没有用final修饰也可以访问);
(3)、属性屏蔽,与内嵌类相同,匿名内部类定义的类型(如变量)会屏蔽其作用域范围内的其他同名类型(变量):

案例一,内嵌类的属性屏蔽:

public class ShadowTest {

  public int x = 0;

  class FirstLevel {

    public int x = 1;

    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.new FirstLevel();
    fl.methodInFirstLevel(23);
  }
}

输出结果为:

x = 23
this.x = 1
ShadowTest.this.x = 0

这个实例中有三个变量x:1、ShadowTest类的成员变量;2、内部类FirstLevel的成员变量;3、内部类方法methodInFirstLevel的参数。

methodInFirstLevel的参数x屏蔽了内部类FirstLevel的成员变量,因此,在该方法内部使用x时实际上是使用的是参数x,可以使用this关键字来指定引用是成员变量x:

System.out.println("this.x = " + this.x); 

利用类名来引用其成员变量拥有最高的优先级,不会被其他同名变量屏蔽,如:

System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);

案例二,匿名内部类的属性屏蔽:

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
    }
  };
}

(5)、匿名内部类可以有常量属性(final修饰的属性);

(6)、匿名内部内中可以定义属性,如上面代码中的代码:private int x = 1;

(7)、匿名内部内中可以可以有额外的方法(父接口、类中没有的方法);

(8)、匿名内部内中可以定义内部类;

(9)、匿名内部内中可以对其他类进行实例化。

4.匿名内部类实例

官方提供的两个实例供大家参考:

实例一:

import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class HelloWorld extends Application {
  public static void main(String[] args) {
    launch(args);
  }

  @Override
  public void start(Stage primaryStage) {
    primaryStage.setTitle("Hello World!");
    Button btn = new Button();
    btn.setText("Say 'Hello World'");
    btn.setOnAction(new EventHandler<ActionEvent>() {

      @Override
      public void handle(ActionEvent event) {
        System.out.println("Hello World!");
      }
    });

    StackPane root = new StackPane();
    root.getChildren().add(btn);
    primaryStage.setScene(new Scene(root, 300, 250));
    primaryStage.show();
  }
}

实例二:

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;

public class CustomTextFieldSample extends Application {

  final static Label label = new Label();

  @Override
  public void start(Stage stage) {
    Group root = new Group();
    Scene scene = new Scene(root, 300, 150);
    stage.setScene(scene);
    stage.setTitle("Text Field Sample");

    GridPane grid = new GridPane();
    grid.setPadding(new Insets(10, 10, 10, 10));
    grid.setVgap(5);
    grid.setHgap(5);

    scene.setRoot(grid);
    final Label dollar = new Label("$");
    GridPane.setConstraints(dollar, 0, 0);
    grid.getChildren().add(dollar);

    final TextField sum = new TextField() {
      @Override
      public void replaceText(int start, int end, String text) {
        if (!text.matches("[a-z, A-Z]")) {
          super.replaceText(start, end, text);
        }
        label.setText("Enter a numeric value");
      }

      @Override
      public void replaceSelection(String text) {
        if (!text.matches("[a-z, A-Z]")) {
          super.replaceSelection(text);
        }
      }
    };

    sum.setPromptText("Enter the total");
    sum.setPrefColumnCount(10);
    GridPane.setConstraints(sum, 1, 0);
    grid.getChildren().add(sum);

    Button submit = new Button("Submit");
    GridPane.setConstraints(submit, 2, 0);
    grid.getChildren().add(submit);

    submit.setOnAction(new EventHandler<ActionEvent>() {
      @Override
      public void handle(ActionEvent e) {
        label.setText(null);
      }
    });

    GridPane.setConstraints(label, 0, 1);
    GridPane.setColumnSpan(label, 3);
    grid.getChildren().add(label);

    scene.setRoot(grid);
    stage.show();
  }

  public static void main(String[] args) {
    launch(args);
  }
}

写在最后:

这篇文章是我在阅读官方文档的同时加以自己的理解整理出来的,可能受英文原版的影响,有些地方表达得不准确或是不清楚还希望读者能够指正。另外,体会到了那些翻译英文技术书的人确实不容易,英文的文章看上去意思都很清楚,但是想要再用中文表述出来却不那么容易。

到此这篇关于JAVA匿名内部类语法分析及实例详解的文章就介绍到这了,更多相关JAVA匿名内部类内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java中匿名内部类详解

    java匿名内部类: 1:匿名内部类,匿名内部类也就是没有名字的内部类. 2:匿名内部类的作用 正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写. 3:匿名内部类的实现 匿名内部类的两种实现方式:第一种,继承一个类,重写其方法:第二种,实现一个接口(可以是多个),实现其方法. 4:匿名内部类的创建 匿名类是不能有名称的类,所以没办法引用它们.必须在创建时,作为new语句的一部分来声明它们. package com.mianshi.test; /** * 类名称:Anonymou

  • Java 匿名内部类详解及实例代码

    Java  匿名内部类详解 匿名内部类也就是没有名字的内部类 正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写 但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat someth

  • java 中匿名内部类的实例详解

    java 中匿名内部类的实例详解 原来的面貌: class TT extends Test{ void show() { System.out.println(s+"~~~哈哈"); System.out.println("超级女声"); } TT tt=new TT(); tt.show(); 只是说我们这里采用的是匿名的形式来处理. 重写了Test的show()方法,在重写好了以后,又调用了重写后的show()方法 实现代码: package cn.com; c

  • java匿名内部类实例代码详解

    这篇文章主要介绍了java匿名内部类实例代码详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Person.java package insof; public class Person extends Object{ String name; static int age; public Person() { this.name = "tom"; System.out.println("执行的是构造方法");

  • Java匿名类,匿名内部类实例分析

    本文实例讲述了Java匿名类,匿名内部类.分享给大家供大家参考,具体如下: 本文内容: 内部类 匿名类 首发日期 :2018-03-25 内部类: 在一个类中定义另一个类,这样定义的类称为内部类.[包含内部类的类可以称为内部类的外部类] 如果想要通过一个类来使用另一个类,可以定义为内部类.[比如苹果手机类,苹果手机类中的黄金版的是特别定制的] 内部类的外部类的成员变量在内部类中仍然有效,内部类中的方法也可以调用外部类中的方法.[不论是静态还是非静态的,内部类都可以直接调用外部类中的属性,] 内部

  • Java匿名内部类原理与用法详解

    本文实例讲述了Java匿名内部类原理与用法.分享给大家供大家参考,具体如下: 一 点睛 匿名内部类适合创建那种只需要一次使用的类,定义匿名内部类的语法格式如下: new 父类构造器(实参列表) | 实现接口() { //匿名内部类的类体部分 } 从上面的定义可以看出,匿名内部类必须继承一个父类,或实现一个接口,但最多只能继承一个父类,或实现一个接口. 两条规则. 匿名内部类不能是抽象类. 匿名内部类不能定义构造器.由于匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以初始化块,可以通过初始

  • Java局部内部类和匿名内部类定义与用法实例分析

    本文实例讲述了Java局部内部类和匿名内部类.分享给大家供大家参考,具体如下: 一 局部内部类 1 点睛 内部类不仅可以在类中定义,也可以定义在方法体或作用域内.这样的内部类作用范围仅限于方法体或特定的作用域内,因此也称为局部内部类. 2 代码 class InnerClassTest { int score = 95; void inst() { class Inner { void display() { System.out.println("成绩: score = " + sc

  • java中的匿名内部类总结

     java中的匿名内部类总结 匿名内部类也就是没有名字的内部类 正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写 但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat somet

  • java 内部类(匿名类,匿名对象,静态内部类)详解及实例

    内部类的介绍 定义在另外一个类中的类,叫内部类 成员内部类 1..new 创建成员内部类必须先创建外部类的实例,然后通过.new 创建内部类的对象 2..this 可以通过外部类的类名.this去访问外部类的所有属性和方法. public class Test1 { String name = "asnd"; public static void main(String[] args) { Test1 test1 = new Test1(); Inner mInner = test1.

  • Java匿名对象与匿名内部类

    匿名对象:没有名字的对象. 非匿名对象: ClassName c=new ClassName(); c.run(); 匿名对象: new ClassName().run(); 注意事项: 1.当对象对方法仅进行一次调用的时候,就可以简化成匿名对象. 2.两个匿名对象不可能是同一个对象. 3.一般不给匿名对象赋予属性值,因为永远无法获取到. 4.运行一次,直接就被回收掉了,节省内存空间. 匿名对象使用的代码例子: public class Anony{ int a=1; int b=2; void

随机推荐