Java 如何使用匿名内部类？

我创建这两个类是为了利用匿名内部类的概念。 类1有一个静态的内部类。第二类使用它。但是我不明白如何调用内部类的方法。请帮帮我

第一类

public class outerclass {
  outerclass() {
    System.out.println("Constructor of new class");
  }

  public void showthis(String str) {
    System.out.println(str);
  }

  static class insideclass {
    insideclass() {
      System.out.println("This is inside class constructor");
    }

    public void nowshowthis(String str) {
      System.out.println(str);
    }
  }
}

第二类

public class helloworld {
  public static void main(String args[]) {
    //this is an object of the outer class
    outerclass example=new outerclass();
    //How do i make an anonymous inner class and call the method "nowshowthis()"
  }
}

---

让我从眼前的问题中解脱出来如果您的内部类是非静态的，那么这就是如何实例化它：（假设

示例

是

外部类

类型的对象）

对于

静态public

内部类，您甚至不需要外部类的实例。只需执行此操作（非常类似于访问公共静态变量）

你试过这个吗

这是怎么回事？在您的情况下，您并不是在处理匿名内部类。它实际上只是一个普通的香草内部类。（我无法解释你为什么要这么做。）

那么什么是匿名类，我们在哪里使用它呢？匿名类就像是一次性使用的类的实例。当您实现某些接口时，其中一个示例浮出水面。。。但你不需要以其他方式使用它。例如，您希望将处理程序附加到按钮。您可以像这样做（假设示例）

---

你明白了吗？

让我从眼前的问题中解脱出来吧如果您的内部类是非静态的，那么这就是如何实例化它：（假设

示例

是

外部类

类型的对象）

对于

静态public

内部类，您甚至不需要外部类的实例。只需执行此操作（非常类似于访问公共静态变量）

你试过这个吗

这是怎么回事？在您的情况下，您并不是在处理匿名内部类。它实际上只是一个普通的香草内部类。（我无法解释你为什么要这么做。）

那么什么是匿名类，我们在哪里使用它呢？匿名类就像是一次性使用的类的实例。当您实现某些接口时，其中一个示例浮出水面。。。但你不需要以其他方式使用它。例如，您希望将处理程序附加到按钮。您可以像这样做（假设示例）

---

您看到了吗？

内部类是一个非静态类，因此必须通过外部类的实例访问它，如下所示：

new outerclass（）.new insideclass（）.nowshowthis（）
内部类是一个非静态类，因此必须通过外部类的实例访问它，如下所示：

new outerclass（）.new insideclass（）.nowshowthis（）
不是匿名内部类。以下是匿名内部类的示例：

class InnerClassDemo {
  public static void main(String[] args) {
    ActionListener a = new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        System.out.println(e.getActionCommand());
      }
    };
    // now a is the only instance of an anonymous inner class implementing the ActionListener interface
  }
}

当然，您也可以使用自己的接口或类执行此操作：

class InnerClassDemo {
  public class InsideClass {
      InsideClass() {
          System.out.println("This is inside class constructor");
      }

      public void nowshowthis(String str) {
          System.out.println(str);
      }
  }

  public static void main(String[] args) {
    InsideClass anonym = new InsideClass() {
      @Override
      public void nowshowthis(String str) {
          System.out.println("anonymous inner class override: "+str);
      }
    }
    InsideClass normalInstance = new InsideClass();
    anonym.noshowthis("test");
    normalInstance.noshowthis("test");
  }
}

您的输出将是

anonymous inner class override: test
test

因此，
anonyman
是
insidelclass
的匿名内部类实现的实例，而
normalInstance
只是类
insidelclass
的普通实例，而不是匿名内部类。以下是匿名内部类的示例：

class InnerClassDemo {
  public static void main(String[] args) {
    ActionListener a = new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        System.out.println(e.getActionCommand());
      }
    };
    // now a is the only instance of an anonymous inner class implementing the ActionListener interface
  }
}

public class HelloWorld {

    public static void main(String args[])
        {


        outerclass.insideclass example= new outerclass.insideclass();

        example.nowshowthis("Hello");


    }
}

当然，您也可以使用自己的接口或类执行此操作：

class InnerClassDemo {
  public class InsideClass {
      InsideClass() {
          System.out.println("This is inside class constructor");
      }

      public void nowshowthis(String str) {
          System.out.println(str);
      }
  }

  public static void main(String[] args) {
    InsideClass anonym = new InsideClass() {
      @Override
      public void nowshowthis(String str) {
          System.out.println("anonymous inner class override: "+str);
      }
    }
    InsideClass normalInstance = new InsideClass();
    anonym.noshowthis("test");
    normalInstance.noshowthis("test");
  }
}

您的输出将是

anonymous inner class override: test
test

因此，
anonyman
是
insidelclass
的匿名内部类实现的实例，而
normalInstance
只是类
insidelclass
的普通实例

public class HelloWorld {

    public static void main(String args[])
        {


        outerclass.insideclass example= new outerclass.insideclass();

        example.nowshowthis("Hello");


    }
}

或者，将nowshowthis方法设为静态，可以这样调用：

outerclass.insideclass.nowshowthis("Howdy. This method is static.");

或者，将nowshowthis方法设为静态，可以这样调用：

outerclass.insideclass.nowshowthis("Howdy. This method is static.");

匿名内部类是在另一个类的方法体中创建和定义的内部类。本质上，您是在从抽象定义动态创建一个具体类。到目前为止，您的InnerClass类实际上只是一个常规的内部类，这意味着非匿名

如果您想尝试匿名内部类，我能想到的最简单的方法是将您的内部类更改为接口，如下所示：

public interface InnerClass{
    public void doSomething();
}

所以在此刻，内心世界是蹲着的；它在定义之前没有任何意义。接下来，您需要更改OuterClass的工作方式。将showThis（）函数更改如下：

public showThis(InnerClass innerObj){
    innerObj.doSomething();
}

现在我们有外部类要求内部类实例做一些事情，但是我们仍然没有定义我们希望它做什么。这就是神奇之处——在main方法中，您将定义内部类实例的实际外观：

public static void main (String[] args){
    OuterClass outer = new OuterClass();

    // This is the key part: Here you are creating a new instance of inner class 
    // AND defining its body. If you are using Eclipse, and only write the 
    // new InnerClass() part, you'll notice that the IDE complains that you need 
    // to implement the doSomething() method, which you will do as though you
    // were creating a plain 'ol class definition
    outer.showThis(new InnerClass(){ 
        public void doSomething(){
            System.out.println("This is the inner anonymous class speaking!");
        }
    });
}

在实践中，我并没有过多地使用匿名内部类，但是了解它们很有用。在进行GUI编程时，我经常使用它们来定义GUI控制事件的侦听器，例如按钮单击

另外，正如其他人所提到的，请记住Java标准中类名的第一个字母是大写字母，我在这里已经完成了。您将希望遵循该标准，因为它使其他人更容易阅读您的代码，并且当您查看一个类和一个对象时，一眼就可以很容易地分辨出来

无论如何，希望这能有所帮助。
匿名内部类是在另一个类的方法体中创建和定义的。本质上，您是在从抽象定义动态创建一个具体类。到目前为止，您的InnerClass类实际上只是一个常规的内部类，这意味着非匿名

如果您想尝试匿名内部类，我能想到的最简单的方法是将您的内部类更改为接口，如下所示：

public interface InnerClass{
    public void doSomething();
}

所以在此刻，内心世界是蹲着的；它在定义之前没有任何意义。接下来，您需要更改OuterClass的工作方式。将showThis（）函数更改如下：

public showThis(InnerClass innerObj){
    innerObj.doSomething();
}

现在我们有外部类要求内部类实例做一些事情，但是我们仍然没有定义我们希望它做什么。这就是魔法发生的地方——在你的主要方法中，哟