instancia - java classe dentro de outra classe




Classe interna de Java e classe aninhada estática (16)

Diferença entre a classe aninhada estática e não estática em Java

1) A classe estática aninhada não precisa de referência da classe Outer, mas a classe aninhada não estática ou a classe Inner requerem uma referência da classe Outer. Você não pode criar uma instância da classe Inner sem criar uma instância da classe Outer. Esta é de longe a coisa mais importante a considerar ao tornar uma classe aninhada estática ou não estática.

2) classe estática é realmente membro estático da classe e pode ser usado em contexto estático, por exemplo, método estático ou bloco estático da classe exterior.

3) Outra diferença entre a classe aninhada estática e não estática é que você não pode acessar membros não estáticos, por exemplo, método e campo, diretamente na classe estática aninhada. Se você fizer isso, você receberá um erro como "membro não estático não pode ser usado no contexto estático". Enquanto a classe Inner pode acessar membros estáticos e não estáticos da classe Outer.

public class OuterClass {
    private static String message = "Hello JAVA";

    // How to create instance of static and non static nested class
    public static void main(String... args) {

        // creating instance of nested Static class
        InnerClassStatic printer = new InnerClassStatic();

        //calling non static method of nested static class
        printer.printMessage();

        // creating instance of non static nested class or InnerClass class
        // In order to create instance of InnerClass class you need an OuterClass class instance
        OuterClass outerClass = new OuterClass(); //outerClass class instance for creating non static nested class

        InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();  //calling non static method of InnerClass class

        // we can also combine above steps in one step to create instance of InnerClass class
        InnerClass nonStaticIner = new OuterClass().new InnerClass();

        nonStaticIner.display(); // similarly you can now call InnerClass class method
    }


    // Static nested class
    private static class InnerClassStatic {
        //Only static member of OuterClass class is directly accessible in nested static class

        public void printMessage() {
            // Compile time error if message field is not static
            System.out.println("Message from nested static class : " + message);
        }
    }

    //non static nested class - also called InnerClass class
    private class InnerClass {

        // Both static and non static member of OuterClass class is accessible in this InnerClass class
        public void display() {
            System.out.println(" Message from non static nested or InnerClass class : " + message);
        }
    }
}

Saída:

Message from nested static class : Hello JAVA
Message from non static nested or Inner class : Hello JAVA
Message from non static nested or Inner class : Hello JAVA

Isso é tudo sobre a diferença entre a classe aninhada estática e não estática em Java. Até agora, tocamos apenas a classe Inner do membro e não discutimos outros dois tipos na classe Inner, por exemplo, Local class e Anonymous Inner class. Neste tutorial Java, vimos O que é classe estática aninhada em Java e Como criar uma instância de ambas as classes estática e não estática aninhada em Java.

Em resumo, é fácil criar uma instância de classe estática aninhada, já que ela não requer uma instância da classe Outer enquanto uma classe aninhada não estática, por exemplo, a classe Inner sempre precisará de uma instância da classe Outer e não pode existir sem a classe Outer. Se você tiver que escolher entre estática vs classe não estática do que preferir classe aninhada estática, se puder usar isso.

Qual é a principal diferença entre uma classe interna e uma classe aninhada estática em Java? O design / implementação desempenha um papel na escolha de um deles?


A instância da classe interna é criada quando a instância da classe externa é criada. Portanto, os membros e métodos da classe interna têm acesso aos membros e métodos da instância (objeto) da classe externa. Quando a instância da classe externa sai do escopo, também as instâncias da classe interna deixam de existir.

A classe aninhada estática não tem uma instância concreta. É apenas carregado quando é usado pela primeira vez (assim como os métodos estáticos). É uma entidade completamente independente, cujos métodos e variáveis ​​não têm acesso às instâncias da classe externa.

As classes aninhadas estáticas não são acopladas ao objeto externo, são mais rápidas e não recebem memória heap / pilha, porque não é necessário criar uma instância dessa classe. Portanto, a regra é tentar definir a classe aninhada estática, com o escopo limitado possível (private> = class> = protected> = public), e então convertê-la para a classe interna (removendo o identificador "estático") e soltar o escopo, se é realmente necessário.


Aqui estão as principais diferenças e semelhanças entre a classe interna Java e a classe aninhada estática.

Espero que ajude!

Classe interna

  • Pode acessar a classe externa tanto a instância quanto os métodos e campos estáticos
  • Associado à instância de inclusão da classe , para instanciá-lo primeiro, precisa de uma instância da classe externa (note new keyword place):

    Outerclass.InnerClass innerObject = outerObject.new Innerclass();
  • Não é possível definir nenhum membro estático

  • Não é possível ter declaração de classe ou interface

Classe aninhada estática

  • Não é possível acessar métodos ou campos da instância de classe externa

  • Não associado a nenhuma instância da classe envolvente Portanto, para instanciá-lo:

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

Semelhanças

  • Ambas as classes internas podem acessar até mesmo campos privados e métodos de classe externa
  • Também a classe Outer tem acesso a campos privados e métodos de classes internas
  • Ambas as classes podem ter modificador de acesso privado, protegido ou público

Por que usar classes aninhadas?

De acordo com a documentação da Oracle, existem vários motivos ( documentação completa ):

  • É uma maneira de agrupar logicamente classes que são usadas apenas em um lugar: se uma classe é útil para apenas uma outra classe, é lógico incorporá-la a essa classe e manter as duas juntas. Aninhar essas "classes auxiliares" torna seu pacote mais simplificado.

  • Aumenta o encapsulamento: Considere duas classes de nível superior, A e B, em que B precisa de acesso a membros de A que, de outra forma, seriam declarados privados. Ao ocultar a classe B dentro da classe A, os membros de A podem ser declarados privados e B pode acessá-los. Além disso, o próprio B pode ser escondido do mundo exterior.

  • Isso pode levar a um código mais legível e sustentável: Agrupar pequenas classes nas classes de nível superior coloca o código mais próximo de onde ele é usado.


Classe aninhada: classe dentro da classe

Tipos:

  1. Classe aninhada estática
  2. Classe aninhada não estática [classe interna]

Diferença:

Classe aninhada não estática [classe interna]

No objeto de classe aninhada não estático da classe interna existe dentro do objeto da classe externa. Assim, esse membro de dados da classe externa é acessível para a classe interna. Então, para criar um objeto de classe interna, devemos criar primeiro o objeto da classe externa.

outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass(); 

Classe aninhada estática

No objeto de classe aninhada estático da classe interna não é necessário o objeto da classe externa, porque a palavra "estática" não indica a necessidade de criar um objeto.

class outerclass A {
    static class nestedclass B {
        static int x = 10;
    }
}

Se você quiser acessar x, escreva o seguinte método interno

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

Em termos simples, precisamos de classes aninhadas principalmente porque o Java não fornece closures.

Classes Aninhadas são classes definidas dentro do corpo de outra classe envolvente. Eles são de dois tipos - estáticos e não estáticos.

Eles são tratados como membros da classe envolvente, portanto, você pode especificar qualquer um dos quatro especificadores de acesso - private, package, protected, public . Não temos esse luxo com classes de nível superior, que só podem ser declaradas public ou privadas de pacotes.

Classes internas, também conhecidas como classes Não-empilhamento, têm acesso a outros membros da classe superior, mesmo se forem declaradas como privadas, enquanto as classes estáticas aninhadas não têm acesso a outros membros da classe superior.

public class OuterClass {
    public static class Inner1 {
    }
    public class Inner2 {
    }
}

Inner1 é nossa classe interna estática e Inner2 é nossa classe interna que não é estática. A principal diferença entre eles, você não pode criar uma instância Inner2 sem um Outer, onde você pode criar um objeto Inner1 independente.

Quando você usaria a classe Inner?

Pense em uma situação em que a Class A e a Class B estão relacionadas, a Class B precisa acessar Class A membros da Class A e a Class B está relacionada apenas à Class A As aulas internas entram em cena.

Para criar uma instância de classe interna, você precisa criar uma instância de sua classe externa.

OuterClass outer = new OuterClass();
OuterClass.Inner2 inner = outer.new Inner2();

ou

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

Quando você usaria classe interna estática?

Você definiria uma classe interna estática quando souber que ela não tem nenhum relacionamento com a instância da classe class / top anexa. Se a sua classe interna não usa métodos ou campos da classe externa, é apenas um desperdício de espaço, então torne-a estática.

Por exemplo, para criar um objeto para a classe aninhada estática, use esta sintaxe:

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

A vantagem de uma classe aninhada estática é que ela não precisa que um objeto da classe / classe superior contida funcione. Isso pode ajudá-lo a reduzir o número de objetos que seu aplicativo cria no tempo de execução.


Eu acho que a convenção geralmente seguida é esta:

  • classe estática dentro de uma classe de nível superior é uma classe aninhada
  • classe não estática dentro de uma classe de nível superior é uma classe interna , que possui ainda mais duas formas:
    • classe local - classes nomeadas declaradas dentro de um bloco como um método ou corpo de construtor
    • classe anônima - classes sem nome cujas instâncias são criadas em expressões e declarações

No entanto, alguns outros pontos para lembrar são:

  • As classes de nível superior e a classe aninhada estática são semanticamente iguais, exceto que, no caso de uma classe aninhada estática, ela pode fazer referência estática a campos / métodos estáticos privados de sua classe Outer [parent] e vice-versa.

  • Classes internas têm acesso a variáveis ​​de instância da instância delimitadora da classe Outer [parent]. No entanto, nem todas as classes internas possuem instâncias delimitadoras, por exemplo, classes internas em contextos estáticos, como uma classe anônima usada em um bloco inicializador estático, não.

  • Por padrão, a classe anônima estende a classe pai ou implementa a interface pai e não há cláusula adicional para estender qualquer outra classe ou implementar mais interfaces. Assim,

    • new YourClass(){}; significa class [Anonymous] extends YourClass {}
    • new YourInterface(){}; significa class [Anonymous] implements YourInterface {}

Eu sinto que a grande questão que permanece em aberto é qual usar e quando? Bem, isso depende principalmente do cenário com o qual você está lidando, mas ler a resposta dada por @jrudolph pode ajudá-lo a tomar alguma decisão.


Há uma sutileza sobre o uso de classes estáticas aninhadas que podem ser úteis em determinadas situações.

Considerando que os atributos estáticos são instanciados antes que a classe seja instanciada através de seu construtor, atributos estáticos dentro de classes estáticas aninhadas não parecem ser instanciados até que o construtor da classe seja invocado, ou pelo menos não até que os atributos sejam referenciados pela primeira vez, mesmo se eles são marcados como 'finais'.

Considere este exemplo:

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");
    }
}

Mesmo que 'aninhado' e 'innerItem' sejam declarados como 'final estático'. a configuração de nested.innerItem não ocorre até que a classe seja instanciada (ou pelo menos não até que o item estático aninhado seja mencionado pela primeira vez), como você pode ver por si mesmo comentando e descomentando as linhas a que me refiro, acima. O mesmo não vale para 'outerItem'.

Pelo menos é isso que estou vendo no Java 6.0.


No caso da criação da instância, a instância da classe interna não estática é criada com a referência do objeto da classe externa na qual ela está definida. Isso significa que tem instância inclinada. Mas a instância da classe interna estática é criada com a referência da classe Outer, não com a referência do objeto da classe externa. Isto significa que não tem instância inclusa.

Por exemplo:

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….
  }
}

Alunos de segmentação, que são novatos em Java e / ou em turmas aninhadas

As classes aninhadas podem ser:
1. Classes estáticas aninhadas.
2. Classes aninhadas não estáticas. (também conhecidas como classes internas ) => Por favor, lembre-se disto


Classes internas 1.
Exemplo:

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


Classes internas são subconjuntos de classes aninhadas:

  • classe interna é um tipo específico de classe aninhada
  • classes internas são subconjuntos de classes aninhadas
  • Você pode dizer que uma classe interna também é uma classe aninhada, mas você NÃO pode dizer que uma classe aninhada também é uma classe interna .

Especialidade da classe interna:

  • instância de uma classe interna tem acesso a todos os membros da classe externa, mesmo aqueles que estão marcados como "privados"


2. Classes Estáticas Aninhadas:
Exemplo:

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

Caso 1: instanciando uma classe aninhada estática de uma classe sem inclusão

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"
  }
}

Caso 2: instanciando uma classe aninhada estática de uma classe de inclusão

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"
  }

}

Especialidade de classes estáticas:

  • A classe interna estática só teria acesso aos membros estáticos da classe externa e não teria acesso a membros não estáticos.

Conclusão:
Pergunta: Qual é a principal diferença entre uma classe interna e uma classe aninhada estática em Java?
Resposta: basta passar por detalhes de cada classe mencionada acima.


Classe interna e classe estática aninhada em Java são classes declaradas dentro de outra classe, conhecida como classe de nível superior em Java. Na terminologia Java, se você declarar uma classe aninhada estática, ela será chamada de classe estática aninhada em Java, enquanto que as classes aninhadas não estáticas são simplesmente chamadas de Classe Interna.

O que é classe interna em Java?

Qualquer classe que não seja de nível superior ou declarada dentro de outra classe é conhecida como classe aninhada e fora dessas classes aninhadas, as classes que são declaradas não estáticas são conhecidas como classe interna em Java. Existem três tipos de classe interna em Java:

1) Classe interna local - é declarada dentro de um bloco de código ou método.
2) Anonymous inner class - é uma classe que não tem nome para referenciar e inicializada no mesmo local onde é criada.
3) Classe interna do membro - é declarada como membro não estático da classe externa.

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");
        }
    }
}

O que é uma classe estática aninhada em Java?

A classe estática aninhada é outra classe que é declarada dentro de uma classe como membro e tornada estática. A classe estática aninhada também é declarada como membro da classe externa e pode tornar-se privada, pública ou protegida como qualquer outro membro. Um dos principais benefícios da classe estática aninhada sobre a classe interna é que a instância da classe estática aninhada não está anexada a nenhuma instância delimitadora da classe Outer. Você também não precisa de nenhuma instância da classe Outer para criar uma instância da classe estática aninhada em Java .

1) Pode acessar membros de dados estáticos da classe externa, incluindo privados.
2) A classe aninhada estática não pode acessar o membro ou método de dados não-estático (instância) .

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");
        }
    }
}

Ref: Classe interna e classe estática aninhada em Java com exemplo


Eu ilustrei vários possíveis cenários de erros e erros que podem ocorrer no código 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);
                        }*/
                    //}
                }
    }

Ummm ... uma classe interna é uma classe aninhada ... você quer dizer classe anônima e classe interna?

Edit: Se você realmente quis dizer interna vs anônima ... uma classe interna é apenas uma classe definida dentro de uma classe como:

public class A {
    public class B {
    }
}

Considerando que uma classe anônima é uma extensão de uma classe definida anonimamente, então nenhuma classe real é definida, como em:

public class A {
}

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

Edição adicional:

A Wikipedia alega que há uma diferença em Java, mas eu tenho trabalhado com Java por 8 anos, e é o primeiro que eu ouvi tal distinção ... sem mencionar que não há referências lá para fazer backup da afirmação ... line, uma classe interna é uma classe definida dentro de uma classe (estática ou não), e aninhada é apenas outro termo para significar a mesma coisa.

Há uma diferença sutil entre classes aninhadas estáticas e não-estáticas ... basicamente classes internas não-estáticas têm acesso implícito a campos de instância e métodos da classe envolvente (assim eles não podem ser construídos em um contexto estático, ele será um compilador erro). As classes aninhadas estáticas, por outro lado, não têm acesso implícito a campos e métodos de instância e podem ser construídas em um contexto estático.


Acho que as pessoas aqui devem notar para Poster que: Static Nest Class apenas apenas a primeira classe interna. Por exemplo:

 public static class A {} //ERROR

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

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

 }

Resumindo, a classe estática não depende de qual classe ela contém. Então, eles não podem na aula normal. (porque a classe normal precisa de uma instância).


Eu não acho que há muito a acrescentar aqui, a maioria das respostas explica perfeitamente as diferenças entre a classe aninhada estática e as classes internas. No entanto, considere o seguinte problema ao usar classes aninhadas versus classes internas. Como mencionado em algumas respostas, as classes internas não podem ser instanciadas sem uma instância da classe envolvente, o que significa que elas mantêm um ponteiro para a instância da classe envolvente, o que pode levar à sobrecarga de memória ou à exceção de estouro de pilha devido ao fato do GC não será capaz de coletar as classes envolvidas, mesmo que elas não sejam mais usadas. Para tornar isso claro, verifique o seguinte código:

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();

}

Se você remover o comentário // inner = null;O programa irá colocar " Eu estou destruído! ", Mas mantendo este comentário não será.
O motivo é que a instância interna branca ainda é referenciada. O GC não pode coletá-la e, como faz referência (tem um ponteiro para) a instância externa, ela não é coletada também. Tendo bastante desses objetos em seu projeto e pode ficar sem memória.
Comparado a classes internas estáticas que não mantêm um ponto para a instância da classe interna, porque não é relacionado à instância, mas sim relacionado à classe. O programa acima pode imprimir " Estou destruído! " Se você tornar a classe Inner estática e instanciada comOuter.Inner i = new Outer.Inner();


Os termos são usados ​​de forma intercambiável. Se você quiser ser realmente pedante sobre isso, então você pode definir "aninhamento de classe" para se referir a uma classe interna estática, uma que não possui nenhuma instância delimitadora. No código, você pode ter algo assim:

public class Outer {
    public class Inner {}

    public static class Nested {}
}

Isso não é realmente uma definição amplamente aceita.


Primeiro de tudo Não existe essa classe chamada Static class. O modificador Static use with inner class (chamado de Nested Class) diz que é um membro estático de Outer Class, o que significa que podemos acessá-lo como com outros membros estáticos e sem ter qualquer instância da classe Outer. (Que é o benefício da estática originalmente.)

A diferença entre usar a classe aninhada e a classe interna regular é:

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

Primeiro podemos instanciar Outerclass então podemos acessar Inner.

Mas se a classe estiver aninhada, a sintaxe será:

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

Que usa a sintaxe estática como implementação normal da palavra-chave estática.





inner-classes