Использование внутреннего класса

Ответ 1

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

Лучший пример, который я могу представить, - это положить класс Node внутри LinkedList. Узлы имеют смысл только для LinkedList, поэтому они существуют только внутри одного. Никто, кроме LinkedList, не заботится о узлах или не должен иметь к ним доступ.

Ответ 2

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

Пройдите эту ссылку....

http://www.javaworld.com/javaworld/javaqa/2000-03/02-qa-innerclass.html

Ответ 3

Также, как вы знаете, в Java существуют вложенные классы, которые являются статической внутренней классовой.

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

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

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

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

    public class Foo {
    private int param1;
    private int param2;
    private int param3;

    private Foo(FooBuilder builder) {
        this.param1 = builder.param1;
        this.param2 = builder.param2;
        this.param3 = builder.param3;
    }

    public int getParam1() {
        return param1;
    }

    public void setParam1(int param1) {
        this.param1 = param1;
    }

    public int getParam2() {
        return param2;
    }

    public void setParam2(int param2) {
        this.param2 = param2;
    }

    public int getParam3() {
        return param3;
    }

    public void setParam3(int param3) {
        this.param3 = param3;
    }

    public static class FooBuilder {
        private int param1;
        private int param2;
        private int param3;

        public FooBuilder() {
        }

        public FooBuilder withParameter1(int param1) {
            this.param1 = param1;
            return this;
        }

        public FooBuilder withParameter2(int param2) {
            this.param2 = param2;
            return this;
        }

        public FooBuilder withParameter3(int param3) {
            this.param3 = param3;
            return this;
        }

        public Foo build() {
            return new Foo(this);
        }
    }
}

Этот пример иллюстрирует в листе одну из причин, почему нам нужны такие классы

2) Второе различие между внутренними и статическими внутренними классами состоит в том, что первый всегда имеет указатель на родительский класс. Компонент Actully создает синтетический член поля для нестатического внутреннего класса типа его родителя, поэтому по этой причине мы можем обращаться к закрытым членам родительского класса. У статической внутренней оболочки нет такого сгенерированного элемента поля. Например, у нас есть простой родительский класс с объявленным нестационарным внутренним классом:

public class Foo {
    public class FooBuilder {
    }
}

но на самом деле, если принять во внимание байтовый код, он выглядит так:

public class Foo {
    public class FooBuilder {
        private Foo generatedNameHere;
    }
}

если вы хотите, вы можете определить этот код сгенерированного байта.

Ответ 4

Одно из внутренних классов:

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

//первый случай; может реализоваться, если два класса являются интерфейсом

interface A {  }
interface B {  }

class X implements A, B { }

//второй случай; вы можете расширить только один класс. Этот внутренний класс case может также наследовать другой класс, а

 class D {  }
 abstract class E { }
 class Z extends D {
    void method() {
      return new E()  {   };   //Anonymous inner class
    }
 }

Ответ 5

• Если вы хотите указать класс, имеющий значение только в контексте с ограниченным.

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

• Когда внутренний класс не используется нигде, кроме встроенного.

• Вы используете анонимные внутренние классы для указания только операции, например, если вы хотите сортировать коллекцию, вы указываете класс Comparable только для сравнения одного метода.

    Collections.sort(employments, new Comparator<Employment>() {
  
  
  

      @Override
      public int compare(Employment o1, Employment o2) {
          return o1.getStartDate().before(o2.getStartDate()) ? 1 : -1 ;
      }
  });
  

  Код>

Ответ 6

• С внутренними классами вы можете получить доступ к закрытым членам охватывающего класса.
• Они полезны для реализации интерфейса, которые используются только классом-оболочкой (обработчики событий в приложении).
• Они полезны для обеспечения мелкозернистого доступа и создания контроля над реализацией интерфейса, которая извлекается извне (возможно, что-то вроде реализации Iterator).