Por que você não pode declarar uma classe como estática em Java?

Por que você não pode declarar uma classe como estática em Java?

Somente classes aninhadas podem ser estáticas. Ao fazer isso, você pode usar a classe aninhada sem ter uma instância da classe externa.

class OuterClass{
    public static class StaticNestedClass{
    }

    public class InnerClass{
    }

    public InnerClass getAnInnerClass(){
        return new InnerClass();
    }

    //This method doesn't work
    public static InnerClass getAnInnerClassStatically(){
        return new InnerClass();
    }
}

class OtherClass{
    //Use of a static nested class:
    private OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();

    //Doesn't work
    private OuterClass.InnerClass innerClass = new OuterClass.InnerClass();

    //Use of an inner class:
    private OuterClass outerclass= new OuterClass();
    private OuterClass.InnerClass innerClass2 = outerclass.getAnInnerClass();
    private OuterClass.InnerClass innerClass3 = outerclass.new InnerClass();
}

Fontes :

• Tutorial do Oracle sobre classes aninhadas

Sobre o mesmo tópico:

• Java: classe interna estática vs não estática
• Classe interna Java e classe aninhada estática

As classes de nível superior são estáticas por padrão. Classes internas são não estáticas por padrão. Você pode alterar o padrão para classes internas marcando-as explicitamente estáticas. As classes de nível superior, em virtude de serem de nível superior, não podem ter semântica não estática porque não pode haver classe pai a que se referir. Portanto, não há como alterar o padrão para as classes de nível superior.

Estou chegando atrasado à festa, mas aqui estão meus dois centavos - filosoficamente acrescentando à resposta de Colin Hebert.

Em um nível alto, sua pergunta lida com a diferença entre objetos e tipos. Embora existam muitos carros (objetos), há apenas uma classe de carros (tipo). Declarar algo como estático significa que você está operando no espaço "tipo". Há apenas um. A palavra-chave da classe de nível superior já define um tipo no espaço "type". Como resultado, "a classe estática pública Car" é redundante.

Classe com construtor privado é estática.

Declare sua turma assim:

public class eOAuth {

    private eOAuth(){}

    public final static int    ECodeOauthInvalidGrant = 0x1;
    public final static int    ECodeOauthUnknown       = 0x10;
    public static GetSomeStuff(){}

}

e você pode usar sem inicialização:

if (value == eOAuth.ECodeOauthInvalidGrant)
    eOAuth.GetSomeStuff();
...

Claro que podem, mas apenas classes internas aninhadas. Lá, isso significa que as instâncias da classe aninhada não requerem uma instância anexa da classe externa.

Porém, para as classes de nível superior, os designers de idiomas não conseguiram pensar em nada útil para fazer com a palavra-chave, portanto, não é permitido.

Você pode criar uma classe de utilitário (que não pode ter instâncias criadas) declarando um tipo de enum sem instâncias. ou seja, você está declarando especificamente que não há instâncias.

public enum MyUtilities {;
   public static void myMethod();
}

public class Outer {
   public static class Inner {}
}

... pode ser declarado estático - desde que seja uma classe membro.

Do JLS:

As classes membro podem ser estáticas, caso em que não têm acesso às variáveis ​​de instância da classe circundante; ou eles podem ser classes internas (§8.1.3).

e aqui:

A palavra-chave estática pode modificar a declaração de um membro do tipo C dentro do corpo de uma classe não interna T. Seu efeito é declarar que C não é uma classe interna. Assim como um método estático de T não possui instância atual de T em seu corpo, C também não possui instância atual de T, nem possui instâncias lexicamente fechadas.

Uma palavra-chave estática não faria sentido para uma classe de nível superior, apenas porque uma classe de nível superior não possui um tipo de anexo.

Como explicado acima, uma classe não pode ser estática, a menos que seja membro de outra classe.

Se você deseja criar uma classe "da qual não pode haver várias instâncias", convém examinar o padrão de design "Singleton".

Informações sobre Singleton para iniciantes aqui .

Embargo:

Se você está pensando em usar o padrão singleton, resista com todas as suas forças. É um dos DesignPatterns mais fáceis de entender, provavelmente o mais popular e, definitivamente, o mais abusado. (fonte: JavaRanch como link acima)

Além de como o Java define classes internas estáticas, há outra definição de classes estáticas conforme o mundo C # [1] . Uma classe estática é aquela que possui apenas métodos estáticos (funções) e destina-se a oferecer suporte a programação procedural. Essas classes não são realmente classes, pois o usuário da classe está interessado apenas nas funções auxiliares e não na criação de instâncias da classe. Embora as classes estáticas sejam suportadas em C #, não existe esse suporte direto em Java. No entanto, você pode usar enumerações para imitar classes estáticas de C # em Java, para que um usuário nunca possa criar instâncias de uma determinada classe (mesmo usando reflexão) [2] :

public enum StaticClass2 {
    // Empty enum trick to avoid instance creation
    ; // this semi-colon is important

    public static boolean isEmpty(final String s) {
        return s == null || s.isEmpty();
    }
}

Tudo o que codificamos em java entra em uma classe. Sempre que executamos uma classe, a JVM instancia um objeto. A JVM pode criar vários objetos, por definição Estático significa que você tem o mesmo conjunto de cópias para todos os objetos.

Portanto, se Java permitiria que a classe superior fosse estática sempre que você executa um programa, ele cria um Objeto e continua substituindo o mesmo local da memória.

Se você está apenas substituindo o objeto toda vez que o executa, qual é o objetivo de criá-lo?

Portanto, esse é o motivo pelo qual o Java se livrou da estática da classe de nível superior.

Pode haver razões mais concretas, mas isso fez muito sentido lógico para mim.

As únicas classes que podem ser estáticas são as classes internas. O código a seguir funciona bem:

public class whatever {
    static class innerclass {
    }
}

O objetivo das classes internas estáticas é que elas não têm uma referência ao objeto de classe externa.

Eu acho que isso é possível tão fácil quanto beber um copo de café! Basta dar uma olhada nisso. Não usamos palavras-chave estáticas explicitamente ao definir classe.

public class StaticClass {

    static private int me = 3;
    public static void printHelloWorld() {
       System.out.println("Hello World");
    }



    public static void main(String[] args) {
        StaticClass.printHelloWorld();
        System.out.println(StaticClass.me);
    }
}

Isso não é uma definição de classe estática? Nós apenas usamos uma função ligada a apenas uma classe. Tenha cuidado para que, neste caso, possamos usar outra classe nesse aninhado. Veja isso:

class StaticClass1 {

    public static int yum = 4;

    static void  printHowAreYou() {
        System.out.println("How are you?");
    }
}

public class StaticClass {

    static int me = 3; 
    public static void printHelloWorld() {
       System.out.println("Hello World");
       StaticClass1.printHowAreYou();
       System.out.println(StaticClass1.yum);
    }



    public static void main(String[] args) {
        StaticClass.printHelloWorld();
        System.out.println(StaticClass.me);
    }
}

Pode-se observar no PlatformUIEclipse uma classe com métodos estáticos e construtor privado, sendo ele próprio final.

public final class <class name>
{
   //static constants
   //static memebers
}

se o benefício de usar uma classe estática não era instanciar um objeto e usar um método, basta declarar a classe como pública e esse método como estático.