Eu tentei o exemplo nos tutoriais Java da Oracle . Ambos compilam bem, mas em tempo de execução, ambos apresentam este erro:

Exception in thread "main" java.lang.NoClassDefFoundError: graphics/shapes/Square
    at Main.main(Main.java:7)
Caused by: java.lang.ClassNotFoundException: graphics.shapes.Square
    at java.net.URLClassLoader$1.run(URLClassLoader.java:366)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    ... 1 more

Eu acho que posso ter o Main.javaarquivo na pasta errada. Aqui está a hierarquia de diretórios:

graphics
├ Main.java
├ shapes
|   ├ Square.java
|   ├ Triangle.java
├ linepoint
|   ├ Line.java
|   ├ Point.java
├ spaceobjects
|   ├ Cube.java
|   ├ RectPrism.java

E aqui está Main.java:

import graphics.shapes.*;
import graphics.linepoint.*
import graphics.spaceobjects.*;

public class Main {
    public static void main(String args[]) {
        Square s = new Square(2,3,15);
        Line l = new Line(1,5,2,3);
        Cube c = new Cube(13,32,22);
    }
}

O que eu estou fazendo errado aqui?

ATUALIZAR

Depois de colocar a Mainclasse no graphicspacote (eu a adicionei package graphics;), defina o caminho da classe como "_test" (pasta que contém gráficos), compilei e executei usando java graphics.Main(na linha de comando), funcionou.

ATUALIZAÇÃO # 2 muito atrasada

Eu não estava usando o Eclipse (apenas o Notepad ++ e o JDK), e a atualização acima resolveu meu problema. No entanto, parece que muitas dessas respostas são para Eclipse e IntelliJ, mas eles têm conceitos semelhantes.

Depois de compilar seu código, você acaba com .classarquivos para cada classe no seu programa. Esses arquivos binários são o código de bytes que o Java interpreta para executar seu programa. A NoClassDefFoundErrorindica que o carregador de classe (neste caso java.net.URLClassLoader), que é responsável para as classes de carga dinâmica, não pode encontrar o .classarquivo para a classe que você está tentando usar.

Seu código não seria compilado se as classes necessárias não estivessem presentes (a menos que as classes sejam carregadas com reflexão); portanto, essa exceção geralmente significa que seu caminho de classe não inclui as classes necessárias. Lembre-se de que o carregador java.net.URLClassLoaderde classes (especificamente ) procurará classes no pacote abc na pasta a / b / c / em cada entrada no seu caminho de classe. NoClassDefFoundErrortambém pode indicar que está faltando uma dependência transitiva de um arquivo .jar que você compilou e está tentando usar.

Por exemplo, se você tivesse uma classe com.example.Foo, depois de compilar, teria um arquivo de classe Foo.class. Digamos, por exemplo, seu diretório de trabalho é .../project/. Esse arquivo de classe deve ser colocado .../project/com/examplee você definiria seu caminho de classe para .../project/.

Nota lateral: eu recomendaria aproveitar as ferramentas incríveis que existem para as linguagens Java e JVM. IDEs modernos, como Eclipse e IDEA, e ferramentas de gerenciamento de compilação como Maven ou Gradle ajudarão você a não ter que se preocupar com os caminhos de classe (tanto) e se concentrar no código! Dito isto, este link explica como definir o caminho de classe quando você executa na linha de comando.

Eu gostaria de corrigir a perspectiva dos outros NoClassDefFoundError.

NoClassDefFoundError pode ocorrer por várias razões, como

1. ClassNotFoundException - .class não encontrado para essa classe referenciada, independentemente de estar disponível em tempo de compilação ou não (ou seja, classe base / filho).
   
2. Arquivo de classe localizado, mas exceção gerada ao inicializar variáveis ​​estáticas
   
3. Arquivo de classe localizado, exceção gerada ao inicializar blocos estáticos
   

Na pergunta original, foi o primeiro caso que pode ser corrigido configurando CLASSPATH no arquivo jar de classes referenciado ou em sua pasta do pacote.

O que significa dizer "disponível em tempo de compilação"?

• A classe referenciada é usada no código.
  Ex: Duas classes, A e B (estende A). Se B for referenciado diretamente no código, ele estará disponível em tempo de compilação, ou seja, A a = new B ();

O que significa dizer "não disponível em tempo de compilação"?

• A classe de tempo de compilação e a classe de tempo de execução são diferentes, ou seja, por exemplo, a classe base é carregada usando o nome da classe da classe filho, por exemplo Class.forName ("classname")
  Por exemplo: Duas classes, A e B (estende A). O código possui
  A a = Class.forName ("B"). NewInstance ();

NoClassDefFoundErrorsignifica que a classe está presente no caminho de classe em Compile time, mas não existe no caminho de classe em Runtime.

Se você estiver usando Eclipse, verifique se você tem o shapes, linepointseo spaceobjectscomo entradas no .classpatharquivo.

se você tiver um destes erros ao compilar e executar:

* NoClassDefFoundError

* Error: Could not find or load main class hello

* Exception in thread "main" java.lang.NoClassDefFoundError:javaTest/test/hello 
(wrong name: test/hello)
        at java.lang.ClassLoader.defineClass1(Native Method)
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$100(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.launcher.LauncherHelper.checkAndLoadMain(Unknown Source)

-------------------------- SOLUÇÃO -----------------------

o problema está principalmente na organização de pacotes. Você deve organizar suas aulas em pastas adequadamente, em relação às classificações dos pacotes no seu código-fonte.

On Compiling process use this command:

javac -d . [FileName.java]

To Run the class please use this command:

java [Package].[ClassName]

java.lang.NoClassDefFoundError

indica que algo foi encontrado em tempo de compilação, mas não em tempo de execução . talvez você apenas precise adicioná-lo ao caminho da classe.

Nenhuma exceção de definição de classe ocorre quando a classe pretendida não é encontrada no caminho da classe. Na classe de tempo de compilação: a classe foi gerada a partir do Java Compiler, mas, de alguma forma, no tempo de execução, a classe dependente não foi encontrada.

Vamos passar por um exemplo simples:

public class ClassA{
public static void main(String args[]){
     //Some gibberish Code...
     String text = ClassB.getString();
     System.out.println("Text is :" + text);
}

}

public class ClassB{
    public static String getString(){
      return "Testing Some Exception";
 }
}

Agora vamos supor que os dois códigos-fonte Java acima sejam colocados em alguma pasta, digamos "NoClassDefinationFoundExceptionDemo"

Agora abra um shell (supondo que o Java já esteja sendo configurado corretamente)

1. Vá para a pasta "NoClassDefinationFoundExceptionDemo"
2. Compilar arquivos de origem Java javac ClassB javac ClassA
3. Ambos os arquivos são compilados com êxito e geram arquivos de classe na mesma pasta que ClassA.class e ClassB.class
4. Agora, como estamos substituindo o ClassPath no diretório de trabalho atual, executamos o seguinte comando java -cp. ClassA e funcionou com sucesso e você verá a saída na tela
5. Agora, digamos que você removeu o arquivo ClassB.class do Present Directory. e agora você executa o comando novamente. java -cp. ClassA Agora, ele será recebido com NoClassDefFoundException. como ClassB, que é uma dependência para ClassA, não é encontrado no caminho de classe (ou seja, no diretório de trabalho atual).

NoClassDefFoundError em Java:

Definição:

NoClassDefFoundError virá se uma classe estiver presente durante o tempo de compilação, mas não estiver disponível no caminho de classe java durante o tempo de execução. Normalmente, você verá a linha abaixo no log ao obter NoClassDefFoundError: Exceção no segmento "main" java.lang.NoClassDefFoundError

Causas Possíveis:

1. A classe não está disponível no Java Classpath.

2. Você pode estar executando seu programa usando o comando jar e a classe não foi definida no atributo ClassPath do arquivo de manifesto.

3. Qualquer script de inicialização está substituindo a variável de ambiente Classpath.

4. Como NoClassDefFoundError é uma subclasse de java.lang.LinkageError, ela também pode ocorrer se uma das dependências, como a biblioteca nativa, não estiver disponível.

5. Verifique java.lang.ExceptionInInitializerError no seu arquivo de log. NoClassDefFoundError devido à falha na inicialização estática é bastante comum.

6. Se você estiver trabalhando no ambiente J2EE, a visibilidade de Class entre vários Classloader também poderá causar java.lang.NoClassDefFoundError, consulte exemplos e seção de cenário para discussão detalhada.

Resoluções possíveis:

1. Verifique se todas as classes Java necessárias estão incluídas no caminho de classe do aplicativo. O erro mais comum é não incluir todas as classes necessárias, antes de começar a executar um aplicativo Java que possui dependências em algumas bibliotecas externas.

2. O caminho de classe do aplicativo está correto, mas a variável de ambiente Classpath é substituída antes da execução do aplicativo.

3. Verifique se o mencionado ExceptionInInitializerError não aparece no rastreamento de pilha do seu aplicativo.

Recursos:

3 maneiras de resolver java.lang.NoClassDefFoundError no Java J2EE

java.lang.NoClassDefFoundError - Como resolver nenhum erro encontrado na classe Def

Se seu projeto estiver em um pacote como com.blahcodee sua classe for chamada Main, os arquivos compilados poderão ser gerados em uma estrutura de diretório como ./out/com/blahcode/Main.class. Isto é especialmente verdade para o IntelliJ IDEA.

Ao tentar executar a partir de um shell ou cmd, você precisa cddaquilo que contém comcomo um subdiretório.

cd out
java -classpath . com.blahcode.Main

Depois de trabalhar em um projeto NetBeans por muitos meses, de repente recebi a mensagem NoClassDefFoundError logo após receber o alerta de "Memória insuficiente". Fazer uma reconstrução limpa não ajudou, mas ao fechar o Netbeans e reabrir o projeto, não houve relatórios de erros.

Esta resposta é específica para um java.lang.NoClassDefFoundError acontecendo em um serviço :

Minha equipe recentemente viu esse erro após atualizar uma rpm que fornecia um serviço. O rpm e o software dentro dele foram criados com o Maven, então parecia que tínhamos uma dependência de tempo de compilação que simplesmente não havia sido incluída no rpm.

No entanto, ao investigar, a classe que não foi encontrada estava no mesmo módulo que várias das classes no rastreamento de pilha. Além disso, este não era um módulo que havia sido adicionado recentemente recentemente à compilação. Esses fatos indicaram que pode não ser um problema de dependência do Maven.

A solução eventual: reinicie o serviço!

Parece que a atualização do rpm invalidou o identificador de arquivo do serviço no arquivo jar subjacente. O serviço viu uma classe que não havia sido carregada na memória, procurou-a entre sua lista de identificadores de arquivo jar e falhou em localizá-lo porque o identificador de arquivo do qual podia carregar a classe havia sido invalidado. A reinicialização do serviço obrigou-o a recarregar todos os seus identificadores de arquivo, o que permitiu carregar a classe que não havia sido encontrada na memória logo após a atualização do rpm.

Espero que esse caso específico ajude alguém.

Eu enfrentei o problema hoje. Eu tenho um projeto Android e depois de ativar multidexo projeto não seria mais iniciado.

O motivo foi que eu havia me esquecido de chamar o método multidex específico que deveria ser adicionado ao Application classe invocado antes de todo o resto.

 MultiDex.install(this);

Siga este tutorial para ativar o multidex corretamente. https://developer.android.com/studio/build/multidex.html

Você deve adicionar essas linhas à sua classe Application

 @Override
  protected void attachBaseContext(Context base) {
     super.attachBaseContext(base);
     MultiDex.install(this);
  }

Para o meu projeto, o que resolveu o problema foi que o navegador Chrome e o chromedriver não eram compatíveis. Eu tinha uma versão muito antiga do driver que nem conseguia abrir o navegador. Acabei de baixar a versão mais recente dos dois e o problema foi resolvido. Como eu descobri o problema? Como eu executei meu projeto usando o driver nativo do Firefox, Selenium, com uma versão antiga do FF incluída no meu aplicativo, percebi que o problema era incompatibilidade entre o navegador e o driver.

Espero que isso possa ajudar alguém com um problema semelhante ao meu, que gerou essa mesma mensagem de erro.

Meus dois centavos nesta cadeia:

Verifique se o caminho da classe contém caminhos completos (em /home/user/lib/some_lib.jarvez de ~/lib/some_lib.jar), caso contrário você ainda poderá enfrentar NoClassDefFoundErrorerros.

Recebo NoClassFoundError quando as classes carregadas pelo carregador de classes de tempo de execução não podem acessar as classes já carregadas pelo java rootloader. Como os diferentes carregadores de classes estão em domínios de segurança diferentes (de acordo com java), a jvm não permitirá que as classes já carregadas pelo rootloader sejam resolvidas no espaço de endereço do carregador de tempo de execução.

Execute seu programa com 'java -javaagent: tracer.jar [YOUR java ARGS]'

Produz saída mostrando a classe carregada e o env do carregador que carregou a classe. É muito útil rastrear por que uma classe não pode ser resolvida.

// ClassLoaderTracer.java
// From: https://blogs.oracle.com/sundararajan/entry/tracing_class_loading_1_5

import java.lang.instrument.*;
import java.security.*;

// manifest.mf
// Premain-Class: ClassLoadTracer

// jar -cvfm tracer.jar manifest.mf ClassLoaderTracer.class

// java -javaagent:tracer.jar  [...]

public class ClassLoadTracer 
{
    public static void premain(String agentArgs, Instrumentation inst) 
    {
        final java.io.PrintStream out = System.out;
        inst.addTransformer(new ClassFileTransformer() {
            public byte[] transform(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {

                String pd = (null == protectionDomain) ? "null" : protectionDomain.getCodeSource().toString();
                out.println(className + " loaded by " + loader + " at " + new java.util.Date() + " in " + pd);

                // dump stack trace of the thread loading class 
                Thread.dumpStack();

                // we just want the original .class bytes to be loaded!
                // we are not instrumenting it...
                return null;
            }
        });
    }
}

Isso aconteceu comigo no Android Studio.

A solução que funcionou para mim: basta reiniciar o estúdio.

Eu tive o mesmo problema com o meu desenvolvimento Android usando o Android studio. As soluções fornecidas são gerais e não me ajudaram (pelo menos para mim). Após horas de pesquisa, encontrei a seguinte solução e pode ajudar os desenvolvedores do Android que estão desenvolvendo usando o android studio. modifique a configuração conforme abaixo Preferências -> Compilar, Execução, Implantação -> Execução Instantânea -> desmarque a primeira opção.

Com essa mudança, estou em funcionamento. Espero que isso ajude meus amigos de desenvolvimento.

Uma fonte de erro para esta exceção pode resultar de definições inconsistentes para Proguard, por exemplo, uma falta

-libraryJars "path.to.a.missing.jar.library".

Isso explica por que a compilação e a execução funcionam bem, uma vez que o jar está lá, enquanto o clean & build falha. Lembre-se de definir as novas bibliotecas jar adicionadas na configuração do programa!

Observe que as mensagens de erro do Proguard realmente não estão de acordo com o padrão, pois são facilmente confundidas com mensagens semelhantes de formigas chegando quando o jar não está presente. Somente no fundo haverá um pequeno indício de progresso em problemas. Portanto, é bastante lógico começar a procurar por erros tradicionais do caminho de classe, etc., mas isso será em vão.

Evidentemente, a exceção NoClassDefFound será o resultado da execução, por exemplo, o jar executável resultante, construído e baseado na falta de consistência do programa. Alguns chamam isso de "inferno"

Eu uso o plug-in FileSync para Eclipse para poder depurar ao vivo no Tomcat e recebi NoClassFoundErrorporque havia adicionado uma entrada de sincronização para o bindiretório no espaço de trabalho Eclipse => classesno metadatapara Tomcat, mas também não havia adicionado uma sincronização de pastas para o extlibdiretório no Eclipse=>

C:\Users\Stuart\eclipse-workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\webapps\myApp\WEB-INF\lib

Estou desenvolvendo um aplicativo baseado em Eclipse, também conhecido como RCP (Rich Client Platform) . E eu tenho enfrentado esse problema após a refatoração (movendo uma classe de um plug-in para um novo).

A limpeza do projeto e a atualização do Maven não ajudaram.

O problema foi causado pelo Bundle-Activator que não foi atualizado automaticamente. A atualização manual do Bundle-Activator em MANIFEST.MF no novo PlugIn corrigiu o meu problema.

se você adicionou recentemente o suporte a multidex no android studio como este:

// To Support MultiDex
implementation 'com.android.support:multidex:1.0.1'

portanto, sua solução é estender From MultiDexApplication em vez de Application

public class MyApp extends MultiDexApplication {

Se você estiver usando mais de um módulo, deverá ter

dexOptions {
    preDexLibraries = false
}

no seu arquivo de compilação.

Verifique se você tem um manipulador estático em sua classe. Nesse caso, tenha cuidado, pois o manipulador estático só pode ser iniciado no encadeamento que possui um looper, a falha pode ser acionada da seguinte maneira:

1. primeiramente, crie a instância da classe em um thread simples e pegue a falha.

2. depois chame o método de campo Class no thread principal, você obterá o NoClassDefFoundError.

aqui está o código de teste:

public class MyClass{
       private static  Handler mHandler = new Handler();
       public static int num = 0;
}

no método onCrete da atividade principal, adicione a parte do código de teste:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //test code start
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                MyClass myClass = new MyClass();
            } catch (Throwable e) {
                e.printStackTrace();
            }
        }
    }).start();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    MyClass.num = 3;
    // end of test code
}

existe uma maneira simples de corrigi-lo usando um handlerThread para iniciar o manipulador:

private static Handler mHandler;
private static HandlerThread handlerThread = new HandlerThread("newthread");
static {
    handlerThread.start();
    mHandler = new Handler(handlerThread.getLooper(), mHandlerCB);
}

Não use classes de teste fora do módulo

Eu não tenho uma solução, apenas outro sabor do caso "presente na compilação, ausente no tempo de execução".

Eu estava tentando usar um método muito conveniente de uma classe de teste JUnit de outra classe de teste que reside em um módulo diferente. Isso é um não-não, pois o código de teste não faz parte do jar empacotado, mas eu não percebi porque parece visível para a classe de usuário no Eclipse.

Minha solução foi colocar o método em uma classe de utilitários existente que faz parte do código de produção.

No meu ambiente, encontro esse problema no teste de unidade. Depois de anexar uma dependência de biblioteca a * .pom, isso foi corrigido.

por exemplo:

mensagem de erro:

java.lang.NoClassDefFoundError: com/abc/def/foo/xyz/Iottt

pom:

<dependency>
    <groupId>com.abc.def</groupId>
    <artifactId>foo</artifactId>
    <scope>test</scope>
</dependency>

Eu recebi esse erro após uma alteração no ramo Git. Para o caso específico do Eclipse, havia linhas perdidas no diretório .settings do arquivo org.eclipse.wst.common.component. Como você pode ver abaixo

Restaurar as dependências do projeto com o Maven Install ajudaria.

se você estiver usando gradlew, vá para ./gradle/wrapper/gradle-wrapper.propertiese mudedistributionUrl para a versão correta do gradle.

Se você estiver usando o JDK14, tente

distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip

Isso acontece muito com meus dispositivos de genymotion. Verifique se você tem uma boa quantidade de memória disponível em sua unidade onde o Genymotion está instalado.