Определение метода в методе [дубликат]

Внутренний класс связан с экземпляром внешнего класса и есть два специальных вида: Локальный класс и Анонимный класс . Анонимный класс позволяет нам объявлять и создавать экземпляр класса одновременно, поэтому делает код кратким. Мы используем их, когда нам нужен локальный класс только один раз, поскольку у них нет имени.

Рассмотрим пример из doc , где мы имеем класс Person:

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    public int getAge() {
        // ...
    }

    public void printPerson() {
        // ...
    }
}

, и у нас есть способ печати элементов, которые соответствуют критериям поиска:

public static void printPersons(
    List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

, где CheckPerson - это интерфейс, такой как:

interface CheckPerson {
    boolean test(Person p);
}

Теперь мы можем использовать анонимный класс, который реализует этот интерфейс, чтобы указать критерии поиска как:

printPersons(
    roster,
    new CheckPerson() {
        public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
        }
    }
);

. Здесь интерфейс очень прост, и синтаксис анонимного класса кажется громоздким и непонятным.

В Java 8 введен термин функциональный интерфейс , который является интерфейсом только с одним абстрактным методом, поэтому можно сказать, CheckPerson является функциональным интерфейсом. Мы можем использовать выражение Lambda Expression , которое позволяет нам передать функцию как аргумент метода как:

printPersons(
                roster,
                (Person p) -> p.getGender() == Person.Sex.MALE
                        && p.getAge() >= 18
                        && p.getAge() <= 25
        );

Вместо стандартного функционального интерфейса Predicate мы можем использовать интерфейс CheckPerson, что дополнительно уменьшит требуемый код.

GuideLines для анонимного класса.

1. Анонимный класс объявляется и инициализируется одновременно.
2. Анонимный класс должен расширять или реализовывать только один класс или интерфейс соответственно
3. Поскольку класс anonymouse не имеет имени, его можно использовать только один раз.

например:

button.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent arg0) {
        // TODO Auto-generated method stub

    }
});

Да, анонимные внутренние классы определенно являются одним из преимуществ Java.

С анонимным внутренним классом у вас есть доступ к конечным и переменным-членам окружающего класса, и это очень удобно в слушателях и т. д. .

Но главное преимущество заключается в том, что внутренний код класса, который (по крайней мере должен быть) тесно связан с окружающим классом / методом / блоком, имеет конкретный контекст (окружающий класс, метод и блок). [/ д2]

Они обычно используются в качестве подробной формы обратного вызова.

Я полагаю, вы могли бы сказать, что они являются преимуществом по сравнению с отсутствием их, и каждый раз нужно создавать именованный класс, но аналогичные концепции реализованы гораздо лучше на других языках (как закрытие или блоки)

Вот пример качания

myButton.addActionListener(new ActionListener(){
    public void actionPerformed(ActionEvent e) {
        // do stuff here...
    }
});

. Хотя это все еще бесполезно многословно, это намного лучше, чем заставлять вас определять названный класс для каждого раздающего прослушивателя, подобного этому (хотя в зависимости от ситуации и повторного использования это может быть лучшим подходом)

new Thread() {
        public void run() {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                System.out.println("Exception message: " + e.getMessage());
                System.out.println("Exception cause: " + e.getCause());
            }
        }
    }.start();

Это также один из примеров анонимного внутреннего типа с использованием thread

Анонимный внутренний класс используется в следующем сценарии:

1.) Для переопределения (подкласс), когда определение класса не используется, кроме текущего случая:

class A{
   public void methodA() {
      System.out.println("methodA");
    }
}
class B{
    A a = new A() {
     public void methodA() {
        System.out.println("anonymous methodA");
     }
   };
}

2 .) Для реализации интерфейса, когда реализация интерфейса требуется только для текущего случая:

interface interfaceA{
   public void methodA();
}
class B{
   interfaceA a = new interfaceA() {
     public void methodA() {
        System.out.println("anonymous methodA implementer");
     }
   };
}

3.) Аргумент Определенный Анонимный внутренний класс:

 interface Foo {
   void methodFoo();
 }
 class B{
  void do(Foo f) { }
}

class A{
   void methodA() {
     B b = new B();
     b.do(new Foo() {
       public void methodFoo() {
         System.out.println("methodFoo");
       } 
     });
   } 
 } 

Лучший способ оптимизации кода. Кроме того, мы можем использовать для переопределения метод класса или интерфейса.

import java.util.Scanner;
abstract class AnonymousInner {
    abstract void sum();
}

class AnonymousInnerMain {
    public static void main(String []k){
        Scanner sn = new Scanner(System.in);
        System.out.println("Enter two vlaues");
            int a= Integer.parseInt(sn.nextLine());
            int b= Integer.parseInt(sn.nextLine()); 
        AnonymousInner ac = new AnonymousInner(){
            void sum(){
                int c= a+b;
                System.out.println("Sum of two number is: "+c);
            }
        };
        ac.sum();
    }

}

Вы можете использовать анонимный класс

TreeSet treeSetObj = new TreeSet(new Comparator()
{
    public int compare(String i1,String i2)
    {
        return i2.compareTo(i1);
    }
});

Вы используете его в ситуациях, когда вам нужно создать класс для определенной цели внутри другой функции, например, в качестве слушателя, как runnable (для создания потока) и т. д.

Идея что вы вызываете их изнутри кода функции, чтобы вы никогда не ссылались на них в другом месте, поэтому вам не нужно их называть. Компилятор просто перечисляет их.

Они по сути являются синтаксическим сахаром и обычно должны перемещаться в другом месте по мере их роста.

Я не уверен, является ли это одним из преимуществ Java, хотя, если вы их используете (и мы все часто используем их, к сожалению), то вы можете утверждать, что они одни.

Анонимный внутренний класс может быть полезным, предоставляя различные реализации для разных объектов. Но он должен использоваться очень экономно, поскольку он создает проблему для удобочитаемости программы.

Я иногда использую их в качестве синтаксического взлома для создания карты:

Map map = new HashMap() {{
   put("key", "value");
}};

vs

Map map = new HashMap();
map.put("key", "value");

Он сохраняет некоторую избыточность при выполнении множества операторов put. Тем не менее, у меня также возникают проблемы с этим, когда внешний класс должен быть сериализован посредством удаленного доступа.

Кажется, здесь никто не упоминается, но вы также можете использовать анонимный класс для хранения аргумента generic type (который обычно теряется из-за стирания типа) :

public abstract class TypeHolder<T> {
    private final Type type;

    public TypeReference() {
        // you may do do additional sanity checks here
        final Type superClass = getClass().getGenericSuperclass();
        this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }

    public final Type getType() {
        return this.type;
    }
}

Если вы экземпляр этого класса анонимным способом

TypeHolder<List<String>, Map<Ineger, Long>> holder = 
    new TypeHolder<List<String>, Map<Ineger, Long>>() {};

, тогда такой экземпляр holder будет содержать неидентифицированное определение пройденного типа.

Использование

Это очень удобно для создания валидаторов / десериализаторов. Кроме того, вы можете создавать типичный тип с отражением (так что если вы когда-либо хотели сделать new T() в параметризованном типе - приветствуется!) [/ ​​G1].