0Pricing
Clojure Functional Programming & JVM Backend Development · Lektion

Java aus Clojure aufrufen

Entdecken Sie, wie Sie Java-Methoden aufrufen, auf Felder zugreifen und Objekte direkt aus Clojure-Code instanziieren

Java aus Clojure aufrufen ist eine kostenlose Clojure Functional Programming & JVM Backend Development-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Clojure Functional Programming & JVM Backend Development-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Clojure Functional Programming & JVM Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Clojure & Java: Best Friends!

Clojure runs on the Java Virtual Machine (JVM), which means it can use all the amazing Java libraries directly! This is called Java Interop.

  • Access Java classes and methods.
  • Leverage the vast Java ecosystem.
  • Combine Clojure's power with Java's stability.

This lesson will show you how to call Java code from Clojure.

Creating Java Objects

To use a Java class, you often need to create an instance of it. In Clojure, you can do this using a special syntax.

  • Use (new ClassName args) or the shorthand (ClassName. args).
  • The . after the class name is a convenient way to call a constructor.

Example: (java.util.Date.) creates a new Date object.

Demo: New Date Object

Try creating a new java.util.Date object. It will represent the current date and time.

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

Calling Static Java Methods

Static methods belong to the class itself, not to a specific object instance. You can call them directly on the class.

  • Syntax: (ClassName/staticMethodName args)
  • The / separates the class name from the static method name.

Example: (java.lang.Math/random) calls the random static method of the Math class.

Demo: Math.random()

Let's get a random number using Java's Math/random static method. It returns a double between 0.0 (inclusive) and 1.0 (exclusive).

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

Calling Instance Java Methods

Once you have an object, you can call its instance methods. These methods operate on that specific object's data.

  • Syntax: (.methodName instance args) or (. instance methodName args).
  • The . before the method name indicates an instance method call.

Example: (.getTime my-date) calls the getTime method on the my-date object.

Demo: Date.getTime()

Create a Date object and then call its getTime() method. This method returns the number of milliseconds since January 1, 1970, 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)))

Accessing Java Fields

Java objects can have fields (variables) that store data. You can access these fields directly from Clojure.

  • Syntax: (.-fieldName instance) for getting a field's value.
  • For static fields, use (.-staticFieldName ClassName).

Example: (.-out System) accesses the out static field of the System class, which is a PrintStream.

Demo: System.out Field

The java.lang.System class has a static field named out, which is a PrintStream object. We can access it to print to the console.

(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!")))

Quick Check: Java Interop

You've learned how to interact with Java classes. Which Clojure expression uses the ClassName. shorthand to instantiate a java.io.File object for the path "myfile.txt"?

Recap: Java Interop Basics

Great job! You've learned the fundamentals of interacting with Java from Clojure:

  • Instantiate objects: Use (ClassName. args) or (new ClassName args).
  • Call static methods: Use (ClassName/staticMethodName args).
  • Call instance methods: Use (.methodName instance args) or (. instance methodName args).
  • Access fields: Use (.-fieldName instance).

This powerful capability allows you to leverage the entire Java ecosystem within your Clojure projects. Next, we'll explore implementing Java interfaces.

Häufig gestellte Fragen

Ist die Lektion „Java aus Clojure aufrufen“ kostenlos?

Ja — der vollständige Text von „Java aus Clojure aufrufen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Clojure Functional Programming & JVM Backend Development-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Clojure Functional Programming & JVM Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Java aus Clojure aufrufen“?

Entdecken Sie, wie Sie Java-Methoden aufrufen, auf Felder zugreifen und Objekte direkt aus Clojure-Code instanziieren Du übst Clojure Functional Programming & JVM Backend Development mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Clojure Functional Programming & JVM Backend Development zu starten?

Keine Vorkenntnisse erforderlich. Clojure Functional Programming & JVM Backend Development auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Java aus Clojure aufrufen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Clojure Functional Programming & JVM Backend Development-Lektion Code schreiben und ausführen?

Ja. Jede Clojure Functional Programming & JVM Backend Development-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Java aus Clojure aufrufen
  2. Java-Interfaces implementieren
  3. Java-Bibliotheken und -Tools nutzen
  4. Mit Java-Collections und Arrays arbeiten
← Zurück zu Clojure Functional Programming & JVM Backend Development