Запрос на понимание PowerMockito и частного статического класса для создания экземпляров [duplicate]

Преимущество внутреннего класса -

1. однократное использование
2. поддерживает и улучшает инкапсуляцию
3. читаемость
4. частное поле access

Без существующего внутреннего класса внешнего класса не будет существовать.

class car{
    class wheel{

    }
}

Существует четыре типа внутреннего класса.

1. нормальный внутренний класс
2. Метод Локальный Внутренний класс
3. Анонимный внутренний класс
4. статический внутренний класс

point ---

1. из статического внутреннего класса, мы можем получить доступ только к статическому члену внешнего класса.
2. Внутри внутреннего класса мы cananot объявим статический член.
3. inorder to вызвать обычный внутренний класс в статической области внешнего класса. Outer 0=new Outer(); Outer.Inner i= O.new Inner();
4. inorder для вызова нормального внутреннего класса в области экземпляра внешнего класса. Inner i=new Inner();
5. inorder для вызова нормального внутреннего класса вне внешнего класса. Outer 0=new Outer(); Outer.Inner i= O.new Inner();
6. внутри Внутренний класс Этот указатель на внутренний класс. this.member-current inner class outerclassname.this--outer class
7. для встроенного модификатора внутреннего класса - public, default, final,abstract,strictfp,+private,protected,static
8. external $ inner - это имя внутреннего имени класса.
9. внутренний класс внутри метода экземпляра, тогда мы можем использовать статический и экземплярный класс внешнего класса.

10.inner class внутри статического метода, тогда мы можем получить доступ только к статическому полю

внешний класс.

class outer{

    int x=10;
    static int y-20;

    public void m1() {
        int i=30;
        final j=40;

        class inner{

            public void m2() {
                // have accees x,y and j
            }
        }
    }
}

статический вложенный класс похож на любой другой внешний класс, так как он не имеет доступа к внешним членам класса.

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

Пример такого использования можно найти в файле Android R.java (resources). В папке «Res» для Android содержатся макеты (содержащие экраны), выпадающая папка (содержащая изображения, используемые для проекта), папка значений (которая содержит строковые константы) и т. Д.

Sine все папки являются частью папки Res , инструмент android создает файл R.java (resources), который внутри содержит множество статических вложенных классов для каждой из своих внутренних папок.

Вот внешний вид файла R.java, сгенерированного в android: Здесь они используются только для удобства упаковки.

/* AUTO-GENERATED FILE.  DO NOT MODIFY.
 *
 * This class was automatically generated by the
 * aapt tool from the resource data it found.  It
 * should not be modified by hand.
 */

package com.techpalle.b17_testthird;

public final class R {
    public static final class drawable {
        public static final int ic_launcher=0x7f020000;
    }
    public static final class layout {
        public static final int activity_main=0x7f030000;
    }
    public static final class menu {
        public static final int main=0x7f070000;
    }
    public static final class string {
        public static final int action_settings=0x7f050001;
        public static final int app_name=0x7f050000;
        public static final int hello_world=0x7f050002;
    }
}

Использование статического вложенного класса, а не нестатического, в некоторых случаях может сэкономить места. Например: реализация Comparator внутри класса, скажем, Student.

public class Student {
  public static final Comparator<Student> BY_NAME = new ByName();
  private final String name;
  ...
  private static class ByName implements Comparator<Student> {
    public int compare() {...}
  }
}

Тогда static гарантирует, что класс Student имеет только один компаратор, а не создает экземпляр нового при каждом новом экземпляр студента.

Простой пример:

package test;

public class UpperClass {
public static class StaticInnerClass {}

public class InnerClass {}

public static void main(String[] args) {
    // works
    StaticInnerClass stat = new StaticInnerClass();
    // doesn't compile
    InnerClass inner = new InnerClass();
}
}

Если нестатический класс не может быть создан, кроме как в экземпляре верхнего класса (поэтому не в примере, где main является статической функцией)

Из http://docs.oracle.com/javase/tutorial/java/javaOO/whentouse.html :

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

На мой взгляд, вопрос должен быть наоборот, когда вы видите внутренний класс - действительно ли действительно должен быть внутренним классом, с дополнительной сложностью и неявным (а не явная и ясная, IMO) ссылка на экземпляр содержащего класса?

Имейте в виду, я предвзятый как вентилятор C # - у C # нет эквивалента внутренних классов, хотя он имеет вложенные типы. Я не могу сказать, что я пропустил внутренние классы:)

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

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

class OuterClass {
    private OuterClass(int x) {
        System.out.println("x: " + x);
    }

    static class InnerClass {
        public static void test() {
            OuterClass outer = new OuterClass(1);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass.test();
        // OuterClass outer = new OuterClass(1); // It is not possible to create outer instance from outside.
    }
}

Это выведет x: 1

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

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

Это немного похоже на то, почему я всегда делаю свои переменные окончательными на Java - если они не окончательные, я знаю с ними что-то смешное. Если вы используете внутренний класс вместо статического вложенного класса, должна быть веская причина.