Java-syntax

Duke, Java-maskoten

Den syntax i Java programmeringsspråket är definierad i Java Language Specification , som är semantik i Java.

Den här artikeln ger en översikt över Java-syntax och belyser några av dess detaljer. Detaljer finns i Sun Microsystems Java Language Specification .

terminologi

Eftersom Java är ett programmeringsspråk, för beskrivning av vilket huvudsakligen engelskspråkiga termer används, men tyska översättningar av vissa komponenter också används i litteraturen, bör tvetydigheten klargöras vid denna tidpunkt och de uttryck som används i denna artikel bör också vara fast besluten att undvika förvirring kan uteslutas. Följande är termerna som används i denna artikel och deras engelska eller tyska motsvarigheter.

Uttryck

(Engl. Expression ) Ett uttryck förstås vara varje komplex språkkonstruktion vars utvärdering resulterar i ett enda, väldefinierat värde. I det enklaste fallet är ett uttryck en konstant, såsom Exempelvis nyckelordet true eller ett tal (t.ex. 1 eller 0x7fff ). Mer komplexa uttryck är jämförelser eller beräkningar med flera variabler och konstanter. Inom grammatikbeskrivningarna görs ofta en skillnad mellan olika typer av uttryck (t.ex. numeriska, bokstavliga etc.), vilket inte borde vara fallet här.

Instruktion

(Engelska. Uttalande , instruktion eller kommando ; även kallat kommando ) På Java, som i många andra tvingande programmeringsspråk, hänvisar en instruktion till en enda regel som ska köras inom ramen för genomförandet av programmet. Detta inkluderar deklarationen av variabler, uttryck avslutas med semikolon, kontrollstrukturer, instruktionsblock, hoppinstruktioner, synkroniseringsblock, retur av värden och utlösning av undantag.

Uttalande block

(Engl. Statement Block ) Ett instruktionsblock används för att gruppera flera instruktioner. Detta innebär att flera påståenden kan tolkas som ett enda påstående, vilket är ett krav i vissa språkkonstruktioner - såsom kontrollstrukturerna.

Lexikalisk struktur

Java-program är skrivna i Unicode . Till skillnad från andra språk kan identifierare av klasser, metoder, variabler etc. inte bara innehålla bokstäverna i det latinska alfabetet och siffror utan också tecken från andra alfabet, som t.ex. B. Tyska parlamenter eller kinesiska tecken.

Alla nyckelord i Java skrivs med gemener, t.ex. B. " class" eller " if".

Bokstavssymboler (engelska bokstäver ) finns på Java, det minsta möjliga uttrycket för siffror, enskilda tecken, teckensträngar ( strängar ) logiska värden ( trueeller false) och det specifika ordet null.

Avgränsare (engelska avgränsare ) är olika typer av hängslen och kommatecken, perioder och semikolon.

Java känner till de logiska , jämförande och matematiska operatorerna som är vanliga i programmeringsspråk . Syntaxen baseras på programmeringsspråket C ++ . Exempelvis används det enkla likhetstecknet " =" som en tilldelningsoperator, medan det dubbla likhetstecknet " ==" används för jämförelser .

Mellanslag, radslut och kommentarer kan infogas var som helst mellan identifierare, nyckelord, bokstavssymboler, separatorer och operatörer.

syntax

Datatyper

Java känner till två typer av data : primitiv datatyp och referenser till objekt. De primitiva datatyperna är en anledning till att Java inte är ett rent objektorienterat språk.

Primitiva datatyper

Det finns åtta primitiva datatyper. De har olika storlekar och egenskaper och används för att beräkna och lagra diskreta numeriska värden. Alla dessa datatyper har en fast storlek som är densamma för alla plattformar. För varje typ finns en motsvarande omslagsklass så att de också kan behandlas som verkliga föremål.

Typecast

Hierarkin för konvertering ( typecasting ) av de primitiva datatyperna kan gissas från ovanstående tabell. De numeriska datatyperna kan konverteras till nästa större datatyp utan förlust, men inte tvärtom. Ett " int" kan omvandlas till ett " " implicit, dvs. utan en speciell operatör long, men inte tvärtom.

int i = 12345;
long l = i;

För att till exempel konvertera en " long" till en " int" i motsatt riktning måste typkonverteringsoperatören användas. Information kan också gå förlorad under processen.

long l = 12345678901L;
int i = (int) l;

En iförlust av information uppstår här: " " har värdet −539222987 efter tilldelningen eftersom de mer betydande byten trunkeras.

Den primitiva datatypen " boolean" kan inte konverteras till någon annan datatyp. Tecken av typen " char" kan implicit konverteras till valfri heltalstyp från " int". Detta beror särskilt på det faktum att " char" är den enda osignerade datatypen som är känd i Java. En förlustfri omvandling till " short" är inte längre möjlig från värdet 32768.

referenser

Alla objekt och fält finns i högminnet och refereras därför till via en adress. Objektåtkomst i Java implementeras med referenser som liknar pekare som är kända från C / C ++. Språkdefinitionen (Java Language Specification) hänvisar till dem som "referensvärden" för att göra det tydligt att de överförs med samtalsvärde . I Java finns det inget direkt sätt att visa referensens minnesadress eller ändra den, vilket utesluter så kallad pekare-aritmetik i Java.

Object a = new Object();  // a referenziert das gerade neu erstellte Objekt
Object b = a;             // b referenziert dasselbe Objekt wie a
a = null;                 // a referenziert kein Objekt mehr, enthält somit die reservierte Adresse null.

Det bör noteras här att teckensträngar (klass String) också representerar referenstyper och därför måste deras innehåll alltid equals()jämföras med metoden (" ==" kontrollerar endast referenser, d.v.s. minnesadresser). Detta står i kontrast till programmeringsspråk som C ++ och C # , som stöder full operatörsöverbelastning och "hallo"=="hallo"utför jämförelser av innehåll.

Reserverade ord

constoch gotoär reserverade, men utan funktion, så inga nyckelord i verklig mening. De tjänar bara kompilatorn för att mata ut användbara felmeddelanden för dem som byter från C ++ eller C.

true, falseoch nullär bokstavliga, men inte egentligen nyckelord i strikt mening.

Med assertär påståenden realiserade.

private, protectedOch publicär åtkomstmodifierare ( åtkomstmodifierare ):

1. ↑ För att ge inre klasser åtkomst till privata metoder och egenskaper skapar kompilatorn statiska, paket-privata metoder som efterliknar anrop, inställning eller läsning. Dessa metoder har namnet access$xxx, där står xxxför ett löpnummer.
2. ↑ Kallas ofta som "paket privat", även om denna åtkomstmodifierare inte finns.

Privata metoder utesluts från polymorfismen; H. Att definiera en metod med samma signatur i en underklass betraktas inte som överskrivning (utan snarare gömd ).

staticidentifierar implementeringar som kan användas utan en objektreferens. Nyckelordet används vid deklarering av fält, metoder och inre klasser. Fält, metoder och klasser som är staticmarkerade med kan användas i klassens sammanhang och är inte länkade till något objekt .

abstractkan visas framför klasser och metoder . Abstrakta metoder har ingen implementering och måste åsidosättas i härledda klasser. Klasser som innehåller abstrakta metoder måste själva förklaras abstrakta. Abstrakta klasser kan inte instansieras även om de är fullt implementerade, t.ex. B. när det gäller EventListener-adapterklasserna i Swing- ramverket.

finalkan visas framför variabler , fält, metoder och klasser och verkställer oföränderlighet. När det gäller variabler och medlemsvariabler, deras beständighet, i fallet med metoder omöjligheten att skriva över dem i härledda klasser, och slutligen när det gäller klasser, att inga ytterligare härledningar kan göras från dem. En slutlig variabel tilldelas ett engångsvärde som inte kan ändras efteråt. En slutlig variabel behöver inte initialiseras i deklarationen, men kan bara tilldelas en gång i följande alternativa instruktioner:

public int calcFinal(int a) {
  final int b; // hier findet noch keine Zuweisung statt
  switch (a) {
    case 1:
       b = 7;
       break;
    case 2:
       b = 3;
       break;
    default:
       b = 1;
       break;
  }
  return b;
}

Åtkomst till slutliga variabler vars kompilator känner till värdet kan ersättas av kompilatorn med värdet på variabeln. Kompilatorn kan ersätta anrop till slutliga metoder med inbäddad kod (inline). Privata metoder är automatiskt slutgiltiga.

nativekan bara visas framför metoder och innebär att implementeringen av metoden i fråga inte skrevs i Java utan på ett annat programmeringsspråk och måste integreras av den virtuella maskinen via ett runtime- bibliotek.

strictfpIdentifierar klasser och metoder, vars operationer med flytande punkt strikt måste följa IEEE 754 .

packageförklarar paketet tillhör en komplex datatyp. Namnet på ett paket bör vara tydligt och baseras mestadels på ägaren eller skaparens internetdomän .

importimporterar symboler (tidigare endast typer, från Java 5 också statiska medlemmar i klasser) så att de kan användas utan fullständigt kvalificerade namn. Importen kan *utvidgas till att kompletta paket med jokertecken .

boolean, char, byte, short, int, long, floatOch doubleär typer. voidicke-typen är nödvändig för att markera metoder utan returvärden. För de primitiva typerna: se ovan.

class, interface, enumOch @interfacetjänar till att förklara sina egna typer: klasser, gränssnitt (gränssnitt för klasser), enums ( uppräkningstyp för typ säker uppräkning, engelsk typ säker uppräkning ) samt anteckning metadata. enumoch @interfacehar införlivats i språket med Java 5.

try, catch, finally, throw, throwsSe undantagshantering (engelska undantagshantering ). Med throwundantag kastas. Alla undantag som tas upp med en metod som inte härrör från RuntimeExceptioneller Errormåste throwsanges i deklarationen av metoden. Dessa är så kallade kontrollerade undantag . trybifogar ett block där ett undantag kan förekomma. catchfångar tryundantaget som har inträffat efter ett block, läggs finallytill i tryeller catchblockerar för rensningsuppgifter som att stänga filer.

extendsoch implementstjäna till arv: extendsden genetiska förlängningen arv från klass till klass eller gränssnitt till gränssnitt och implementsimplementeringsarvet från gränssnitt till klass. Dessutom används extendsgenerika för typförlängning.

superoch thisrelaterar i objektkontexten till det aktuella objektet i dess verkliga morph ( this) eller i superklassens morph ( super). thisanvänds för att kalla konstruktörer överbelastade i konstruktörer och för att hänvisa till dolda delar av yttre strukturer i medlemmar. superanvänds i konstruktörer för att anropa superklasskonstruktören och i övergripande metoder för att anropa den åsidosatta metoden. Dessutom används supergeneriska medel för typavgränsning.

newreserverar minne för nya objekt (inklusive matriser) på högen .

if, else, switch, case, default, while, do, for, break, continueServe drift Test och loop kontroll och att använda sig av en tvingande syntax.

return returnerar värden från en metod till den anropande metoden.

volatileär en modifierare för icke-lokala variabler och förbjuder JIT-kompilatorn att registrera optimeringar på denna variabel eftersom flera trådar kan använda dem samtidigt (särskilt i samband med inhemska metoder).

synchronizedIdentifierar ett kritiskt avsnitt i källkoden som bara kan köras av en tråd i taget. En bildskärm låser sektionen så snart en tråd träder in i den. Om en annan tråd försöker komma in i det blockerade avsnittet, blockerar denna tråd tills monitorn släpper avsnittet. Vilket Java-objekt som helst kan användas som bildskärm. Om en metod är synchronizedmarkerad med objektet eller, i fallet med statiska metoder, används klassobjektet automatiskt som en bildskärm.

transient identifierar icke-beständiga variabler som inte får serieras.

instanceof är en Java-operatör som kontrollerar om ett objekt är en instans av en angiven typ eller subtyp.

Paket, namn, klasser, gränssnitt

Ett Java- paket innehåller flera klasser, gränssnitt och undantag och bildar sitt eget namnområde .

Java-källtext är indelat i flera kompileringsenheter , som var och en lagras i sin egen fil. Varje enskild översättningsenhet definierar först det paket som det tillhör, importerar sedan flera klasser eller gränssnitt från andra paket och definierar slutligen en eller flera klasser och gränssnitt.

Java skiljer mellan enkla namn, som bara består av en identifierare, och fullt kvalificerade namn, som består av en serie identifierare, åtskilda av perioder. De enkla namnen är bara ett hjälpmedel för att spara programmeraren att skriva och öka programmets läsbarhet. Kompilatorn översätter dem alltid till fullt kvalificerade namn.

Följande exempel visar ett Hello World-program i Java.

package org.wikipedia;

import static java.lang.System.out;

public class HalloWelt {

    public static void main(String[] arguments) {
        out.println("Hallo Welt.");
    }

}

I detta exempel HalloWeltdefinieras en klass " " som org.wikipediatillhör paketet " ". Enligt konvention är paketnamnen i Java baserade på utvecklarnas internetdomäner , i detta fall " org.wikipedia" för domänen " wikipedia.org". Namnets riktning är omvänd eftersom namnet på den yttersta enheten i Internet-domäner är på baksidan, medan det i Java är framför. Paketet " org.wikipedia" är därför "inom" paketet " org".

Ett importuttal definierar ett enkelt namn för ett fullständigt kvalificerat namn. Så definierade t.ex. Instruktionen " import java.io.File" ger till exempel det enkla namnet " File" för den klass vars fulla namn är " java.io.File". Förutom att importera klasser och gränssnitt kan statiska fält eller metoder för klasser också importeras sedan Java version 5. En sådan "statisk import" definieras av det extra nyckelordet " static". I exemplet ovan importeras det statiska fältet " out" för klassen " java.lang.System" och används sedan under det korta namnet " out".

Den viktigaste konstruktionen av Java-programmeringsspråket, eftersom det är ett objektorienterat språk, är klassen . Den förklaring om en klass införs med sökordet " class". Detta följs av klassens namn och sedan - i lockiga parenteser - definieras klassens fält och metoder.

Gränssnittet är en Java-specialitet. Ett sådant gränssnitt består endast av metoddeklarationer, vars implementering endast bestäms av de klasser som "implementerar" dem. Deklarationen av ett gränssnitt liknar deklarationen för en klass, men den introduceras med nyckelordet " interface".

package org.wikipedia;

public interface Article {

    String getName();

    void setContent(String aContent);

}

Eftersom alla metoder i ett gränssnitt är abstrakta kan nyckelordet ” abstract” utelämnas för de enskilda metoderna. Nyckelordet " public" framför de enskilda metoderna kan också utelämnas eftersom metoder för ett gränssnitt alltid är offentliga.

Från och med Java 8 finns det också möjlighet att defaultdefiniera statiska metoder och " " metoder i gränssnitt . Dessutom kan gränssnitt antecknas med “ @FunctionalInterface” för att indikera att de är funktionella gränssnitt. Sådan definieras genom att förklara exakt en abstrakt metod; anteckningen krävs inte för detta. Funktionella gränssnitt kan implementeras i ett nötskal med lambdauttryck eller metodreferenser.

Metoder

Ett objekts faktiska beteende definieras i metoder. Den undertecknandet av en metod består av dess namn och vilka typer av dess parametrar. Dessutom har varje metod en specifik returtyp, eller " void" om den inte returnerar någonting, och kan throwsdefiniera ett antal undantag i det som kallas " ".

Exempel på en konkret metod:

public double summe(double a, double b) throws NotANumberException {
    if (Double.isNaN(a) || Double.isNaN(b)) {
        throw new NotANumberException();
    }
    return a + b;
}

Den här metoden förväntar sig två flytande punktnummer med dubbla precision som parametrar och returnerar också summan av de två som flytande nummer. Om ett av de två siffrorna inte är ett giltigt flytande nummer, ger metoden ett undantag som heter " NotANumberException".

Exempel på en abstrakt metod:

public abstract double summe(double a, double b) throws NotANumberException;

Attribut

Attribut är variabler som tillhör ett objekt. De definieras av en typ och ett namn och kan valfritt initieras när objektet skapas.

Exempel på en variabeldeklaration utan initialisering:

private int x;

Klassvariabler deklareras som statiska attribut. Dessa attribut finns inte en gång per objekt utan bara en gång per klass. Nyckelordet " final" hindrar en variabel från att ändra sitt värde efter att den har initialiserats. Den används till exempel för att definiera konstanter.

Exempel på en statisk och slutlig klassvariabeldeklaration med initialisering:

private static final int X = 2;

Fält

I Java-programmeringsspråket är ett fält (engelsk array ) ett oberoende objekt. Detta kan acceptera data av den typ som anges i deklarationen. Minnet upptas endast när fältet initialiseras. För att göra detta måste en längd ( storlek ) anges som beskriver hur många element av en typ fältet ska ha. Storleken på en matris är fast och kan inte ändras efter att den har instanserats. I Java indexeras alltid ett fält med ett positivt heltal. Detta begränsar den möjliga längden på en matris till 0 till 2 ³¹ - 1.

De enskilda elementen i ett fält - analoga med attributen för andra objekt - initialiseras med nollvärdet för respektive fältbastyp när fältet instansieras. För fält med numeriska primitiva typer är detta 0 eller 0,0, för ett fält med bastypen boolean är det värdet false, för fält med objektreferenser är det den tomma referensen null. När du skapar ett fält med objektreferenser skapas inga objekt förutom själva fältet.

Det finns inga riktiga flerdimensionella fält i Java. Det är dock möjligt att skapa flerdimensionella fält genom att kapa fält i fält. När det gäller ett tvådimensionellt fält skapas först ett fält som kan innehålla referenser till fält av önskad typ. En hänvisning till ett endimensionellt fält av önskad bastyp tilldelas sedan varje plats i detta fält.

Endimensionellt fält

deklaration

<Datentyp>[] <Variablenbezeichner>; // Deklaration
<Datentyp> <Variablenbezeichner>[]; // Alternative Deklaration (seltener verwendet)

Datatypen för fältet anges i deklarationen. Inget fält tilldelas dock, men som med alla andra objekt definieras endast en referens av en typ som ett fält kan tilldelas.

Instantiering

<Variablenbezeichner> = new <Datentyp>[<Anzahl>]; // Instanziierung eines eindimensionalen Feldes

När du startar ett endimensionellt fält måste både dess datatyp och antalet element vara kända. Som noterats i början är längden på ett fält begränsat till icke-negativa helvärden. Nyckelordet newhar här samma betydelse som med alla andra objekt och skapar en instans av typen. Det erforderliga minnet är reserverat för objektet såväl som för dess element. Till skillnad från andra objekt har dock fälten inga konstruktörer och det är inte möjligt att bilda undertyper av en fälttyp genom uttrycklig härledning.

Exempel på ett endimensionellt fält av typen int med längd 3

int[] feld = new int[3];  // auf der linken Seite wird die Objektreferenz deklariert
                          // auf der rechten Seite wird das Feld initialisiert

Deklarationen och instansieringen behöver inte göras separat utan kan som vanligt också skrivas som en instruktion. När du öppnar elementen, observera att Java börjar räkna med index 0. I detta exempel nås det första elementet med index 0 och det sista elementet med index 2.

int[] feld = {1,2,3}

är en förkortning av

int[] feld = new int[3];
feld[0]=1;
feld[1]=2;
feld[2]=3;

Läser upp värden

int a = feld[0];         // das Auslesen erfolgt durch Angabe des Index
objekt.methode(feld[1]); // Einzelwerte eines Feldes können wie Variablen des gleichen Typs verwendet werden
int b = feld[3];         // würde in diesem Beispiel eine IndexOutOfBoundsException auslösen, da es kein 4. Element gibt

Tilldelning av värden

feld[0] = 5;             // Java ist "nullbasiert"
feld[1] = (int) 2.7;     // bei Zuweisungen muss wie bei normalen Variablen der Typ angepasst werden
feld[2] = 0;             // die Indexierung läuft immer bis n-1

Fältets längd Många algoritmer kräver längden på ett fält, till exempel för att bearbeta alla poster. Längden på ett fält är känt vid körning och kan lengthifrågasättas via objektvariabeln , som själv är av typen int. Denna variabel är alltid konstant och kan inte ändras. Det är därför inte möjligt att tilldela ett annat värde.

int len = feld.length;   // Liest die Länge des Feldes aus und speichert sie in der Variablen len
feld.length = 5;         // diese Zuweisung würde einen Fehler beim Kompilieren ergeben, da sie nicht zulässig ist

Flerdimensionella fält

Exempel på konstruktion av en tvådimensionell dubbel array.

Som redan nämnts känner Java inte igen flerdimensionella fält. Fält kan dock kapslas in i varandra för att erhålla en analog struktur. Ett tvådimensionellt fält kan jämföras med en tabell, där det första (yttre) indexeringsfältet hänvisar till raden. Själva raden är i sin tur ett fält vars index hänvisar till kolumnen i raden, dvs. till motsvarande post, vilket också kan ses i figuren.

I Java kan flerdimensionella fält implementeras genom att ange flera par hakparenteser [], varje par står för en ytterligare dimension av fältet. Det yttre fältet, som indikerar nästa inre, är på vänster sida eller är det parfäste som definierades först. Detta kan ses i exemplet med en bild som vanligtvis skulle [y][x]indexeras, varvid raden (y) bestäms först och sedan kolumnen (x) från raden.

Exempel på att skapa ett tvådimensionellt fält

double[][] feld = new double[zeilen][spalten];

I detta exempel bör det noteras att inte bara det yttre fältet (här kallas fältet ) tilldelas utan också fälten för "raderna". Så de är inte noll och skapades också. Som förväntat från ett endimensionellt fält initialiseras dina poster med 0 .

I en matris kallas de horisontella fälten rader, de vertikala fälten kallas kolumner. Ett enskilt element bestäms unikt av respektive rad- och kolumnindex. Syntaxen för en matris eller i allmänhet för flerdimensionella fält är nästan identisk. Skillnaden ligger i antalet stängda hakparenteser som berättar hur många dimensioner fältet kommer att ha.

Exempel på skapande av ett tvådimensionellt fält med olika storlekar i "underfält"

double[][] feld = new double[3][];
feld[0] = new double[3];
feld[1] = new double[2];
feld[2] = new double[1];

I detta exempel bör det noteras att i det första kommandot tilldelas endast det externa fältet (i detta fall fältet kallat) och de enskilda elementen med noll att initialisera. I följande kommandon tilldelas dessa element sedan "underfält", vilket resulterar i ett "triangulärt" fält.

Som med endimensionella matriser finns det också en förkortad version av multidimensionella matriser:

int[][] array2D={{1,2,3},{4,5,6}};
//Entspricht "=new int[2][3];" mit den darauf folgenden Zuweisungen
//"array2D[0][0]=1;"
//"array2D[0][1]=2;"
//(...)
//"array2D[1][2]=6;"

Där hakparenteserna ([]) är placerade är det programmeraren:

int[][] A

är det samma som

int A[][]

eller

int[] A[]

Allmän syntax

<Datentyp> []… <Feldvariable> = new <Datentyp> [<Anzahl>]… ;

De ellipser '...' representerar ytterligare par av konsoler, vilka var och en skapar en ytterligare dimension. Tillgången till elementen är analog med ett endimensionellt fält. Det bör dock noteras att respektive yttre fält också kan nås till t.ex. B. för att bestämma antalet rader. Baserat på exemplet med ett tvådimensionellt fält kan antalet bestämmas enligt följande.

Läsa upp och tilldela värden

double wert = feld[y][x];                // liefert den Wert des Feldes x,y
feld[y][x] = wert;                       // weist dem Feld x,y einen Wert zu

Bestämning av fältets längd och delfälten

int zeilenanzahl = feld.length;          // weist der Variable "zeilenanzahl" den Wert von "feld.length" zu

Längden på underfälten kan bestämmas med hjälp av fältets index.

int spaltenanzahl = feld[index].length;  // weist der Variable "spaltenanzahl" den Wert von "feld[index].length" zu

I lång form eller uppdelad i enskilda steg skulle detta se ut så här. Detta visar också att linjerna är objekt - endimensionella fält.

double[] zeilenfeld = feld[index];       // ermittelt das erste "Unterfeld" mit gegebenen Index
int spaltenanzahl = zeilenfeld.length;   // weist der Variable "spaltenanzahl" den Wert von "zeilenfeld.length" zu

Instruktioner och kontrollstrukturer

Structogram för ett linjärt program

Java stöder de vanliga instruktionerna som också är kända från andra tvingande programmeringsspråk. Enkla instruktioner avslutas med semikolon . Flera instruktioner kan kombineras för att bilda ett instruktionsblock med hjälp av lockiga hängslen. Kontrollstrukturer behandlas också som block och behöver därför inte (med ett undantag) avslutas med semikolon.

Eftersom kontrollstrukturer är villkorligt uttalande och förgrening och falluttalande , och While - Do-while - och For loop och dess olika former är tillgängliga.

Villkorligt uttalande och gren

Struktogram för ett if-uttalande

Struktogram för ett if-else-uttalande

Det villkorliga uttalandet och filialen , som i det följande kallas If-uttalandet , gör att uttalanden kan utföras under förutsättning att ett visst villkor är. Nyckelordet "om" används för detta. Detta följs av ett par runda fästen där tillståndet kan definieras. Villkoret är ett uttryck som måste returnera ett booleskt värde ( sant eller falskt ) som resultat . Detta skiljer Java från andra språk som C, där andra värden också är tillåtna som villkor. Det bör också noteras att det ofta förekommande nyckelordet "då" inte finns.

Nyckelordet "annat" kan användas för att utföra ett uttalande om villkoret inte är uppfyllt. Det är valfritt och i det här fallet kallas det en gren eftersom antingen det första eller det andra uttalandet körs. Alternativt kan istället för "annat" användas ett "annat om" som, liksom det första "om", förväntar sig ett ytterligare tillstånd. Detta gör det möjligt att bygga kaskader av grenar. Utan att strukturera med block (lockiga parenteser) finns det dock en risk att dingla annat , där det inte är klart vilket If-uttalande Else-grenen ska tilldelas.

Allmän syntax

if (<Bedingung>)
    <Anweisung>;
else
    <Anweisung>;

Exempel på ett enkelt If-uttalande med ett block med två utgångar

if (i < 0) {
    System.out.print("Die Zahl ist negativ"); // Bedingte Ausgabe
    System.out.println();                     // Zeilenumbruch auf der Konsole
}

Mer komplicerat exempel

if (i < 0) {
    System.out.println("Die Zahl ist negativ");
}
else if (i == 0) {
    System.out.println("Die Zahl ist Null");
}
else if (i < 5) {
    System.out.println("Die Zahl ist kleiner als 5");
}
else {
    System.out.print("Die Zahl ist größer oder gleich 5");
}

Den ternära operatören

Det finns en ytterligare förkortning för ett enkelt If-uttalande. Detta kan användas inom ett uttryck, men är begränsat till ett ”antingen-eller”. Dvs i vilket fall som helst måste den returnera ett specifikt värde. Operatören själv är frågetecknet '?' som måste föregås av ett booleskt uttryck. Returvärdet för det fall att det booleska uttrycket är sant följer frågetecknet. Detta följs av ett kolon ':' varefter returvärdet måste följa om det booleska uttrycket inte är sant (falskt).

syntax

<Bedingung> ? <Ausdruck> : <Ausdruck>

exempel

int a = (i<0) ? -i : i; // kehrt vor der Zuweisung an a das Vorzeichen von i um, wenn i negativ ist (Betrag von i)

Byt uttalande

Struktur för en switchinstruktion

• En åtskillnad mellan fall där uttrycket kan vara ett tecken, ett heltal, en teckensträng eller en uppräkningstyp.

switch (''Ausdruck'') {
   case ''Konstante1'': ''Anweisung1''; break;
   case ''Konstante2'': ''Anweisung2''; break;
   default: ''Anweisung3'';
}

slipa

Java skiljer fyra olika typer av slingor .

• 

  Structogram: While loop

• 

  Structogram: gör-medan-slinga

• 

  Struktogram: För slinga

• Upprepa ett uttalande så länge villkoret är sant, varigenom villkoret kontrolleras före uttalandet ( under loop ).

while (''Bedingung'') ''Anweisung'';

• Upprepning av en instruktion så länge villkoret är sant, varvid villkoret endast kontrolleras efter körning ( gör-medan-slinga ).

do ''Anweisung''; while (''Bedingung'');

• Initierar ett värde, upprepar uttalandet så länge villkoret är sant och utför ett andra uttalande efter varje looppass ( för loop ).

for (''Initialisierung''; ''Bedingung''; ''Anweisung2'') ''Anweisung1'';

• Dessutom finns det en utökad för loop, även känd som en foreach-loop, som gör det möjligt att utföra uttalanden för varje element i ett iterabelt objekt ( sekvenser , listor etc.).

for (''Element'' : ''Kollektion'') ''Anweisung'';

Följande exempel visar användningen av en sådan utökad för loop, applicerad en gång på basdatatypen charoch en gång i en lista.

char[] chars = new char[] { 'a', 'b', 'c' }; // neues Zeichen-Array anlegen
for (char c : chars) {
    System.out.println("Zeichen: " + c); // Jedes Zeichen auf die Konsole schreiben.
}

List<Character> charlist = new ArrayList<Character>(); // neue Zeichen-Liste anlegen
charlist.add('a'); // Werte hinzufügen (mit Autoboxing)
charlist.add('b');
charlist.add('c');
for (Character c : charlist) {
    System.out.println("Zeichen: " + c); // Jedes Zeichen auf die Konsole schreiben.
}

Uttryck

Till skillnad från andra programmeringsspråk, som C , är sekvensen i vilken uttryck utvärderas i Java redan definierad i språkdefinitionen: binära infix-operatörer av samma rang som inte är tilldelningsoperatörer utvärderas alltid från vänster till höger. Dessutom, som i C, kan utvärderingen av logiska uttryck förkortas om resultatet redan har fastställts. I följande exempel är det garanterat att först kontrollera om " objekt" inte är " null". Om detta subuttryck är falskt ( objektdvs. det är en nullreferens) &&utvärderas inte rätt operand alls, dvs. H. metoden inOrdnung()söks inte efter eller ens kallas. Således är det övergripande uttrycket säkert och kan aldrig orsaka ett " NullPointerException". (A " NullPointerException" kastas alltid i Java när ett försök görs för att nulllösa objektreferensen " ".)

if (objekt != null && objekt.inOrdnung()) {
    System.out.println("in Ordnung");
}
else {
    System.out.println("ungeprüft oder Prüfung misslungen");
}

Om bitoperatorerna och används istället för de logiska operatorerna &&och måste båda delresultaten länkas bit för bit och bearbetningen kan inte avbrytas med det vänstra uttrycket, om så är fallet. Så om variabeln har värdet försöker Java VM att länka värdet som härrör från det första uttrycket med resultatet av det andra uttrycket bit för bit. För att beräkna det andra uttrycket försöker den virtuella datorn att avlägsna och kastar en . ||&|falseobjektnullfalseobjektNullPointerException

Funktionella gränssnitt och lambdauttryck

Ett lambdauttryck är en namnlös (anonym) metod som kan skickas (som ett objekt). Lambdauttryck beskriver därför funktionsobjekt. Termen går tillbaka till lambdakalkylen , ett formellt språk för att undersöka funktioner (se även funktionell programmering ). Lambda-uttryck i Java har funnits sedan Java 8 och inkluderar parameterlistor, en returtyp och en kropp:

(<Datentyp> <Variablenbezeichner>,...,<Datentyp> <Variablenbezeichner>) -> <Anweisungsblock>
(<Datentyp> <Variablenbezeichner>,...,<Datentyp> <Variablenbezeichner>) -> <Ausdruck>
(<Variablenbezeichner>,...,<Variablenbezeichner>) -> <Anweisungsblock>
(<Variablenbezeichner>,...,<Variablenbezeichner>) -> <Ausdruck>

De runda parenteserna kan utelämnas om antalet element som finns exakt är ett. Specifikationen av parametertyperna är endast nödvändig om kompilatorn inte kan dra slutsatsen från uttrycket. En funktion som returnerar summan av två argument kan uttryckas enligt följande:

(i,j) -> i+j

De har inte en specifik typ själva och kan därför endast användas i ett sammanhang som anger en typ, såsom metodanrop, returuttalanden och variabla initialiseringar. Den angivna typen måste vara ett funktionellt gränssnitt. I följande exempel Comparator<String>definieras ett objekt med hjälp av ett lambdauttryck. De sortsamtals effekter sortering av someStringsi enlighet med deras längd i fallande ordning.

List<String> someStrings = ...
Collections.sort(someStrings, (x,y) -> y.length() - x.length());

Lambdauttryck hjälper till att undvika de ofta svåra att läsa, långa deklarationer av inre, anonyma klasser.

I Java kallas gränssnitt som bara har en operation (abstrakt metod) funktionella gränssnitt . En abstrakt klass med bara en abstrakt metod är dock inte som ett funktionellt gränssnitt.

Metodreferenser är också ett alternativ tillgängligt från Java 8 och framåt för att implementera funktionella gränssnitt. Du har en av blanketterna

<Klassenreferenz>::<Methodenbezeichner>
<Ausdruck>::<Methodenbezeichner>

Följande kod använder metodreferensen System.out::printlnsom ett java.util.function.Consumer<String>objekt.

static <A> Consumer<A> doTwice(Consumer<A> consumer) {
    return a -> {
        consumer.accept(a);
        consumer.accept(a);
    };
}
static void foo() {
    doTwice(System.out::println).accept("Hello");
}

Kommentarer

Kommentarer är delar av källkoden som innehåller information för den mänskliga läsaren och ignoreras av datorn under vidare bearbetning.

En skillnad görs mellan radkommentarer och blockkommentarer. Radkommentaren följer på en rad. Syntaxen består av ett dubbelt snedstreck. Blockkommentaren innehåller beskrivningen av flera rader. Syntaxen för detta består av ett snedstreck följt av en mal-symbol. Kommentaren avslutas med märket och snedstrecket. Kompilatorn ignorerar kommentarerna vid kompileringen.

Exempel:

 int i = 10; // Zeilenkommentar: hier bekommt die Variable i den Wert 10 zugewiesen.
 int j = 0;

/* Blockkommentar: hier beginnt eine While-Schleife
....
j wird um Eins erhöht, solange j kleiner i ist.*/
 while (j < i) {
  j++;
 }

Javadoc- systemet används ofta för att dokumentera hela metoder eller klasser .

Generisk programmering

Med version 5 av Java introducerades språkelementet för generisk programmering.

webb-länkar

• Java-syntax . Olika tabeller om Java-syntax (tyska)

Individuella bevis

1. ↑ Scott Stanchfield: Java är förbipasserat värde, Dammit! JavaDude.com, nås den 5 november 2010 . 
2. ↑ Typer, värden och variabler. (Inte längre tillgängligt online.) I: Java Language Specification. Oracle (Sun), arkiverad från originalet den 9 mars 2012 ; nås den 6 november 2010 (engelska). Info: Arkivlänken infogades automatiskt och har ännu inte kontrollerats. Kontrollera original- och arkivlänken enligt instruktionerna och ta bort detta meddelande. @ 1@ 2Mall: Webachiv / IABot / docs.oracle.com 
3. ↑ Martin Gerlach: Java SE 8 Innovations (del 1): Lambda-uttryck och standardmetoder I: Neo Tech Blog (skapad 17 november 2014, åtkomst 16 december 2016).