Java Language
Java Compiler - 'javac'

Anmärkningar

"Javac" -kommandot - komma igång

Enkelt exempel

Antagande att "HelloWorld.java" innehåller följande Java-källa:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

(För en förklaring av koden ovan, se Komma igång med Java-språk .)

Vi kan sammanställa ovanstående fil med detta kommando:

$ javac HelloWorld.java 

Detta skapar en fil som heter "HelloWorld.class", som vi sedan kan köra på följande sätt:

$ java HelloWorld
Hello world!

De viktigaste punkterna att notera från detta exempel är:

1. Källfilnamnet "HelloWorld.java" måste matcha klassnamnet i källfilen ... som är HelloWorld . Om de inte matchar får du ett sammanställningsfel.
2. Bytekodens filnamn "HelloWorld.class" motsvarar klassnamnet. Om du skulle byta namn på "HelloWorld.class" skulle du få ett fel när du försökte köra det.
3. När du kör ett Java-program med java tillhandahåller du klassnamnet INTE bytekodens filnamn.

Exempel med paket

Mest praktisk Java-kod använder paket för att organisera namnutrymmet för klasser och minska risken för oavsiktlig kollnamn.

Om vi ville förklara HelloWorld klassen i ett com.example , skulle "HelloWorld.java" innehålla följande Java-källa:

package com.example;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

Den här källkodsfilen måste lagras i ett katalogträd vars struktur motsvarar paketnamnet.

.    # the current directory (for this example)
|
 ----com
     |
      ----example
          |
           ----HelloWorld.java

Vi kan sammanställa ovanstående fil med detta kommando:

$ javac com/example/HelloWorld.java 

Detta producerar en fil som heter "com / exempel / HelloWorld.class"; dvs. efter sammanställningen ska filstrukturen se ut så här:

.    # the current directory (for this example)
|
 ----com
     |
      ----example
          |
           ----HelloWorld.java
           ----HelloWorld.class

Vi kan sedan köra applikationen enligt följande:

$ java com.example.HelloWorld
Hello world!

Ytterligare punkter att notera från detta exempel är:

1. Katalogstrukturen måste matcha paketnamnsstrukturen.
2. När du kör klassen måste hela klassnamnet anges; dvs "com.example.HelloWorld" inte "HelloWorld".
3. Du behöver inte kompilera och köra Java-kod ur den aktuella katalogen. Vi gör det bara här för att illustrera.

Sammansätter flera filer samtidigt med 'javac'.

Om din applikation består av flera källkodfiler (och de flesta gör!) Kan du sammanställa dem en i taget. Alternativt kan du sammanställa flera filer samtidigt genom att lista sökvägarna:

$ javac Foo.java Bar.java

eller med hjälp av ditt kommandoskalts filnamn jokerteckenfunktion ...

$ javac *.java
$ javac com/example/*.java
$ javac */**/*.java #Only works on Zsh or with globstar enabled on your shell

Detta kommer att sammanställa alla Java-källfiler i den aktuella katalogen, i katalogen "com / exempel", och rekursivt i barnkataloger. Ett tredje alternativ är att tillhandahålla en lista med källfilnamn (och kompilatoralternativ) som en fil. Till exempel:

$ javac @sourcefiles

där sourcefiles innehåller:

Foo.java
Bar.java
com/example/HelloWorld.java

Obs: att sammanställa kod som denna är lämplig för små en-personsprojekt och för engångsprogram. Utöver det är det tillrådligt att välja och använda ett Java build-verktyg. Alternativt, de flesta programmerare använder en Java IDE (t.ex. NetBeans , Eclipse , IntelliJ IDEA ), som erbjuder en inbäddad kompilator och inkrementell byggandet av "projekt".

Vanliga "javac" -alternativ

Här är några alternativ för javac kommandot som sannolikt kommer att vara användbara för dig

• Alternativet -d ställer in en destinationskatalog för att skriva ".klass" -filerna.
• -sourcepath anger en sökväg för källkod.
• -cp eller -classpath ställer in sökvägen för att hitta externa och tidigare kompilerade klasser. För mer information om klassvägen och hur du anger den, se klassvägens ämne.
• -version skriver ut kompilatorens -version .

En mer komplett lista med kompilatoralternativ kommer att beskrivas i ett separat exempel.

referenser

Den definitiva referensen för javac kommandot är Oracle-manualsidan för javac .

Kompilering för en annan version av Java

Java-programmeringsspråket (och dess körtid) har genomgått många förändringar sedan det släpptes sedan dess första offentliga utgåva. Dessa ändringar inkluderar:

• Förändringar i Java-programmeringsspråksyntax och semantik
• Ändringar i API: erna som tillhandahålls av Java standardklassbibliotek.
• Ändringar i Java (bytecode) instruktionsuppsättning och klassfilformat.

Med mycket få undantag (till exempel enum nyckelordet, ändringar i vissa "interna" klasser osv.) Är dessa ändringar bakåtkompatibla.

• Ett Java-program som kompilerades med en äldre version av Java-verktygskedjan kommer att köras på en nyare version av Java-plattformen utan rekompilering.
• Ett Java-program som har skrivits i en äldre version av Java kommer att kompilera framgångsrikt med en ny Java-kompilator.

Sammansätta gamla Java med en nyare kompilator

Om du behöver (om) kompilera äldre Java-kod på en nyare Java-plattform för att köra på den nyare plattformen, behöver du i allmänhet inte ge några speciella sammanställningsflaggor. I några få fall (t.ex. om du hade använt enum som identifierare) kan du använda alternativet -source att inaktivera den nya syntaxen. Till exempel, med följande klass:

public class OldSyntax {
    private static int enum;  // invalid in Java 5 or later
}

följande krävs för att kompilera klassen med en Java 5-kompilator (eller senare):

$ javac -source 1.4 OldSyntax.java

Kompilering för en äldre exekveringsplattform

Om du behöver kompilera Java för att köra på en äldre Java-plattformar, är det enklaste sättet att installera en JDK för den äldsta versionen du behöver för att stödja, och använda den JDK: s kompilator i dina build.

Du kan också kompilera med en nyare Java-kompilator, men de är komplicerade. Först och främst finns det några viktiga förutsättningar som måste uppfyllas:

• Koden du sammanställer får inte använda Java-språkkonstruktioner som inte var tillgängliga i den version av Java som du riktar in dig på.
• Koden får inte bero på vanliga Java-klasser, fält, metoder och så vidare som inte fanns tillgängliga på de äldre plattformarna.
• Tredjepartsbibliotek som koden beror på måste också byggas för den äldre plattformen och är tillgängliga vid kompileringstid och körtid.

Med tanke på att förutsättningarna är uppfyllda kan du kompilera kod för en äldre plattform med alternativet -target . Till exempel,

$ javac -target 1.4 SomeClass.java

kommer att sammanställa ovanstående klass för att producera bytekoder som är kompatibla med Java 1.4 eller senare JVM. (I själva -source innebär alternativet -source ett kompatibelt -target , så javac -source 1.4 ... skulle ha samma effekt. Förhållandet mellan -source och -target beskrivs i Oracle-dokumentationen.)

Med det sagt, om du bara använder -target eller -source , kommer du fortfarande att kompilera mot standardklassbibliotek som tillhandahålls av kompilatorens JDK. Om du inte är försiktig kan du sluta med klasser med rätt bytekodversion, men med beroende på API: er som inte är tillgängliga. Lösningen är att använda alternativet -bootclasspath . Till exempel:

$ javac -target 1.4 --bootclasspath path/to/java1.4/rt.jar SomeClass.java

kommer att kompilera mot en alternativ uppsättning runtime-bibliotek. Om klassen som sammanställs har (oavsiktliga) beroenden på nyare bibliotek ger det dig sammanställningsfel.