Java内部类和匿名内部类的用法说明

一、内部类: 

(1)内部类的同名方法

内部类可以调用外部类的方法,如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用(其中OuterClass与MethodName换成实际外部类名及其方法;this为关键字,表示对外部类的引用);若内部类无同名方法可以直接调用外部类的方法。

但外围类无法直接调用内部类的private方法,外部类同样无法直接调用其它类的private方法。注意:内部类直接使用外部类的方法与该方法的权限与是否static无关,它取决于内部类是否有同名方法。

package innerclass;
public class OuterClass {
 private void outerMethod() {
 System.out.println("It's Method of OuterClass");
 }
 public static void main(String[] args) {
 OuterClass t = new OuterClass();
 OuterClass.Innerclass in = t.new Innerclass();
 in.innerMethod();
 }

 class Innerclass {
 public void innerMethod() {
   OuterClass.this.outerMethod();// 内部类成员方法与外部类成员方法同名时,使用this调用外部类的方法
   outerMethod();// 内部类没有同名方法时执行外部类的方法
 }
 private void outerMethod() {
  System.out.println("It's Method of Innerclass");
 }
 }
}

输出结果为:

It's Method of OuterClass

It's Method of Innerclass

(2)内部类访问外部类的变量必须声明为final

方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。

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

注意,若使用JDK1.8,方法中内部类的方法是可以直接访问外部类的方法的局部变量,并且不需要声明为final类型。

public class OuterClass {
 int num1 = 0;// 成员变量

 private void outerMethod() {
 int num2 = 0;// 方法内的局部变量
 class Innerclass_1 {
  public void innerMethod() {
  System.out.println(num1);// 方法中内部类的方法,可以正常访问外部类的成员变量
  System.out.println(num2);// JDK1.8以前,方法中内部类的方法,不能直接访问外部类的方法的局部变量,必须声明为final
  }
 }
 }
}

如果使用JDK1.8以前的版本,Eclipse会出现如下错误提示:

(3)内部类的实例化

内部类实例化不同于普通类,普通类可以在任意需要的时候实例化,而内部类必须在外层类实例化以后方可实例化,并与外部类建立关系

因此在外部类中的非static方法中,是可以实例化内部类对象

private void outerMethod() {
 System.out.println("It's Method of OuterClass");
 Innerclass in = new Innerclass();//在外部类的outerMethod方法中实例化内部类是可以啊
 }

但在static方法中,就要注意啦!!!!不能在static方法中直接new内部类,否则出现错误:

No enclosing instance of type OuterClass is accessible. Must qualify the allocation with an enclosing instance of type OuterClass (e.g. x.new A() where x is an instance of OuterClass).

这是因为静态方法是在类实例化之前就可以使用的,通过类名调用,这时动态内部类都还没实例化呢,怎么用,总不能调用一个不存在的东西吧。

如果想在Static方法中new内部类,可以把内部类声明为Static

public class OuterClass {
 private void outerMethod() {
 System.out.println("It's Method of OuterClass");
 }

 public static void main(String[] args) {
 Innerclass in = new Innerclass();
 in.innerMethod();
 }

 static class Innerclass {//把内部类声明为static
 public void innerMethod() {
  System.out.println("It's Method of innerMethod");

 }
 }

}

当然,一般不使用static的方式,而是推荐这种方法:x.new A() ,其中 x是外部类OuterClass的实例,A是内部类Innerclass

package innerclass;
public class OuterClass {
 private void outerMethod() {
 System.out.println("It's Method of OuterClass");
 }
 public static void main(String[] args) {
 OuterClass.Innerclass in = new OuterClass().new Innerclass();//使用x.new A()的方式
 in.innerMethod();
 }
 class Innerclass {
 public void innerMethod() {
  System.out.println("It's Method of innerMethod");
 }
 }
}

x.new A() ,其中 x是外部类OuterClass的实例,A是类部类Innerclass,当然可以拆分如下,这样就显然很明白啦:

public static void main(String[] args) {
 OuterClass out = new OuterClass();//外部实例
 OuterClass.Innerclass in = out.new Innerclass();//外部实例.new 外部类
 in.innerMethod();
 }

(4)什么情况下使用内部类

典型的情况是,内部类继承自某个类或实现某个接口,内部类的代码操作创建其的外层类的对象。所以你可以认为内部类提供了某种进入其外层类的窗口。

使用内部类最吸引人的原因是:每个内部类都能独立地继承自一个(接口的)实现,所以无论外层类是否已经继承了某个(接口的)实现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角度看,内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了“多重继承”。

(5)在静态方法中实例化内部类例子:(内部类放在静态方法中)

package javatest2;
public class JavaTest2 {
 public static void main(String[] args) {
 class Boy implements Person {
  public void say() {// 匿名内部类自定义的方法say
  System.out.println("say方法调用");
  }
  @Override
  public void speak() {// 实现接口的的方法speak
  System.out.println("speak方法调用");
  }
 }
 Person per = new Boy();
 per.speak();// 可调用
 per.say();// 不能调用
 }
}
interface Person {
 public void speak();
}

per.speak()可调用,而per.say()不能调用,这时因为per是Person对象,要想调用子类的方法,可以强制向下转型为:((Boy) per).say();或者直接改为Boy per = new Boy();。从中可发现,要想调用内部类的自定义的方法,必须通过内部类的对象来调用。那么,匿名内部类连名字都没有,怎么调用内部类自定义的方法?

(二)匿名内部类

匿名内部类也就是没有名字的内部类正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写,但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口,但最多只能继承一个父类,或实现一个接口。

关于匿名内部类还有如下两条规则:

1)匿名内部类不能是抽象类,因为系统在创建匿名内部类的时候,会立即创建内部类的对象。因此不允许将匿名内部类定义成抽象类。

2)匿名内部类不等定义构造器(构造方法),因为匿名内部类没有类名,所以无法定义构造器,但匿名内部类可以定义实例初始化块,

怎样判断一个匿名类的存在啊?看不见名字,感觉只是父类new出一个对象而已,没有匿名类的名字。

先看段伪代码

abstract class Father(){
....
}
public class Test{
  Father f1 = new Father(){ .... } //这里就是有个匿名内部类
}

一般来说,new 一个对象时小括号后应该是分号,也就是new出对象该语句就结束了。但是出现匿名内部类就不一样,小括号后跟的是大括号,大括号中是该new 出对象的具体的实现方法。因为我们知道,一个抽象类是不能直接new 的,必须先有实现类了我们才能new出它的实现类。上面的伪代码就是表示new 的是Father的实现类,这个实现类是个匿名内部类。

其实拆分上面的匿名内部类可为:

class SonOne extends Father{
 ...    //这里的代码和上面匿名内部类,大括号中的代码是一样的
}
public class Test{
  Father f1 = new SonOne() ;
}

先看一个例子,体会一下匿名内部类的用法:

运行结果:eat something

可以看到,我们直接将抽象类Person中的方法在大括号中实现了,这样便可以省略一个类的书写。并且,匿名内部类还能用于接口上

public class JavaTest2 {
 public static void main(String[] args) {
 Person per = new Person() {
  public void say() {// 匿名内部类自定义的方法say
  System.out.println("say方法调用");
  }
  @Override
  public void speak() {// 实现接口的的方法speak
  System.out.println("speak方法调用");
  }
 };
 per.speak();// 可调用
 per.say();// 出错,不能调用
 }
}

interface Person {
 public void speak();
}

这里per.speak()是可以正常调用的,但per.say()不能调用,为什么呢?注意Person per = new Person()创建的是Person的对象,而非匿名内部类的对象。其实匿名内部类连名字都没有,你咋实例对象去调用它的方法呢?但继承父类的方法和实现的方法是可以正常调用的,本例子中,匿名内部类实现了接口Person的speak方法,因此可以借助Person的对象去调用。

若你确实想调用匿名内部类的自定义的方法say(),当然也有方法:

(1)类似于speak方法的使用,先在Person接口中声明say()方法,再在匿名内部类中覆写此方法。

(2)其实匿名内部类中隐含一个匿名对象,通过该方法可以直接调用say()和speak()方法;代码修改如下:

public class JavaTest2 {
 public static void main(String[] args) {
 new Person() {
  public void say() {// 匿名内部类自定义的方法say
  System.out.println("say方法调用");
  }

  @Override
  public void speak() {// 实现接口的的方法speak
  System.out.println("speak方法调用");
  }
 }.say();// 直接调用匿名内部类的方法
 }
}
interface Person {
 public void speak();
}

补充知识: Java内部类的定义、如何创建内部类、内部类的分类、内部类与外部类的关系

1. 内部类的基本概念

1.1 内部类的定义

内部类: 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。

class Outer{
  private String str ="外部类中的字符串";
  //**************************
  //定义一个内部类
  class Inner{
    private String inStr= "内部类中的字符串";
    //定义一个普通方法
    public void print(){
      //调用外部类的str属性
      System.out.println(str);
    }
  }
  //**************************
  //在外部类中定义一个方法,该方法负责产生内部类对象并调用print()方法
  public void fun(){
    //内部类对象
    Inner in = new Inner();
    //内部类对象提供的print
    in.print();
  }
}
public class Test{
  public static void main(String[] args)
  {
    //创建外部类对象
    Outer out = new Outer();
    //外部类方法
    out.fun();
  }
}

运行结果:外部类中的字符串

但是如果去掉内部类:

class Outer{
  private String outStr ="Outer中的字符串";
  public String getOutStr()
  {
    return outStr;
  }
  public void fun(){ //2
    //this表示当前对象
    Inner in = new Inner(this); //3
    in.print();         //5
  }
}
class Inner{
  private String inStr= "Inner中的字符串";
  private Outer out;
  //构造注入
  public Inner(Outer out) //3
  {
    this.out=out;    //4.为Inner中的out变量初始化
  }
  public void print(){  //6
    System.out.println(out.getOutStr()); //7
  }
}
public class Test{
  public static void main(String[] args)
  {
    Outer out = new Outer(); //1.
    out.fun(); //2.
  }
}

执行结果:Outer中的字符串

但是去掉内部类之后发现程序更加难以理解。

1.2 内部类的优缺点

内部类的优点:

内部类与外部类可以方便的访问彼此的私有域(包括私有方法、私有属性)。

内部类是另外一种封装,对外部的其他类隐藏。

内部类可以实现java的单继承局限。

内部类的缺点:

结构复杂。

记录:使用内部类实现多继承:

class A {
  private String name = "A类的私有域";
  public String getName() {
    return name;
  }
}
class B {
  private int age = 20;
  public int getAge() {
    return age;
  }
}
class Outter {
  private class InnerClassA extends A {
    public String name() {
      return super.getName();
  }
}
  private class InnerClassB extends B {
    public int age() {
      return super.getAge();
  }
}
  public String name() {
    return new InnerClassA().name();
  }
  public int age() {
    return new InnerClassB().age();
  }
}
public class Test2 {
    public static void main(String[] args) {
      Outter outter = new Outter();
      System.out.println(outter.name());
      System.out.println(outter.age());
    }
}

2. 创建内部类

2.1 在外部类外部 创建非静态内部类

语法: 外部类.内部类 内部类对象 = new 外部类().new 内部类();

举例: Outer.Inner in = new Outer().new Inner();

2.2 在外部类外部 创建静态内部类

语法: 外部类.内部类 内部类对象 = new 外部类.内部类();

举例: Outer.Inner in = new Outer.Inner();

2.3 在外部类内部创建内部类语法

在外部类内部创建内部类,就像普通对象一样直接创建:Inner in = new Inner();

3. 内部类的分类

在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类

3.1 成员内部类

类比成员方法

成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性 (成员方法与对象相关、静态属性与类有关)

class Outer {
  private String name = "test";
  public static int age =20;

  class Inner{
    public static int num =10;
    public void fun()
    {
      System.out.println(name);
      System.out.println(age);
    }
  }
}
public class Test{
  public static void main(String [] args)
  {}
}

2. 成员内部类是依附外部类的,只有创建了外部类才能创建内部类。

3.2 静态内部类

关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类,使用static修饰的内部类我们称之为静态内部类,静态内部类和非静态内部类之间存在一个最大的区别,非静态内部类在编译完成之后会隐含的保存着一个引用,该引用是指向创建它的外围类,但是静态类没有。没有这个引用就意味着:

1.静态内部类的创建不需要依赖外部类可以直接创建。

2.静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以存在自己的成员变量。

class Outer {
  public String name = "test";
  private static int age =20;

  static class Inner{
    private String name;
    public void fun()
    {
      System.out.println(name);
      System.out.println(age);
    }
  }
}
public class Test{
  public static void main(String [] args)
  {
    Outer.Inner in = new Outer.Inner();
  }
}

3.3 方法内部类

方法内部类顾名思义就是定义在方法里的类

1.方法内部类不允许使用访问权限修饰符(public、private、protected)均不允许。

class Outer{
  private int num =5;
  public void dispaly(final int temp)
  {
    //方法内部类即嵌套在方法里面
    public class Inner{
    }
  }
}
public class Test{
  public static void main(String[] args)
  {}
}

2. 方法内部类对外部完全隐藏,除了创建这个类的方法可以访问它以外,其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)方法内部类对外部完全隐藏,出了创建这个类的方法可以访问它,其他地方均不能访问。

3. 方法内部类如果想要使用方法形参,该形参必须使用final声明(JDK8形参变为隐式final声明)

class Outer{
  private int num =5;
  //普通方法
  public void dispaly(int temp)
  {
    //方法内部类即嵌套在方法里面
    class Inner{
      public void fun()
      {
        System.out.println(num);
        temp++;
        System.out.println(temp);
      }
    }
    //方法内部类在方法里面创建
    new Inner().fun();
  }
}
public class Test{
  public static void main(String[] args)
  {
    Outer out = new Outer();
    out.dispaly(2);
  }
}

3.4 匿名内部类

匿名内部类就是一个没有名字的方法内部类,因此特点和方法与方法内部类完全一致,除此之外,还有自己的特点:

1.匿名内部类必须继承一个抽象类或者实现一个接口。

2.匿名内部类没有类名,因此没有构造方法。

//匿名内部类
//声明一个接口
interface MyInterface {
  //接口中方法没有方法体
  void test();
}
class Outer{
  private int num = 5;
  public void dispaly(int temp)
  {
    //匿名内部类,匿名的实现了MyInterface接口
    //隐藏的class声明
    new MyInterface()
    {
      public void test()
      {
        System.out.println("匿名实现MyInterface接口");
        System.out.println(temp);
      }
    }.test();
  }
}
public class Test{
  public static void main(String[] args)
  {
    Outer out = new Outer();
    out.dispaly(3);
  }
}

4. 内部类与外部类的关系

对于非静态的内部类,内部类的创建依赖外部类的实例对象,在没有外部类实例之前是无法创建内部类的。内部类可以直接访问外部类的元素(包括私有域)—外部类在内部类之前创建,创建内部类时会将外部类的对象传入

class Outer{
  //成员变量 与对象有关
  private String msg;
  private int age;
  //--------------------------
  class Inner{
    public void dispaly()
    {
      //此处有一个隐藏的Outer.this
      msg = "test";
      age = 20;
      System.out.println(msg);
      System.out.println(age);
    }
  }
  //--------------------------
  public void test()
  {
    Inner in = new Inner();
    in.dispaly();
  }
}
public class Test{
  public static void main(String[] args)
  {
    Outer out = new Outer();
    out.test();
  }
}

外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性,必须先创建内部类对象

class Outer{
  public void dispaly()
  {
    //外部类通过创建内部类的对象间接访问内部类元素
    Inner in = new Inner();
    in.dispaly();
  }
  class Inner{
    public void dispaly()
    {
      System.out.println("内部类");
    }
  }
}
public class Test1{
  public static void main(String[] args)
  {
    Outer out = new Outer();
    out.dispaly();
  }
}

内部类是一个相对独立的个体,与外部类没有关系。

以上这篇Java内部类和匿名内部类的用法说明就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • static关键字有何魔法?竟让Spring Boot搞出那么多静态内部类(推荐)

    生命太短暂,不要去做一些根本没有人想要的东西.本文已被 https://www.yourbatman.cn 收录,里面一并有Spring技术栈.MyBatis.JVM.中间件等小而美的专栏供以免费学习. 前言 各位小伙伴大家好,我是A哥.上篇文章了解了static关键字 + @Bean方法的使用,知晓了它能够提升Bean的优先级,在@Bean方法前标注static关键字,特定情况下可以避免一些烦人的"警告"日志的输出,排除隐患让工程变得更加安全.我们知道static关键字它不仅可使用在

  • Java中ArrayList类的使用方法

    Java中ArrayList类的用法 1.什么是ArrayList ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处: 动态的增加和减少元素 实现了ICollection和IList接口 灵活的设置数组的大小 2.如何使用ArrayList 最简单的例子: ArrayList List = new ArrayList(); for( int i=0;i <10;i++ ) //给数组增加10个Int元素 List.Add(i); //..

  • java中匿名内部类解读分析

    这段时间在看android,看到了java里面的匿名内部类,在印象当中.net里面不支持匿名内部类. 匿名类是不能有名称的类,所以没办法引用它们.必须在创建时,作为new语句的一部分来声明它们.这就要采用另一种形式的new语句,如下所示: new <类或接口> <类的主体> 这种形式的new语句声明一个新的匿名类,它对一个给定的类进行扩展,或者实现一个给定的接口.它还创建那个类的一个新实例,并把它作为语句的结果而返回.要扩展的类和要实现的接口是new语句的操作数,后跟匿名类的主体.

  • Java中初始化List的5种方法示例

    前言 List是java重要的数据结构之一,我们经常接触到的有ArrayList.Vector和LinkedList三种,他们都继承来自java.util.Collection接口,类图如下 Java 中经常需要使用到 List,下面简单介绍几种常见的初始化方式. 1.构造 List 后使用 List.add 初始化 这是最常规的做法,用起来不太方便. 2.使用 {{}} 双括号语法 这种方式相对方便了一些. 外层的{}定义了一个 LinkedList 的匿名内部类.内层的{}的定义了一个实例初

  • Java内部类和匿名内部类的用法说明

    一.内部类: (1)内部类的同名方法 内部类可以调用外部类的方法,如果内部类有同名方法必须使用"OuterClass.this.MethodName()"格式调用(其中OuterClass与MethodName换成实际外部类名及其方法:this为关键字,表示对外部类的引用):若内部类无同名方法可以直接调用外部类的方法. 但外围类无法直接调用内部类的private方法,外部类同样无法直接调用其它类的private方法.注意:内部类直接使用外部类的方法与该方法的权限与是否static无关,

  • Java内部类与匿名内部类

    目录 一.内部类 什么是内部类 成员内部类 访问特点 二.匿名内部类 前提 格式 使用方式 一.内部类 什么是内部类 将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类. 成员内部类 成员内部类 :定义在类中方法外的类. 定义格式: class 外部类 {class 内部类{}} 在描述事物时,若一个事物内部还包含其他事物,就可以使用内部类这种结构.比如,电脑类Computer 中包含中央处理器类Cpu ,这时, Cpu 就可以使用内部类来描述,定义在成员位置. 代码举例

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

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

  • 详谈Java编程之委托代理回调、内部类以及匿名内部类回调(闭包回调)

    最近一直在看Java的相关东西,因为我们在iOS开发是,无论是Objective-C还是Swift中,经常会用到委托代理回调,以及Block回调或者说是闭包回调.接下来我们就来看看Java语言中是如何实现委托代理回调以及闭包回调的.当然这两个技术点虽然实现起来并不困难,但是,这回调在封装一些公用组件时还是特别有用的.所以今天,还是有必要把Java中的委托代理回调以及闭包回调来单独的拿出来聊一下. 本篇博客我们依然依托于实例,先聊聊委托代理回调的实现和使用场景,然后再聊一下使用匿名内部类来进行回调

  • Java内部类原理与用法实例总结

    本文实例讲述了Java内部类原理与用法.分享给大家供大家参考,具体如下: 一.非静态内部类 public class OutClass { private String name = "outclass"; public void show() { System.out.println(this.name); } public void innerShow() { InnerClass inner = new InnerClass(); inner.show(); inner.outS

  • java内部类原理与用法详解

    本文实例讲述了java内部类原理与用法.分享给大家供大家参考,具体如下: 概念 内部类:可以包含在另外一个类中的类 外部类:包含内部类的类 每个内部类都会被编译为一个独立的类,生成一个独立的字节码文件. 内部类可以方便地访问外部类的私有变量,内部类也可以声明为private从而实现对外完全隐藏. 分类 java中的四种内部类(根据定义的位置和方式划分) -静态内部类 -成员内部类 -方法内部类 -匿名内部类 分类介绍 -静态内部类 特征:在类的内部中存在另一个类,且该类被static修饰 使用范

  • Java内部类原理、概述与用法实例详解

    本文实例讲述了Java内部类原理.概述与用法.分享给大家供大家参考,具体如下: 内部类的概述 /* 内部类概述: 把类定义在其他类的内部,这个类就被称为内部类. 举例:在类A中定义了一个类B,类B就是内部类. 内部的访问特点: A:内部类可以直接访问外部类的成员,包括私有. B:外部类要访问内部类的成员,必须创建对象. */ class Outer { private int num = 10; class Inner { public void show() { //内部类可以直接访问外部类的

  • 详解Java内部类——匿名内部类

    今天来看看另一个更加神奇的类--匿名内部类. 就像它的名字表示的那样,这个类是匿名的,用完之后,深藏功与名,就像扫地僧那样默默潜藏于深山之中.匿名内部类不仅没有名字,连class关键字都省掉了,而且匿名内部类必须继承于某个类或者实现某个接口,长的就像这样: new 父类(参数列表)|实现接口() { //匿名内部类的内部定义 } 来看一个栗子: public abstract class Human { public abstract void walk(); } 这是一个抽象类,如果使用匿名内

  • 深入了解Java内部类的用法

    目录 1.内部类分类和概念 2.局部内部类 3.匿名内部类(重要) 基于接口的匿名内部类 基于类的匿名内部类 一些细节 匿名内部类的最佳实践 4.成员内部类 5.静态内部类 1.内部类分类和概念 java类的五大成员:属性,方法,构造器(构造方法),代码块,内部类 内部类的分类: 定义在外部类局部的位置(比如方法内): 局部内部类(有类名) 匿名内部类(无类名) 定义在外部类成员位置上: 成员内部类(没有static修饰) 静态内部类(有static修饰) 概念:在一个类的内部再定义一个完整的类

  • Java中的匿名内部类小结

    java内部类分为: 成员内部类.静态嵌套类.方法内部类.匿名内部类 . 在java的世界里,提供了匿名内部类语法,用于帮助大家简化代码,本文简要从接口,抽象类以及常规类以代码的形式描述其常用模式. 1. 接口模式 public interface IWriter { void write(); } public static void main(String[] args) { IWriter writer = new IWriter() { @Override public void wri

随机推荐