Clojure för funktionell programmering och JVM-backendutveckling · Lektion

Anropa Java från Clojure

Upptäck hur ni anropar Java-metoder, kommer åt fält och instansierar objekt direkt från Clojure-kod.

Lektion 1 av 411 steg

Anropa Java från Clojure är en gratis lektion i Clojure för funktionell programmering och JVM-backendutveckling på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Clojure för funktionell programmering och JVM-backendutveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Clojure för funktionell programmering och JVM-backendutveckling innehåller totalt 4 lektioner.

Clojure och Java: bästa vänner!

Clojure körs på Java Virtual Machine (JVM), vilket innebär att språket kan använda alla fantastiska Java-bibliotek direkt! Detta kallas Java Interop.

Få åtkomst till Java-klasser och metoder.
Dra nytta av det omfattande Java-ekosystemet.
Kombinera Clojures kraft med Javas stabilitet.

I den här lektionen får ni lära er hur ni anropar Java-kod från Clojure.

Skapa Java-objekt

För att använda en Java-klass behöver ni ofta skapa en instans av den. I Clojure kan ni göra detta med en särskild syntax.

Använd (new ClassName args) eller kortformen (ClassName. args).
Punkten . efter klassnamnet är ett praktiskt sätt att anropa en konstruktor.

Exempel: (java.util.Date.) skapar ett nytt Date-objekt.

Demo: nytt Date-objekt

Prova att skapa ett nytt java.util.Date-objekt. Det representerar aktuellt datum och aktuell tid.

(ns my-app.core
  (:gen-class))

(defn -main
  "Creates and prints a new Java Date object."
  [& args]
  (let [current-date (java.util.Date.)]
    (println "Current date:" current-date)))

Anropa statiska Java-metoder

Statiska metoder hör till själva klassen, inte till en specifik objektinstans. Ni kan anropa dem direkt på klassen.

Syntax: (ClassName/staticMethodName args)
/ separerar klassnamnet från den statiska metodens namn.

Exempel: (java.lang.Math/random) anropar den statiska metoden random i klassen Math.

Demo: Math.random()

Vi hämtar ett slumptal med Javas statiska metoden Math/random. Den returnerar ett double-värde mellan 0.0 (inklusive) och 1.0 (exklusive).

(ns my-app.core
  (:gen-class))

(defn -main
  "Generates and prints a random number using Java's Math/random."
  [& args]
  (let [rand-num (java.lang.Math/random)]
    (println "Random number:" rand-num)))

Anropa instansmetoder i Java

När Ni har ett objekt kan Ni anropa dess instansmetoder. Dessa metoder arbetar med data i just det objektet.

Syntax: (.methodName instance args) eller (. instance methodName args).
Pricken . före metodnamnet anger att det är ett anrop av en instansmetod.

Exempel: (.getTime my-date) anropar metoden getTime på objektet my-date.

Demo: Date.getTime()

Skapa ett Date-objekt och anropa sedan dess metod getTime(). Metoden returnerar antalet millisekunder sedan den 1 januari 1970 kl. 00:00:00 GMT.

(ns my-app.core
  (:gen-class))

(defn -main
  "Creates a Date object and calls its getTime() method."
  [& args]
  (let [current-date (java.util.Date.)
        time-in-millis (.getTime current-date)]
    (println "Current date:" current-date)
    (println "Milliseconds since epoch:" time-in-millis)))

Åtkomst till Java-fält

Java-objekt kan ha fält (variabler) som lagrar data. Ni kan komma åt dessa fält direkt från Clojure.

Syntax: (.-fieldName instance) för att hämta värdet i ett fält.
Använd (.-staticFieldName ClassName) för statiska fält.

Exempel: (.-out System) ger åtkomst till det statiska fältet out i klassen System, som är ett PrintStream-objekt.

Demo: fältet System.out

Klassen java.lang.System har ett statiskt fält med namnet out, som är ett PrintStream-objekt. Vi kan komma åt det för att skriva ut till konsolen.

(ns my-app.core
  (:gen-class))

(defn -main
  "Accesses System.out and prints a message using its println method."
  [& args]
  (let [out-stream (.-out java.lang.System)]
    (.println out-stream "Hello from System.out!")))

Snabbtest: Java-interoperabilitet

Ni har lärt Er hur man interagerar med Java-klasser. Vilket Clojure-uttryck använder kortformen ClassName. för att skapa ett java.io.File-objekt för sökvägen "myfile.txt"?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Grunderna i Java-interoperabilitet

Bra jobbat! Ni har lärt Er grunderna i att interagera med Java från Clojure:

Skapa objekt: Använd (ClassName. args) eller (new ClassName args).
Anropa statiska metoder: Använd (ClassName/staticMethodName args).
Anropa instansmetoder: Använd (.methodName instance args) eller (. instance methodName args).
Komma åt fält: Använd (.-fieldName instance).

Denna kraftfulla funktion gör att Ni kan utnyttja hela Java-ekosystemet i Era Clojure-projekt. Därefter utforskar vi hur man implementerar Java-gränssnitt.

Gratis att börja

Lär dig Clojure med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Anropa Java från Clojure” gratis?

Ja – hela texten till ”Anropa Java från Clojure” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Clojure för funktionell programmering och JVM-backendutveckling, kan Ni uppgradera till CoddyKit PRO. Kursen i Clojure för funktionell programmering och JVM-backendutveckling innehåller totalt 4 lektioner.

Vad lär jag mig i ”Anropa Java från Clojure”?

Upptäck hur ni anropar Java-metoder, kommer åt fält och instansierar objekt direkt från Clojure-kod. Ni övar på Clojure för funktionell programmering och JVM-backendutveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Clojure för funktionell programmering och JVM-backendutveckling?

Du behöver inga förkunskaper. Utbildningen i Clojure för funktionell programmering och JVM-backendutveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Anropa Java från Clojure”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Clojure för funktionell programmering och JVM-backendutveckling-lektionen?

Ja. Varje Clojure för funktionell programmering och JVM-backendutveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Clojure för funktionell programmering och JVM-backendutveckling