Ho provato entrambi gli esempi nei tutorial Java di Oracle . Entrambi compilano bene, ma in fase di esecuzione, entrambi presentano questo errore:

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

Penso che potrei avere il Main.javafile nella cartella sbagliata. Ecco la gerarchia di directory:

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

Ed ecco qui 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);
    }
}

Cosa sto facendo di sbagliato qui?

AGGIORNARE

Dopo aver inserito la Mainclasse nel graphicspacchetto (l'ho aggiunta package graphics;), ho impostato il classpath su "_test" (cartella contenente grafica), l'ho compilato ed eseguito usando java graphics.Main(dalla riga di comando), ha funzionato.

AGGIORNAMENTO # 2 davvero in ritardo

Non stavo usando Eclipse (solo Notepad ++ e JDK) e l'aggiornamento sopra risolto il mio problema. Tuttavia, sembra che molte di queste risposte siano per Eclipse e IntelliJ, ma hanno concetti simili.

Dopo aver compilato il codice, si finiscono con i .classfile per ogni classe nel programma. Questi file binari sono il bytecode che Java interpreta per eseguire il programma. La NoClassDefFoundErrorindica che il programma di caricamento classe (in questo caso java.net.URLClassLoader), che è responsabile per le classi in modo dinamico di carico, non riesce a trovare il .classfile per il classe che si sta cercando di utilizzare.

Il tuo codice non verrebbe compilato se le classi richieste non fossero presenti (a meno che le classi non siano caricate con reflection), quindi di solito questa eccezione indica che il tuo percorso di classe non include le classi richieste. Ricorda che il classloader (in particolare java.net.URLClassLoader) cercherà le classi nel pacchetto abc nella cartella a / b / c / in ogni voce nel tuo percorso di classe. NoClassDefFoundErrorpuò anche indicare che ti manca una dipendenza transitiva di un file .jar che hai compilato e che stai provando a utilizzare.

Ad esempio, se avessi una classe com.example.Foo, dopo la compilazione avresti un file di classe Foo.class. Di 'ad esempio la tua directory di lavoro .../project/. Quel file di classe deve essere inserito .../project/com/examplee dovresti impostare il tuo percorso di classe su .../project/.

Nota a margine: consiglierei di sfruttare gli incredibili strumenti esistenti per i linguaggi Java e JVM. I moderni IDE come Eclipse e IDEA e la creazione di strumenti di gestione come Maven o Gradle ti aiuteranno a non doverti preoccupare dei percorsi di classe (altrettanto) e concentrarti sul codice! Detto questo, questo link spiega come impostare il classpath quando si esegue sulla riga di comando.

Vorrei correggere la prospettiva degli altri NoClassDefFoundError.

NoClassDefFoundError può verificarsi per diversi motivi come

1. ClassNotFoundException - .class non trovato per quella classe di riferimento indipendentemente dal fatto che sia disponibile al momento della compilazione o meno (ovvero classe base / figlio).
   
2. File di classe individuato, ma eccezione sollevata durante l'inizializzazione delle variabili statiche
   
3. File di classe individuato, eccezione sollevata durante l'inizializzazione dei blocchi statici
   

Nella domanda originale, è stato il primo caso che può essere corretto impostando CLASSPATH sul file jar delle classi di riferimento o nella sua cartella del pacchetto.

Cosa significa dicendo "disponibile in fase di compilazione"?

• La classe di riferimento viene utilizzata nel codice.
  Ad esempio: due classi, A e B (estende A). Se si fa riferimento direttamente a B nel codice, è disponibile al momento della compilazione, ovvero A a = new B ();

Cosa significa dicendo "non disponibile al momento della compilazione"?

• La classe temporale di compilazione e la classe di runtime sono diverse, ad esempio la classe base viene caricata utilizzando il nome classe della classe figlio, ad esempio Class.forName ("nome classe")
  Ad esempio: due classi, A e B (estende A). Il codice ha
  A a = Class.forName ("B"). NewInstance ();

NoClassDefFoundErrorsignifica che la classe è presente nel percorso di classe in Compile time, ma non esiste nel percorso di classe in Runtime.

Se stai usando Eclipse, assicuratevi di avere la shapes, linepointse il spaceobjectscome voci nel .classpathfile.

se hai riscontrato uno di questi errori durante la compilazione e l'esecuzione:

* 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)

-------------------------- SOLUZIONI -----------------------

il problema è principalmente nell'organizzazione dei pacchetti. È necessario disporre le classi in cartelle correttamente per quanto riguarda le classificazioni del pacchetto nel codice sorgente.

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 che è stato trovato qualcosa in fase di compilazione ma non in fase di esecuzione . forse devi solo aggiungerlo al percorso di classe.

Nessuna eccezione di definizione di classe si verifica quando la classe desiderata non viene trovata nel percorso di classe. In fase di compilazione Classe: la classe è stata generata dal compilatore Java, ma in qualche modo in fase di esecuzione la classe dipendente non è stata trovata.

Vediamo un semplice esempio:

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

Ora supponiamo che i due precedenti codici sorgente Java siano collocati in alcune cartelle diciamo "NoClassDefinationFoundExceptionDemo"

Ora apri una shell (Supponendo che Java sia già configurato correttamente)

1. Vai alla cartella "NoClassDefinationFoundExceptionDemo"
2. Compilare i file di origine Java javac ClassB javac ClassA
3. Entrambi i file vengono compilati correttamente e generati file di classe nella stessa cartella di ClassA.class e ClassB.class
4. Ora, dato che stiamo sovrapponendo ClassPath alla directory di lavoro corrente, eseguiamo il seguente comando java -cp. ClassA e ha funzionato correttamente e vedrai l'output nella schermata
5. Ora diciamo che hai rimosso il file ClassB.class da Present Directory. e ora esegui di nuovo il comando. java -cp. ClassA Ora ti accoglierà con NoClassDefFoundException. come ClassB che è una dipendenza per ClassA non si trova nel classpath (cioè nella directory di lavoro attuale).

NoClassDefFoundError in Java:

Definizione:

NoClassDefFoundError verrà se una classe era presente durante il tempo di compilazione ma non disponibile nel percorso di classe java durante il runtime. Normalmente vedrai la riga sotto nel registro quando ottieni NoClassDefFoundError: Eccezione nel thread "main" java.lang.NoClassDefFoundError

Cause possibili:

1. La classe non è disponibile in Java Classpath.

2. Potrebbe essere in esecuzione il programma utilizzando il comando jar e la classe non è stata definita nell'attributo ClassPath del file manifest.

3. Qualsiasi script di avvio ha la precedenza sulla variabile d'ambiente Classpath.

4. Poiché NoClassDefFoundError è una sottoclasse di java.lang.LinkageError, può anche verificarsi se una di esse come la libreria nativa potrebbe non essere disponibile.

5. Cerca java.lang.ExceptionInInitializerError nel tuo file di registro. NoClassDefFoundError a causa del fallimento dell'inizializzazione statica è abbastanza comune.

6. Se si lavora in un ambiente J2EE rispetto alla visibilità di Class tra più Classloader può anche causare java.lang.NoClassDefFoundError, vedere esempi e sezione scenari per una discussione dettagliata.

Possibili risoluzioni:

1. Verificare che tutte le classi Java richieste siano incluse nel percorso di classe dell'applicazione. L'errore più comune non è quello di includere tutte le classi necessarie, prima di iniziare a eseguire un'applicazione Java che ha dipendenze da alcune librerie esterne.

2. Il percorso di classe dell'applicazione è corretto, ma la variabile di ambiente Classpath viene ignorata prima dell'esecuzione dell'applicazione.

3. Verificare che il suddetto ExceptionInInitializerError non venga visualizzato nella traccia dello stack dell'applicazione.

risorse:

3 modi per risolvere java.lang.NoClassDefFoundError in Java J2EE

java.lang.NoClassDefFoundError - Come risolvere l'errore di def. classe non trovato

Se il tuo progetto è in un pacchetto simile com.blahcodee viene chiamata la tua classe Main, i file compilati potrebbero essere emessi in una struttura di directory simile ./out/com/blahcode/Main.class. Ciò è particolarmente vero per IntelliJ IDEA.

Quando si tenta di eseguire da una shell o cmd, è necessario cdquello che contiene comcome una sottodirectory.

cd out
java -classpath . com.blahcode.Main

Dopo aver lavorato su un progetto NetBeans per molti mesi, ho ricevuto improvvisamente il messaggio NoClassDefFoundError poco dopo aver ricevuto un avviso "Memoria insufficiente". Fare una ricostruzione pulita non ha aiutato, ma chiudendo del tutto Netbeans e riaprendo il progetto non sono stati segnalati errori.

Questa risposta è specifica per un java.lang.NoClassDefFoundError che si verifica in un servizio :

Il mio team ha recentemente riscontrato questo errore dopo aver aggiornato un numero di giri che ha fornito un servizio. L'rpm e il software al suo interno erano stati creati con Maven, quindi sembrava che avessimo una dipendenza dal tempo di compilazione che non era stata inclusa negli rpm.

Tuttavia, durante l'analisi, la classe che non è stata trovata era nello stesso modulo di diverse classi nella traccia dello stack. Inoltre, questo non era un modulo che era stato aggiunto di recente alla build. Questi fatti indicano che potrebbe non essere un problema di dipendenza Maven.

L'eventuale soluzione: riavviare il servizio!

Sembra che l'aggiornamento di rpm abbia invalidato l'handle del file del servizio sul file jar sottostante. Il servizio ha quindi visto una classe che non era stata caricata in memoria, l'ha cercata nel suo elenco di handle di file jar e non è riuscita a trovarla perché l'handle di file dal quale poteva caricare la classe era stato invalidato. Il riavvio del servizio lo ha costretto a ricaricare tutti i suoi handle di file, il che gli ha permesso di caricare quella classe che non era stata trovata in memoria subito dopo l'aggiornamento di rpm.

Spero che un caso specifico aiuti qualcuno.

Oggi ho affrontato il problema. Ho un progetto Android e dopo aver abilitato multidexil progetto non si avvia più.

Il motivo era che avevo dimenticato di chiamare il metodo multidex specifico che doveva essere aggiunto Application classe invocato prima di ogni altra cosa.

 MultiDex.install(this);

Segui questo tutorial per abilitare correttamente multidex. https://developer.android.com/studio/build/multidex.html

È necessario aggiungere queste righe alla classe dell'applicazione

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

Per il mio progetto, ciò che ha risolto il problema era che il browser Chrome e il chromedriver non erano compatibili. Avevo una versione molto vecchia del driver che non riusciva nemmeno ad aprire il browser. Ho appena scaricato l'ultima versione di entrambi e il problema è stato risolto. Come ho scoperto il problema? Poiché ho eseguito il mio progetto utilizzando il driver firefox nativo Selenium con una vecchia versione di FF integrata con la mia applicazione, mi sono reso conto che il problema era l'incompatibilità tra browser e driver.

Spero che questo possa aiutare chiunque abbia un problema simile al mio, che ha generato questo stesso messaggio di errore.

I miei due centesimi in questa catena:

Assicurarsi che il percorso di classe contenga percorsi completi ( /home/user/lib/some_lib.jaranziché ~/lib/some_lib.jar), altrimenti è comunque possibile riscontrare NoClassDefFoundErrorerrori.

Ottengo NoClassFoundError quando le classi caricate dal programma di caricamento classi runtime non possono accedere alle classi già caricate dal rootloader java. Poiché i diversi caricatori di classi si trovano in domini di sicurezza diversi (secondo java), jvm non consentirà di risolvere le classi già caricate dal rootloader nello spazio degli indirizzi del caricatore di runtime.

Esegui il programma con 'java -javaagent: tracer.jar [YOUR java ARGS]'

Produce un output che mostra la classe caricata e il caricatore env che ha caricato la classe. È molto utile tracciare perché una classe non può essere risolta.

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

Mi è successo in Android Studio.

La soluzione che ha funzionato per me: basta riavviare lo studio.

Ho avuto lo stesso problema con il mio sviluppo Android usando Android Studio. Le soluzioni fornite sono generali e non mi hanno aiutato (almeno per me). Dopo ore di ricerca ho trovato la seguente soluzione e posso aiutare gli sviluppatori Android che stanno sviluppando utilizzando Android Studio. modifica l'impostazione come di seguito Preferenze -> Build, Execution, Deployment -> Instant Run -> deseleziona la prima opzione.

Con questo cambiamento sono attivo e funzionante. Spero che questo possa aiutare i miei amici dev.

Una fonte di errore per questa eccezione potrebbe derivare da definizioni incoerenti per Proguard, ad esempio una mancanza

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

Questo spiega perché la compilazione e l'esecuzione funzionano bene, dato che il jar è lì, mentre clean & build fallisce. Ricorda di definire le nuove librerie jar aggiunte nella configurazione di proguard!

Si noti che i messaggi di errore di Proguard non sono davvero standard, in quanto sono facilmente confusi con messaggi di formica simili che arrivano quando il vaso non è presente. Solo in fondo ci sarà un piccolo accenno di proguard nei guai. Quindi, è abbastanza logico iniziare a cercare gli errori tradizionali del percorso di classe ecc., Ma ciò sarà vano.

Evidentemente, l'eccezione NoClassDefFound sarà i risultati durante l'esecuzione, ad esempio il vaso eseguibile risultante creato e basato su una mancanza di coerenza proguard. Alcuni lo chiamano proguard "Hell"

Uso il plug-in FileSync per Eclipse in modo da poter eseguire il debug live su Tomcat e ho ricevuto NoClassFoundErrorperché avevo aggiunto una voce di sincronizzazione per la bindirectory nell'area di lavoro Eclipse => classesin metadataper Tomcat ma non avevo aggiunto anche una sincronizzazione delle cartelle per la extlibdirectory in Eclipse=>

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

Sto sviluppando un'applicazione basata su Eclipse nota anche come RCP (Rich Client Platform) . E ho riscontrato questo problema dopo il refactoring (spostando una classe da un plug-in a una nuova).

La pulizia del progetto e l'aggiornamento di Maven non sono stati utili.

Il problema è stato causato dal Bundle-Activator che non è stato aggiornato automaticamente. L'aggiornamento manuale del Bundle-Activator sotto MANIFEST.MF nel nuovo PlugIn ha risolto il mio problema.

se hai recentemente aggiunto il supporto multidex in Android Studio in questo modo:

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

quindi la tua soluzione è semplicemente estesa da MultiDexApplication invece che da Applicazione

public class MyApp extends MultiDexApplication {

Se stai usando più di un modulo, dovresti averlo

dexOptions {
    preDexLibraries = false
}

nel tuo file di build.

Verifica che se hai un gestore statico nella tua classe. In tal caso, si prega di fare attenzione, poiché solo il gestore statico potrebbe essere avviato nel thread con un looper, l'arresto anomalo potrebbe essere attivato in questo modo:

1.Prima di tutto, crea l'istanza di classe in un semplice thread e cattura l'arresto anomalo.

2.quindi chiama il metodo field di Class nel thread principale, otterrai NoClassDefFoundError.

ecco il codice di prova:

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

nel metodo onCrete dell'attività principale, aggiungi la parte del codice di test:

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

c'è un modo semplice per risolverlo usando un gestoreTread to init handler:

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

Non utilizzare le classi di test al di fuori del modulo

Non ho una soluzione, solo un altro aspetto del caso "presente alla compilazione, assente in fase di esecuzione".

Stavo cercando di utilizzare un metodo molto conveniente da una classe di test JUnit di un'altra classe di test che risiede in un modulo diverso. Questo è un no-no, poiché il codice di test non fa parte del jar impacchettato, ma non me ne sono reso conto perché appare visibile per la classe utente all'interno di Eclipse.

La mia soluzione era quella di posizionare il metodo in una classe di utilità esistente che fa parte del codice di produzione.

Nel mio ambiente, riscontro questo problema nel test unitario. Dopo aver aggiunto una dipendenza della libreria a * .pom, è stato risolto.

per esempio:

messaggio di errore:

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

pom:

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

Ho ricevuto questo errore dopo una modifica del ramo Git. Nel caso specifico di Eclipse, c'erano delle righe perse nella directory .settings per il file org.eclipse.wst.common.component. Come puoi vedere di seguito

Il ripristino delle dipendenze del progetto con Maven Install sarebbe di aiuto.

se stai usando gradlew, vai a ./gradle/wrapper/gradle-wrapper.propertiese distributionUrlpassa alla versione corretta di Gradle.

Se si utilizza JDK14, provare

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

Succede molto con i miei dispositivi genymotion. Assicurati di avere una buona quantità di memoria disponibile sul disco in cui è installato Genymotion.