{"id":671982,"date":"2026-01-05T05:46:41","date_gmt":"2026-01-05T04:46:41","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=kotlin&#038;p=671982"},"modified":"2026-01-05T05:46:46","modified_gmt":"2026-01-05T04:46:46","slug":"einfuehrung-in-kotlin-fuer-java-entwickler-innen","status":"publish","type":"kotlin","link":"https:\/\/blog.jetbrains.com\/de\/kotlin\/2026\/01\/einfuehrung-in-kotlin-fuer-java-entwickler-innen\/","title":{"rendered":"Einf\u00fchrung in Kotlin f\u00fcr Java-Entwickler*innen"},"content":{"rendered":"<p><em>Gastbeitrag von <a href=\"https:\/\/www.linkedin.com\/in\/urs-peter-70a2882\/\" target=\"_blank\" rel=\"noreferrer noopener\" data-type=\"link\" data-id=\"https:\/\/bit.ly\/urs-peter-linked-in\">Urs Peter<\/a>, Senior Software Engineer und JetBrains-zertifizierter Kotlin Trainer. F\u00fcr Leser*innen, beim Ausbau ihrer Kotlin-Kenntnisse strukturierter vorgehen m\u00f6chten, leitet Urs auch das <\/em><a href=\"https:\/\/academy.xebia.com\/upskilling\/kotlin-academy\/\" target=\"_blank\" rel=\"noreferrer noopener\"><em>Kotlin Upskill Program<\/em><\/a><em> an der Xebia Academy.<\/em><\/p>\n<p><em>Dies ist der erste Beitrag der Reihe <\/em><strong><em>Der ultimative Leitfaden f\u00fcr den erfolgreichen Einstieg in Kotlin in einer Java-dominierten Umgebung<\/em><\/strong><em>, die der Frage nachgeht, wie sich Kotlin in Teams in der realen Welt verbreitet, beginnend mit der Neugier einer einzelnen Person bis hin zum unternehmensweiten Wechsel.<\/em><\/p>\n<hr class=\"wp-block-separator has-alpha-channel-opacity\" \/>\n<p class=\"has-text-align-left\">\u201e<em>Man kann nicht einfach einen Schalter umlegen und zu Kotlin wechseln.<\/em><\/p>\n<p class=\"has-text-align-left\"><em>Risiken minimieren, Messungen durchf\u00fchren, Erfolge feiern \u2013<\/em><\/p>\n<p class=\"has-text-align-left\"><em>erst dann hei\u00dft es: volle Kraft voraus.<\/em>\u201c<\/p>\n<p>Die Einf\u00fchrung von Kotlin in einer etablierten Java-Umgebung ist nicht nur eine technische Entscheidung \u2013 es ist ein Prozess, der sorgf\u00e4ltige Planung, strategisches Denken und vor allem die Unterst\u00fctzung Ihrer Kolleg*innen erfordert.<\/p>\n<p>Nachdem ich mehr als 1.000 Entwickler*innen geschult und zahlreiche Organisationen bei der erfolgreichen Umstellung auf Kotlin begleitet habe, wei\u00df ich, was funktioniert und was nicht. Dieser Leitfaden f\u00fchrt Sie durch bew\u00e4hrte Methoden zur Einf\u00fchrung von Kotlin, die ich im Lauf der Zeit gesammelt habe, von der ersten Experimentierwiese bis hin zur umfassenden Transformation eines Unternehmens.<\/p>\n<p>Dies ist die Reise, auf die Sie unsere Reihe mitnehmen wird:<\/p>\n<ul>\n<li><a href=\"#it-always-starts-with-a-spark,-initiated-by-you\" data-type=\"link\" data-id=\"https:\/\/blog.jetbrains.com\/#it-always-starts-with-a-spark,-initiated-by-you\">Am Anfang steht der Funke, der von Ihnen entfacht wird<\/a><\/li>\n<li><a href=\"#the-play-around-stage-start-small-\u2013-with-tests\">Die Experimentierphase: Bescheiden anfangen \u2013 mit Tests<\/a><\/li>\n<li>Die Evaluierungsphase: Wenn Kotlin mehr als nur eine Spielwiese ist<\/li>\n<li>Weitersagen: Die Unterst\u00fctzung Ihrer Entwicklerkolleg*innen gewinnen<\/li>\n<li>Das Management \u00fcberzeugen: Der Business Case f\u00fcr Kotlin<\/li>\n<li>Erfolgsfaktoren f\u00fcr eine gro\u00dffl\u00e4chige Einf\u00fchrung von Kotlin<\/li>\n<li>Mit Kotlin oder ohne Kotlin: Welcher Unternehmenstyp wollen Sie sein?<\/li>\n<\/ul>\n<h2 class=\"wp-block-heading\"><strong>Am Anfang steht der Funke, der von Ihnen entfacht wird<\/strong><\/h2>\n<figure class=\"wp-block-image size-full\"><img decoding=\"async\" loading=\"lazy\" class=\"wp-image-647072\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/unnamed-12.png\" alt=\"Am Anfang steht der Funke, der von Ihnen entfacht wird\" width=\"1586\" height=\"526\" \/><\/figure>\n<p><em>Warum sollte man den Aufwand betreiben, zu Kotlin zu wechseln? Warum nicht einfach bei Java bleiben und weitermachen?\u00a0<\/em><\/p>\n<p>Die Antwort h\u00e4ngt von zahlreichen Faktoren ab. Zwar zeigen die Daten in mehreren Bereichen klare Vorteile f\u00fcr Kotlin, aber die Entscheidung ist nicht rein technischer Natur. Subjektivit\u00e4t (\u201eIch mag meine Sprache, weil sie mir einfach gef\u00e4llt\u201c) und Skepsis gegen\u00fcber Neuem, was meist eine sinnvolle Einstellung ist, spielen eine bedeutende Rolle.<\/p>\n<p>Die Entwicklung der Programmiersprachen zeigt jedoch, dass sich unsere Pr\u00e4ferenzen und Anforderungen im Lauf der Zeit ver\u00e4ndern. Wesentlich ist, dass jede neue Sprachgeneration neue Paradigmen einf\u00fchrt, die Entwickler*innen und Unternehmen entscheidende Vorteile verschaffen: (Null-)Sicherheit, kompakte und leichtgewichtige Syntax, Funktionen als vollwertiger Teil der Sprache, umfangreiche Standardbibliothek, asynchrone Nebenl\u00e4ufigkeit, Multiplattform-Unterst\u00fctzung, Eignung f\u00fcr KI-Generierung usw.<\/p>\n<p>Ohne diese nat\u00fcrliche Entwicklung w\u00fcrden wir heute noch alles in COBOL oder in irgendeiner anderen archaischen Sprache programmieren und w\u00e4ren au\u00dferstande, den Anforderungen der heutigen Zeit gerecht zu werden. Die Weiterentwicklung ist daher nicht optional, sondern geh\u00f6rt untrennbar zur Geschichte unserer Branche dazu.<\/p>\n<p>Damit sich diese Entwicklung jedoch innerhalb eines Unternehmens durchsetzen kann, ist mehr als nur technischer Nutzen vonn\u00f6ten. Es sind Wegbereiter erforderlich \u2013 Personen, die bereit sind, diese neuen Paradigmen zu entdecken, zu f\u00f6rdern und ihren Wert in der Praxis aufzuzeigen. Meiner Erfahrung nach sind es in der Regel drei Arten von Entwickler*innen, die als Katalysatoren zur Einf\u00fchrung von Kotlin beitragen:<\/p>\n<ol>\n<li><strong>Pragmatische, produktivit\u00e4tsorientierte Java-Entwickler*innen<\/strong>: Erfahrene Entwickler*innen, f\u00fcr die Java ein Werkzeug ist und keine Religion. Sie sind stets auf der Suche nach besseren M\u00f6glichkeiten, um die jeweilige Aufgabe schneller zu erledigen.<\/li>\n<li><strong>Qualit\u00e4tsbewusste Fans moderner Sprachen<\/strong>: Entwickler*innen, die Wert auf lesbaren, kompakten und wartungsfreundlichen Code legen. Dies sind oft dieselben Personen, die in der Vergangenheit zu Scala tendierten.<\/li>\n<li><strong>Junior-Entwickler*innen<\/strong>: Nachwuchskr\u00e4fte, die eine einfache, aber explosive Frage stellen: \u201eWarum sollte ich Java verwenden, wenn ich auch Kotlin nutzen kann?\u201c Ohne die langj\u00e4hrige Routine mit Java ist die Entscheidung pro Kotlin f\u00fcr sie oft eine einfache Sache.<\/li>\n<\/ol>\n<p>Welcher Gruppe geh\u00f6ren Sie an?<\/p>\n<p>Diese fr\u00fchen Anwender*innen entfachen den Funken f\u00fcr die erste Phase. Aber wo sollten Sie beginnen? Lesen Sie weiter\u00a0\u2026 ;-)<\/p>\n<h2 class=\"wp-block-heading\"><strong>Die Experimentierphase: Bescheiden anfangen \u2013 mit Tests<\/strong><\/h2>\n<p>Sie haben also von Kotlin geh\u00f6rt und m\u00f6chten es ausprobieren, ohne sich sofort festzulegen.<\/p>\n<p>Das erste, was Sie ben\u00f6tigen, ist ein Entwicklungstool, in dem Sie Ihre ersten Kotlin-Samen s\u00e4en k\u00f6nnen. Hier sind einige Optionen:<\/p>\n<ul>\n<li><a href=\"https:\/\/play.kotlinlang.org\/\" target=\"_blank\" rel=\"noreferrer noopener\">https:\/\/play.kotlinlang.org\/<\/a> ist ein hervorragender Online-Playground, in dem Sie Kotlin-Code nicht nur f\u00fcr die JVM, sondern auch f\u00fcr verschiedene andere Plattformen (JS, WASM usw.) schreiben und ausf\u00fchren k\u00f6nnen.<img decoding=\"async\" loading=\"lazy\" class=\"wp-image-647084\" style=\"width: 650px;\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/unnamed-13.png\" alt=\"Kotlin-Sandkasten\" width=\"1462\" height=\"660\" \/><\/li>\n<\/ul>\n<ul>\n<li><a href=\"https:\/\/kotlinlang.org\/docs\/kotlin-notebook-overview.html\" target=\"_blank\" rel=\"noreferrer noopener\">Kotlin Notebook<\/a> ist eine leistungsstarke Funktion f\u00fcr IntelliJ IDEA, mit der Sie unkompliziert Abh\u00e4ngigkeiten importieren, Code ausf\u00fchren und sogar mit Daten arbeiten oder Graphen zeichnen k\u00f6nnen. Hier ist ein Beispiel, das zeigt, wie einfach Sie mit dem RestClient von Spring einen REST-Aufruf t\u00e4tigen k\u00f6nnen:<img decoding=\"async\" loading=\"lazy\" class=\"wp-image-647095\" style=\"width: 650px;\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/unnamed-11.png\" alt=\"Kotlin Notebook\" width=\"1600\" height=\"1035\" \/><\/li>\n<\/ul>\n<ul>\n<li>IntelliJ IDEA bietet erstklassige Unterst\u00fctzung f\u00fcr Kotlin. Dies ist wenig \u00fcberraschend, da JetBrains der Entwickler von Kotlin ist und ein gro\u00dfer Teil von IntelliJ IDEA in dieser Sprache geschrieben ist. Die Verwendung von Kotlin in <a href=\"https:\/\/www.jetbrains.com\/help\/idea\/get-started-with-kotlin.html#add-kotlin-dependency\" target=\"_blank\" rel=\"noreferrer noopener\">IntelliJ IDEA<\/a> \u2013 sogar in einem bestehenden Java-Projekt \u2013 ist daher sehr einfach:\n<ul>\n<li>F\u00fcr <a href=\"https:\/\/kotlinlang.org\/docs\/maven.html\" target=\"_blank\" rel=\"noreferrer noopener\">Maven<\/a> konfigurieren Sie einfach <code>kotlin-maven-plugin<\/code> und die Kotlin-Standardbibliothek <code>kotlin-stdlib<\/code>.<\/li>\n<li>F\u00fcr <a href=\"https:\/\/kotlinlang.org\/docs\/gradle-configure-project.html\" target=\"_blank\" rel=\"noreferrer noopener\">Gradle<\/a> konfigurieren Sie das Kotlin-Plugin.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p>Und schon kann es losgehen!<\/p>\n<figure class=\"wp-block-image size-full is-resized\"><img decoding=\"async\" loading=\"lazy\" class=\"wp-image-647106\" style=\"aspect-ratio: 1.1216216216216217; width: 320px; height: auto;\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/unnamed-14.png\" alt=\"\" width=\"498\" height=\"444\" \/><\/figure>\n<ul>\n<li>Das ist noch nicht alles! JetBrains hat vor Kurzem den Kotlin Language Server ver\u00f6ffentlicht, der eine vollwertige Kotlin-Entwicklungserfahrung in anderen IDEs als IntelliJ IDEA erm\u00f6glicht \u2013 beispielsweise VS Code. Probieren Sie es aus: <a href=\"https:\/\/github.com\/Kotlin\/kotlin-lsp\" target=\"_blank\" rel=\"noreferrer noopener\">https:\/\/github.com\/Kotlin\/kotlin-lsp<\/a><\/li>\n<\/ul>\n<p>Jetzt k\u00f6nnen Sie in Ihrer bevorzugten Entwicklungsumgebung mit Kotlin programmieren. Wie k\u00f6nnen Sie nun die Sprache in einem realen Kontext mit minimalem St\u00f6rpotenzial und maximalem Erkenntnisgewinn ausprobieren? In der Testsuite eines bestehenden Java-Projekts!<\/p>\n<p>Dieser sichere und realistische Ansatz zum Experimentieren mit Kotlin bietet mehrere Vorteile:<\/p>\n<ul>\n<li><strong>Wenig Risiko<\/strong>: Tests beeintr\u00e4chtigen Ihren Produktionscode nicht.<\/li>\n<li><strong>Lernchance<\/strong>: Sie k\u00f6nnen die Merkmale der Sprache in einem vertrauten Kontext erkunden.<\/li>\n<li><strong>Schrittweise Einf\u00fchrung<\/strong>: Teammitglieder k\u00f6nnen sich ohne Druck mit der Kotlin-Syntax vertraut machen.<\/li>\n<\/ul>\n<h3 class=\"wp-block-heading\"><strong>Tipps<\/strong><\/h3>\n<ol>\n<li>Probieren Sie Kotest + MockK aus: So k\u00f6nnen Sie die Ausdruckskraft der Test-DSLs von Kotlin (DSL = Domain-Specific Language, also dom\u00e4nenspezifische Sprache) unmittelbar erleben, beispielsweise die umfassenden Assertions (<code>shouldHaveSize(...)<\/code>, Infix-Syntax (<code>value shouldBe 1<\/code>) usw.<\/li>\n<li>Verwenden Sie die kompakten und leistungsstarken Kotlin-Collections anstelle der Java-Streams.<\/li>\n<li>Experimentieren Sie mit den verschiedenen Sprachmerkmalen wie nullf\u00e4hige Typen, Destrukturierung, Unver\u00e4nderlichkeit (<code>val<\/code>, <code>data class<\/code>), Ausdruckskonstrukte (<code>when<\/code>, <code>try-catch<\/code>, <code>if-else<\/code>) und so weiter.<\/li>\n<\/ol>\n<p>Das Ergebnis:<\/p>\n<p><strong>Java<\/strong><\/p>\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"java\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">@Test\nvoid shouldGetAverageRating() {\n   when(productRepository.findAll()).thenReturn(products);\n\n   Map ratings = productService.averageRatings();\n\n   assertAll(\n           () -&gt; assertThat(ratings).hasSize(4),\n           () -&gt; assertEquals(ratings, products\n                   .stream()\n                   .collect(Collectors.groupingBy(\n                           Product::getName,\n                           Collectors.flatMapping(\n                                   p -&gt; p.getRatings()\n                                    .stream()\n                                    .mapToDouble(Integer::doubleValue)\n                                    .boxed(),   \n                              Collectors.averagingDouble(Double::doubleValue)\n                           )))\n           )\n   );\n   verify(productRepository).findAll();\n\n}\n<\/pre>\n<p><strong>Kotlin<\/strong><\/p>\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"kotlin\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">@Test\nfun `should get average rating`() { \/\/descriptive tests using ``\n   every { productRepository.findAll() } returns products\n\n   val ratings = productService.averageRatings()\n\n   assertSoftly(ratings) { \t\t\/\/powerful testing DSLs (Kotest)\n       shouldHaveSize(4)\n       this shouldBe productRepository.findAll()\n           .groupBy { it.name }   \t\t\t\/\/concise collections\n           .mapValues { (_, products) -&gt; \t\t\/\/destructuring\n                  products.flatMap { it.ratings }.average() }\n   }\n    verify { productRepository.findAll() }\n}<\/pre>\n<h3 class=\"wp-block-heading\">Im n\u00e4chsten Teil der Reihe<\/h3>\n<p>Der Wechsel zu Kotlin beginnt in der Regel damit, dass eine einzelne Person ein bisschen damit experimentiert und einige Tests sich als n\u00fctzlich erweisen. Diese ersten Momente der Entdeckung f\u00fchren naturgem\u00e4\u00df zu etwas Gr\u00f6\u00dferem: der Evaluierung von Kotlin in einem realen Projekt.<\/p>\n<p>Der n\u00e4chste Beitrag dieser Reihe geht auf diese Phase ein und zeigt, wie Kotlin in Produktionsumgebungen getestet werden kann.<\/p>\n<div class=\"about-author \">\n<div class=\"about-author__box\">\n<div class=\"row\">\n<div class=\"about-author__box-img\"><img decoding=\"async\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2025\/10\/a3f7-400o400o1-QYUavRYyARnAVJLCpM1m8M.webp\" alt=\"\" \/><\/div>\n<div class=\"about-author__box-text\">\n<h4>Urs Peter<\/h4>\n<p>Urs ist erfahrener Softwareentwickler, L\u00f6sungsarchitekt, Vortragsredner und Dozent mit \u00fcber 20 Jahren Erfahrung in der Entwicklung robuster, skalierbarer und unternehmenskritischer Systeme, haupts\u00e4chlich in Kotlin und Scala.<\/p>\n<p>Neben seiner T\u00e4tigkeit als Berater ist er leidenschaftlicher Dozent und Autor einer gro\u00dfen Vielfalt von Kursen, die von Spracheinf\u00fchrungen f\u00fcr Kotlin und Scala bis hin zu Architekturschulungen f\u00fcr Microservices und ereignisgesteuerte Architekturen reichen.<\/p>\n<p>Als kontaktfreudiger Mensch ist er gerne auf Treffen und Konferenzen, um sein Wissen zu teilen, andere zu inspirieren und selbst inspiriert zu werden. Urs ist JetBrains-zertifizierter Kotlin Trainer.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<p><strong>Autorin des urspr\u00fcnglichen Blogposts<\/strong><\/p>\n\n    <div class=\"about-author \">\n        <div class=\"about-author__box\">\n            <div class=\"row\">\n                <div class=\"about-author__box-img\">\n                    <img decoding=\"async\" src=\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2021\/08\/photo_2021-08-03_15-27-43-200x200.jpg\" width=\"200\" height=\"200\" alt=\"Alyona Chernyaeva\" loading=\"lazy\"  class=\"avatar avatar-200 wp-user-avatar wp-user-avatar-200 photo avatar-default\">\n                <\/div>\n                <div class=\"about-author__box-text\">\n                                            <h4>Alyona Chernyaeva<\/h4>\n                                                        <\/div>\n            <\/div>\n        <\/div>\n    <\/div>\n","protected":false},"author":964,"featured_media":671994,"comment_status":"closed","ping_status":"closed","template":"","categories":[],"tags":[],"cross-post-tag":[],"acf":[],"_links":{"self":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin\/671982"}],"collection":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin"}],"about":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/types\/kotlin"}],"author":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/users\/964"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/comments?post=671982"}],"version-history":[{"count":2,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin\/671982\/revisions"}],"predecessor-version":[{"id":672017,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/kotlin\/671982\/revisions\/672017"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/media\/671994"}],"wp:attachment":[{"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/media?parent=671982"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/categories?post=671982"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/tags?post=671982"},{"taxonomy":"cross-post-tag","embeddable":true,"href":"https:\/\/blog.jetbrains.com\/de\/wp-json\/wp\/v2\/cross-post-tag?post=671982"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}