Класс SQLite Contract - зачем делать внутренний класс статическим? [Дубликат]

Если вы используете этот код на локальном сервере (т. е. ваш компьютер для целей разработки), он не отправит электронное письмо получателю. Что произойдет, он создаст файл .txt в папке с именем mailoutput.

В случае, если вы используете бесплатный сервисный сервис, например 000webhost или hostinger, эти поставщики услуг отключают функцию mail(), чтобы предотвратить непреднамеренное использование электронной почты, спам и т. д. Я предпочитаю вас чтобы связаться с ними, чтобы узнать, поддерживают ли они эту функцию.

Если вы уверены, что поставщик услуг поддерживает функцию mail (), вы можете проверить это руководство по PHP для дальнейшей справки, PHP mail ()

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


Надеюсь, что это помогли.

1522
задан Micha Sprengers 22 April 2016 в 10:14
поделиться

24 ответа

Из учебника Java Tutorial :

Вложенные классы делятся на две категории: статические и нестатические. Вложенные классы, объявленные static, просто называются статическими вложенными классами. Нестатические вложенные классы называются внутренними классами.

Доступ к статическим вложенным классам осуществляется с помощью имени класса:

OuterClass.StaticNestedClass

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

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Объекты, являющиеся экземплярами внутреннего класса, существуют в экземпляре внешнего класса. Рассмотрим следующие классы:

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

Экземпляр InnerClass может существовать только внутри экземпляра OuterClass и имеет прямой доступ к методам и полям его вмещающего экземпляра.

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

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

см.: Учебник по Java - вложенные классы

Для полноты отметим, что там также является внутренним классом без вмещающего экземпляра :

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

Здесь new A() { ... } является внутренним классом , определенным в статическом контексте и не имеет охватывающего экземпляра.

1485
ответ дан Community 22 August 2018 в 18:32
поделиться
  • 1
    Имейте в виду, что вы также можете импортировать статический вложенный класс напрямую, т. Е. Вы можете сделать (вверху файла): import OuterClass.StaticNestedClass;, а затем ссылаться на класс just как OuterClass. – Camilo Díaz Repka 16 July 2011 в 01:22
  • 2
    @Martin есть какое-то конкретное техническое имя для этой идиомы создания внутреннего класса OuterClass.InnerClass innerObject = outerObject.new InnerClass();? – Geek 28 March 2013 в 09:42
  • 3
    Итак, что такое использование частного статического вложенного класса? Я думаю, мы не можем создать экземпляр из него, как OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass (); – RoboAlex 9 May 2013 в 19:56
  • 4
    @Ilya Kogan: Я имел в виду, что знаю, что мы можем обращаться к полям класса родителя статическим или нестатическим (если дочерний класс нестационарный класс), я использовал их функции пару раз, но мне было интересно, какая модель памяти они следуют? Концепции ООП охватывают их как отдельную концепцию? если нет, где они действительно вписываются в ООП. Кажется, мне нравится класс друга :) – Mubashar Ahmad 9 September 2013 в 03:24
  • 5
    @martin, я знаю, что я прихожу к этой теме невероятно поздно, но: Это ваша переменная a, которая является статическим полем класса A. Это не означает анонимный класс, созданный 'new A () {int t () {return 2; }} 'статична, если я просто назначил какой-либо другой объект статическому полю, a, как в: class B {static void main (string s) {Aa = new A ()}} (A & amp; B in тот же пакет) Это не делает A статическим классом. Фраза «статический контекст», в ссылке, указанной в теме, к которой вы привязались, невероятно расплывчато. Фактически, это было отмечено во многих комментариях в этом потоке. – GrantRobertson 19 May 2015 в 18:43

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

OverView

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

Разница

Нестатический Вложенный класс: неявно связан с вмещающим экземпляром содержащего класса, это означает, что можно вызвать методы и получить доступ к окружающим экземплярам. Одно распространенное использование нестатического вложенного класса - это определение класса адаптера.

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

Заключение

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

82
ответ дан Abdellah 22 August 2018 в 18:32
поделиться
  • 1
    : из вашего заключения & quot; в то время как статический не может & quot; , Даже статические экземпляры контейнера? Конечно? – VedX 21 July 2015 в 09:39
  • 2
    Обычным использованием статического вложенного класса является шаблон проектирования ViewHolder в RecyclerView и ListView. – Hamzeh Soboh 18 August 2015 в 09:21
  • 3
    Во многих случаях короткий ответ более ясен и лучше. Это такой пример. – Eric Wang 9 January 2017 в 18:38

В случае создания экземпляра экземпляр нестационарного внутреннего класса создается с ссылкой на объект внешнего класса, в котором он определен. Это означает, что у него есть инклюзивный экземпляр. Но экземпляр статического внутреннего класса создается со ссылкой на класс Outer, а не ссылкой на объект внешнего класса. Это означает, что он не включает экземпляр.

Например:

class A
{
  class B
  {
    // static int x; not allowed here…..    
  }
  static class C
  {
    static int x; // allowed here
  }
}

class Test
{
  public static void main(String… str)
  {
    A o=new A();
    A.B obj1 =o.new B();//need of inclosing instance

    A.C obj2 =new A.C();

    // not need of reference of object of outer class….
  }
}
9
ответ дан Anders Gustafsson 22 August 2018 в 18:32
поделиться
  • 1
    «статическое внутреннее» является противоречием в терминах. Вложенный класс является либо статическим, либо внутренним. – user207421 10 May 2015 в 23:58

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

    class Outter1 {

        String OutStr;

        Outter1(String str) {
            OutStr = str;
        }

        public void NonStaticMethod(String st)  {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            //  below static attribute not permitted
            // static String tempStatic1 = "static";    

            //  below static with final attribute not permitted         
            // static final String  tempStatic1 = "ashish";  

            // synchronized keyword is not permitted below          
            class localInnerNonStatic1 {            

                synchronized    public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /* 
        //  static method with final not permitted
          public static void innerStaticMethod(String str11) { 

                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }                            

        }

        public static  void StaticMethod(String st)     {

            String temp1 = "ashish";
            final String  tempFinal1 = "ashish"; 

            // static attribute not permitted below
            //static String tempStatic1 = "static";     

            //  static with final attribute not permitted below
            // static final String  tempStatic1 = "ashish";                         

            class localInnerNonStatic1 {
                public void innerMethod(String str11) {
                    str11 = temp1 +" sharma";
                    System.out.println("innerMethod ===> "+str11);
                }

                /*
    // static method with final not permitted
    public static void innerStaticMethod(String str11) {  
                    str11 = temp1 +" india";
                    System.out.println("innerMethod ===> "+str11);
                }*/
            }

            // static class not permitted below
            //  static class localInnerStatic1 {   }    

        }

        // synchronized keyword is not permitted
        static  class inner1 {          

            static String  temp1 = "ashish";
            String  tempNonStatic = "ashish";
            // class localInner1 {

            public void innerMethod(String str11) {
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            public static void innerStaticMethod(String str11) {
                //  error in below step
                str11 = temp1 +" india";    
                //str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }
            //}
        }

        //synchronized keyword is not permitted below
        class innerNonStatic1 {             

//This is important we have to keep final with static modifier in non
// static innerclass below
            static final String  temp1 = "ashish";  
            String  tempNonStatic = "ashish";
            // class localInner1 {

            synchronized    public void innerMethod(String str11) {
                tempNonStatic = tempNonStatic +" ...";
                str11 = temp1 +" sharma";
                str11 = str11+ tempNonStatic +" sharma";
                System.out.println("innerMethod ===> "+str11);
            }

            /*
            //  error in below step
            public static void innerStaticMethod(String str11) {   
                            //  error in below step
                            // str11 = tempNonStatic +" india";                     
                            str11 = temp1 +" india";
                            System.out.println("innerMethod ===> "+str11);
                        }*/
                    //}
                }
    }
0
ответ дан Ashish Sharma 22 August 2018 в 18:32
поделиться
  • 1
    Пожалуйста, изучите форматирование своего ответа. – GhostCat 10 October 2017 в 10:50
  • 2
    Очевидно, часть кода. И в случае, если вы не заметили: ваш пример кода очень трудно читать. Даже на моем огромном настольном мониторе я получил горизонтальную полосу прокрутки. Подумайте о том, чтобы добавить свои комментарии выше или ниже того, что они комментируют, вместо позади . – GhostCat 11 October 2017 в 06:12
  • 3
    @GhostCat ОК, я сделал это. – Ashish Sharma 11 October 2017 в 06:53

Вот ключевые различия и сходства между внутренним классом Java и статическим вложенным классом.

Надеюсь, что это поможет!

Внутренний класс

  • к внешнему классу и экземпляру, и статическим методам и полям
  • Связан с экземпляром охватывающего класса, поэтому для его создания сначала нужен экземпляр внешнего класса (обратите внимание на место ключевого слова new ):
    Outerclass.InnerClass innerObject = outerObject.new Innerclass();
    
  • Невозможно определить какие-либо статические элементы сами
  • Не может быть объявления класса или интерфейса

Статический вложенный класс

  • Невозможно получить доступ к методам или полям экземпляра внешнего класса
  • Не связано с каким-либо экземпляром класса включения So, чтобы его создать:
    OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
    

Сходства

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

Зачем использовать Neste d Классы?

Согласно документации Oracle есть несколько причин ( полная документация ):

  • Это способ логически группы классов, которые используются только в одном месте: если класс полезен только для одного другого класса, то логично вставлять его в этот класс и поддерживать вместе. Вложение таких «вспомогательных классов» делает их пакет более упорядоченным.
  • Он увеличивает инкапсуляцию: рассмотрим два класса верхнего уровня: A и B, где B нужен доступ к членам A, которые иначе были бы объявлены частными. Скрывая класс B в классе A, члены A могут быть объявлены частными, а B может получить к ним доступ. Кроме того, сам B может быть скрыт от внешнего мира.
  • Это может привести к более легко читаемому и поддерживаемому коду: Вложение небольших классов в классы верхнего уровня помещает код ближе к тому, где он используется.
23
ответ дан Behzad Bahmanyar 22 August 2018 в 18:32
поделиться

Вложенный класс является очень общим термином: каждый класс, который не является верхним, представляет собой вложенный класс. Внутренний класс - это нестатический вложенный класс. Джозеф Дарси написал очень приятное объяснение о Nested, Inner, Member и Top-Level Classes .

7
ответ дан Bill the Lizard 22 August 2018 в 18:32
поделиться

Термины используются взаимозаменяемо. Если вы хотите быть действительно педантичным, то вы можете определить «вложенный класс» для обозначения статического внутреннего класса, который не имеет закрывающего экземпляра. В коде у вас может быть что-то вроде этого:

public class Outer {
    public class Inner {}

    public static class Nested {}
}

Это не совсем общепринятое определение.

7
ответ дан Daniel Spiewak 22 August 2018 в 18:32
поделиться

Разница заключается в том, что вложенное объявление класса, которое также является статическим, может быть создано вне класса-оболочки.

Если у вас есть объявление вложенного класса, которое является not static, также известный как внутренний класс , Java не позволит вам создать экземпляр, кроме как через класс включения. Объект, созданный из внутреннего класса, связан с объектом, созданным из внешнего класса, поэтому внутренний класс может ссылаться на поля внешнего.

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

0
ответ дан DigitalRoss 22 August 2018 в 18:32
поделиться
  • 1
    Это неверно. Существует специальный синтаксис для создания внутреннего класса вне области охватывающего класса. – user207421 25 June 2017 в 12:58

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

Как внутренний объект класса находится в памяти?

Управление памятью - Внутренний статический класс в Java

Когда в него загружается статический вложенный класс (и статические члены)?

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

В чем преимущество создания внутреннего класса как статического с Java?

0
ответ дан Han XIAO 22 August 2018 в 18:32
поделиться

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

Если статические атрибуты получают экземпляр до того, как класс получает экземпляр через его конструктор, статические атрибуты внутри вложенных статических классов похоже, не создаются экземпляром до тех пор, пока не будет вызван конструктор класса или, по крайней мере, до тех пор, пока не будут указаны первые атрибуты, даже если они отмечены как «final».

Рассмотрим этот пример:

public class C0 {

    static C0 instance = null;

    // Uncomment the following line and a null pointer exception will be
    // generated before anything gets printed.
    //public static final String outerItem = instance.makeString(98.6);

    public C0() {
        instance = this;
    }

    public String makeString(int i) {
        return ((new Integer(i)).toString());
    }

    public String makeString(double d) {
        return ((new Double(d)).toString());
    }

    public static final class nested {
        public static final String innerItem = instance.makeString(42);
    }

    static public void main(String[] argv) {
        System.out.println("start");
        // Comment out this line and a null pointer exception will be
        // generated after "start" prints and before the following
        // try/catch block even gets entered.
        new C0();
        try {
            System.out.println("retrieve item: " + nested.innerItem);
        }
        catch (Exception e) {
            System.out.println("failed to retrieve item: " + e.toString());
        }
        System.out.println("finish");
    }
}

Хотя «вложенные» и «innerItem» объявляются как «статические окончательные». параметр nested.innerItem не выполняется до тех пор, пока не будет создан экземпляр класса (или, по крайней мере, до тех пор, пока не будет указан первый вложенный статический элемент), как вы можете убедиться сами, комментируя и раскомментируя строки, на которые я ссылаюсь, выше. То же самое не относится к «externalItem».

По крайней мере, это то, что я вижу в Java 6.0.

10
ответ дан HippoMan 22 August 2018 в 18:32
поделиться
526
ответ дан informatik01 22 August 2018 в 18:32
поделиться

Я не думаю, что реальная разница стала понятной в приведенных выше ответах.

Сначала, чтобы получить правильные слова:

  • Вложенный класс - это класс, который содержится в другом классе на уровне исходного кода.
  • It является статическим, если вы объявляете его со статическим модификатором.
  • Нестатический вложенный класс называется внутренним классом. (Я остаюсь с нестатическим вложенным классом.)

Ответ Мартина прав до сих пор. Тем не менее, актуальным вопросом является: Какова цель объявления статического кластера вложенным или нет?

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

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

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

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

Более подробные пояснения к хардкору:

Если вы посмотрите на байт-коды Java, которые генерирует компилятор для (нестатического ) вложенный класс может стать еще яснее:

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public <init>(Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

Как вы видите, компилятор создает скрытое поле Container this$0. Это устанавливается в конструкторе, который имеет дополнительный параметр типа Container для указания экземпляра-оболочки. Вы не можете увидеть этот параметр в источнике, но компилятор неявно генерирует его для вложенного класса.

Пример Мартина

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

был бы скомпилирован для вызова чего-то вроде (в байтекодах)

new InnerClass(outerObject)

Для полноты:

Анонимный класс - прекрасный пример нестатического вложенного класса, у которого просто нет имени, связанного с ним, и на него нельзя ссылаться позже.

124
ответ дан jrudolph 22 August 2018 в 18:32
поделиться
  • 1
    «Не существует семантической разницы между статическим вложенным классом и каждым другим классом». За исключением того, что вложенный класс может видеть частные поля / методы родителя, а родительский класс может видеть частные вложенные поля / методы. – Brad Cupit 22 June 2010 в 15:56
  • 2
    Не может ли нестатический внутренний класс вызвать массивные утечки памяти? Как и в случае, каждый раз, когда вы создаете слушателя, вы создаете утечку? – G_V 15 December 2014 в 09:24
  • 3
    @G_V существует определенная вероятность утечек памяти, потому что экземпляр внутреннего класса сохраняет ссылку на внешний класс. Является ли это фактической проблемой, зависит от того, где и как хранятся ссылки на экземпляры внешнего и внутреннего классов. – jrudolph 17 December 2014 в 10:09

Я не думаю, что здесь есть что добавить, большинство ответов прекрасно объясняют различия между статическим вложенным классом и внутренними классами. Однако рассмотрите следующую проблему при использовании вложенных классов и внутренних классов. Как упоминание в нескольких ответах, внутренние классы не могут быть созданы без экземпляра и их вмещающего класса, что означает, что они удерживают указатель на экземпляр их вмещающего класса, что может привести к переполнению памяти или исключению переполнения стека из-за того, что GC не смогут мусор собирать окружающие классы, даже если они больше не используются. Чтобы сделать это, проверьте следующий код:

public class Outer {


    public  class Inner {

    }


    public Inner inner(){
        return new Inner();
    }

    @Override
    protected void finalize() throws Throwable {
    // as you know finalize is called by the garbage collector due to destroying an object instance
        System.out.println("I am destroyed !");
    }
}


public static void main(String arg[]) {

    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();

    // out instance is no more used and should be garbage collected !!!
    // However this will not happen as inner instance is still alive i.e used, not null !
    // and outer will be kept in memory until inner is destroyed
    outer = null;

    //
    // inner = null;

    //kick out garbage collector
    System.gc();

}

Если вы удалите комментарий на // inner = null;, программа выйдет «Я уничтожен!», Но если оставить комментарий, это не будет. Причина в том, что белый внутренний экземпляр по-прежнему ссылается, GC не может его собрать и потому что он ссылается (имеет указатель на) внешний экземпляр, который он также не собирает. Наличие достаточного количества этих объектов в вашем проекте и может закончиться нехваткой памяти. По сравнению со статическими внутренними классами, которые не содержат точку для внутреннего экземпляра класса, поскольку он не связан с экземпляром, а связан с классом. Вышеупомянутая программа может печатать «Я уничтожен!» если вы станете классом Inner static и инстанцируются с помощью Outer.Inner i = new Outer.Inner();

9
ответ дан L Joey 22 August 2018 в 18:32
поделиться

Ориентационный ученик, который является новичком для Java и / или вложенных классов

Вложенные классы могут быть либо: 1. Статические вложенные классы. 2. Нестатические вложенные классы. (также известный как Внутренние классы) => Пожалуйста, запомните это

1.Интерные классы Пример:

class OuterClass  {
/*  some code here...*/
     class InnerClass  {  }
/*  some code here...*/
}

Внутренние классы - это подмножества вложенных классов:

    Внутренний класс
  • - это определенный тип вложенных классов
  • . Внутренние классы - это подмножества вложенных классов
  • . Вы можете сказать, что внутренний класс также является вложенным классом, но вы не можете сказать, что вложенный класс также является внутренним классом .

Специальность класса Inner:

  • экземпляр внутреннего класса имеет доступ ко всем членам внешнего класса, даже к тем, которые отмечены как «частные "

2.Static Вложенные классы: Пример:

class EnclosingClass {
  static class Nested {
    void someMethod() { System.out.println("hello SO"); }
  }
}

Случай 1: Создание статического вложенного класса из не закрывающего класса

class NonEnclosingClass {

  public static void main(String[] args) {
    /*instantiate the Nested class that is a static
      member of the EnclosingClass class:
    */

    EnclosingClass.Nested n = new EnclosingClass.Nested(); 
    n.someMethod();  //prints out "hello"
  }
}

Случай 2: Создание статического вложенного класса из класса-оболочки

class EnclosingClass {

  static class Nested {
    void anotherMethod() { System.out.println("hi again"); } 
  }

  public static void main(String[] args) {
    //access enclosed class:

    Nested n = new Nested(); 
    n.anotherMethod();  //prints out "hi again"
  }

}

Специальность статических классов:

  • Статический внутренний класс будет иметь доступ только к статические члены внешнего класса и не имеют доступа к нестационарным элементам.

Заключение: Вопрос: В чем основное отличие между внутренним классом и статический вложенный класс в Java? Ответ: просто рассмотрите особенности каждого класса, упомянутого выше.

6
ответ дан Marko Bonaci 22 August 2018 в 18:32
поделиться

Я думаю, что люди здесь должны заметить Poster, что: Static Nest Class - это только первый внутренний класс. Например:

 public static class A {} //ERROR

 public class A {
     public class B {
         public static class C {} //ERROR
     }
 }

 public class A {
     public static class B {} //COMPILE !!!

 }

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

4
ответ дан Nikhil Agrawal 22 August 2018 в 18:32
поделиться
  • 1
    Это все ненормально. Все это показывает, что внутренний класс не может содержать статический класс. Часть о «не зависит от того, какой класс содержит ее» бессмысленна, как и следующее предложение. – user207421 24 March 2016 в 05:06

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

class Test{
    private static int x = 1;
        static class A{
        private static int y = 2;
        public static int getZ(){
            return B.z+x;
        }
    }
    static class B{
        private static int z = 3;
        public static int getY(){
            return A.y;
        }
    }
}

class TestDemo{
     public static void main(String[] args){
        Test t = new Test();
        System.out.println(Test.A.getZ());
        System.out.println(Test.B.getY());
    }
}

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

    class Test{
        private int i = 10;
        class A{
            private int i =20;
            void display(){
            int i = 30;
            System.out.println(i);
            System.out.println(this.i);
            System.out.println(Test.this.i);
        }
    }
}
4
ответ дан Pankti 22 August 2018 в 18:32
поделиться

Прежде всего нет такого класса, который называется Static class. Использование модификатора Static с внутренним классом (называемый вложенным классом) говорит о том, что он является статическим членом Outer Class, что означает, что мы можем получить к нему доступ, как и с другими статическими членами, и без какого-либо экземпляра класса Outer. (Которая является преимуществом статического изначально.)

Разница между использованием класса Nested и регулярным внутренним классом:

OuterClass.InnerClass inner = new OuterClass().new InnerClass();

Сначала Мы можем создать экземпляр Outerclass, после чего мы можем получить доступ к Inner.

Но если класс вложен, то синтаксис:

OuterClass.InnerClass inner = new OuterClass.InnerClass();

Использует статический синтаксис как обычную реализацию статического ключевого слова.

2
ответ дан Pritam Banerjee 22 August 2018 в 18:32
поделиться
  • 1
    «... говорит, что это статический член Outer Class, что означает ...». Неверно думать о статическом вложенном классе как о «классе-члене». внешнего класса, но сходства со статическими полями и методами заканчиваются. Статический вложенный класс не "принадлежит" к внешнему классу. Практически все, что имеет значение, статический вложенный класс - это класс свободно стоящего высшего уровня, определение класса которого вложено внутри класса Outer для удобства упаковки (и, надеюсь, потому что существует логическая связь между вложенным классом и внешним классом ... хотя их не должно быть). – scottb 18 October 2013 в 01:03
  • 2
    «статическое внутреннее» является противоречием в терминах. Статические классы существуют на первом уровне вложенности, и по определению они не являются внутренними классами. Очень смущенный. – user207421 28 November 2014 в 04:50

Экземпляр внутреннего класса создается, когда создается экземпляр внешнего класса. Поэтому члены и методы внутреннего класса имеют доступ к членам и методам экземпляра (объекта) внешнего класса. Когда экземпляр внешнего класса выходит за пределы области видимости, также исчезают внутренние экземпляры классов.

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

Статические вложенные классы не связаны с внешним объектом, они быстрее, и они не 't взять память кучи / стека, потому что не нужно создавать экземпляр такого класса. Поэтому эмпирическое правило состоит в том, чтобы попытаться определить статический вложенный класс с максимально возможной областью (private> = class> = protected> = public), а затем преобразовать его во внутренний класс (удалив «статический» идентификатор) и ослабить объем, если это действительно необходимо.

10
ответ дан rmaruszewski 22 August 2018 в 18:32
поделиться
  • 1
    Первое предложение неверно. Существует не такая штука, как « экземпляр внутреннего класса», а экземпляры ее могут быть созданы в любое время после создания внешнего класса. Второе предложение не следует из первого предложения. – user207421 10 May 2015 в 23:55

Внутренний класс и вложенный статический класс в Java - это классы, объявленные внутри другого класса, известного как класс верхнего уровня в Java. В терминологии Java. Если вы объявляете вложенный класс static, он будет вызывать вложенный статический класс в Java, а нестатический вложенный класс просто называется Inner Class.

Что такое Inner Class в Java?

Любой класс, который не является верхним уровнем или объявлен внутри другого класса, известен как вложенный класс и из тех вложенных классов, класс, которые объявлены нестатические известны как класс Inner в Java. в Java есть три типа класса Inner:

1) Локальный внутренний класс - объявляется внутри кодового блока или метода. 2) Анонимный внутренний класс - это класс, который не имеет имени для ссылки и инициализируется в том же месте, где он создается. 3) Внутренний класс члена - объявлен как нестационарный член внешнего класса.

public class InnerClassTest {
    public static void main(String args[]) {      
        //creating local inner class inside method i.e. main() 
        class Local {
            public void name() {
                System.out.println("Example of Local class in Java");

            }
        }      
        //creating instance of local inner class
        Local local = new Local();
        local.name(); //calling method from local inner class

        //Creating anonymous inner class in Java for implementing thread
        Thread anonymous = new Thread(){
            @Override
            public void run(){
                System.out.println("Anonymous class example in java");
            }
        };
        anonymous.start();

        //example of creating instance of inner class
        InnerClassTest test = new InnerClassTest();
        InnerClassTest.Inner inner = test.new Inner();
        inner.name(); //calling method of inner class
    }

     //Creating Inner class in Java
    private class Inner{
        public void name(){
            System.out.println("Inner class example in java");
        }
    }
}

Что такое вложенный статический класс в Java?

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

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

public class NestedStaticExample {
    public static void main(String args[]){  
        StaticNested nested = new StaticNested();
        nested.name();
    }  
    //static nested class in java
    private static class StaticNested{
        public void name(){
            System.out.println("static nested class example in java");
        }
    }
}

Ссылка: Внутренний класс и вложенный Static Class в Java с примером

5
ответ дан roottraveller 22 August 2018 в 18:32
поделиться
  • 1
    "Статический вложенный класс не может получить доступ к нестатическому (экземпляру) элементу данных или методу. & quot; неверен, а вызывает путаницу . Они абсолютно имеют доступ к частной информации об экземплярах - при условии, что они создают экземпляр для доступа к этой информации экземпляра. У них нет закрывающего экземпляра, такого как внутренние классы, но у них есть доступ к частным членам экземпляра закрытого класса. – T.J. Crowder 11 April 2017 в 10:23

Я думаю, что соглашение, которое обычно соблюдается, таково:

  • статический класс в классе верхнего уровня представляет собой вложенный класс
  • нестатический класс в верхнем уровне class является внутренним классом, который имеет еще две формы: локальные классы с именами, объявленные внутри блока, такие как метод или тело конструктора anonymous class - неназванные классы, экземпляры которых создаются в выражениях и операторах

Тем не менее, несколько других моментов для запоминания:

  • Классы верхнего уровня и статический вложенный класс семантически одинаковы, за исключением того, что в случае статического вложенного класса он может статически ссылаться на частные статические поля / методы его класса Outer [parent] и наоборот.
  • Внутренние классы имеют доступ к переменным экземпляра окружающего экземпляра класса Outer [parent]. Однако не все внутренние классы включают экземпляры, например внутренние классы в статических контекстах, например анонимный класс, используемый в статическом блоке инициализации.
  • Анонимный класс по умолчанию расширяет родительский класс или реализует родительский интерфейс, и нет дополнительного предложения для расширения любого другого класса или реализации каких-либо дополнительных интерфейсов. Таким образом, new YourClass(){}; означает class [Anonymous] extends YourClass {} new YourInterface(){}; означает class [Anonymous] implements YourInterface {}

Я чувствую, что больший вопрос остается открытым, какой из них использовать и когда? Хорошо, что в основном зависит от того, с каким сценарием вы сталкиваетесь, но чтение ответа, данное @jrudolph, может помочь вам принять какое-то решение.

24
ответ дан Sumit Singh 22 August 2018 в 18:32
поделиться

Ummm ... внутренний класс IS является вложенным классом ... вы имеете в виду анонимный класс и внутренний класс?

Edit: Если вы на самом деле имели в виду внутреннее или анонимное ... внутренний класс - это просто класс, определенный в классе, например:

public class A {
    public class B {
    }
}

. В то время как анонимный класс является расширением класса, определенного анонимно, поэтому никакого фактического «класса» не определено, как в:

public class A {
}

A anon = new A() { /* you could change behavior of A here */ };

Дальнейшее редактирование:

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

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

29
ответ дан user207421 22 August 2018 в 18:32
поделиться
  • 1
    В соответствии с документацией Java существует разница между внутренним классом и статическим вложенным классом. Статические вложенные классы не имеют ссылок на их охватывающий класс и используются в основном для целей организации. Вы должны увидеть ответ Джегсхемеша для более подробного описания. – mipadi 7 November 2008 в 17:05
  • 2
    Я думаю, что семантическая разница в основном историческая. Когда я написал компилятор C # - & gt; Java 1.1, ссылка на язык Java была очень явной: вложенный класс является статическим, внутренний класс не является (и, следовательно, имеет этот 0 0). Во всяком случае, это сбивает с толку, и я рад, что это уже не проблема. – Tomer Gabel 26 March 2009 в 14:41
  • 3
    вы имели в виду OuterClass.Inner2 inner = outer.new Inner2();? – Erik Allik 12 March 2014 в 04:57
  • 4
    static inner - противоречие в терминах. – user207421 6 June 2016 в 06:30
  • 5
    JLS определяет «внутренний класс», в docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.1.3 , и поэтому невозможно иметь нестатический & quot; внутренний класс " в Java. & Quot; Уплотненный & Quot; НЕ является «еще одним термином, означающим одну и ту же вещь», и НЕ является истинным, что «внутренний класс является классом, определенным в классе (статическим или нет)». Это НЕПРАВИЛЬНАЯ информация. – Lew Bloch 1 July 2016 в 22:54
  • 6
    И внутренние классы также не известны как «классы без стека». Не используйте форматирование кода для текста, который не является кодом, и используйте его для текста. – user207421 2 January 2017 в 06:16
2
ответ дан Pritam Banerjee 5 November 2018 в 15:52
поделиться
0
ответ дан Shomu 5 November 2018 в 15:52
поделиться
29
ответ дан user207421 5 November 2018 в 15:52
поделиться
Другие вопросы по тегам:

Похожие вопросы: