Java is een veelgebruikte objectgeoriënteerde programmeertaal en softwareplatform. Het werkt op miljarden apparaten, waaronder notebooks, mobiele apparaten, gameconsoles en vele andere.

Het hebben van dergelijke mogelijkheden heeft een prijs. Java kan moeilijk te leren zijn, met een lange gecompliceerde syntaxis. Het is statisch getypt, wat minder handig kan zijn. En hoewel het platformonafhankelijk is, maakt de opkomst van het cloud computing-platform onafhankelijkheid minder een overwinning.

Dit zijn slechts enkele van de redenen waarom Java uit de gratie raakt.

1. Java wordt steeds minder populair

Eerst en vooral lijkt Java langzaam aan populariteit af te nemen. Jarenlang was dat zo een van de beste programmeertalen om te leren, maar het is nu niet langer trending. Dit betekent dat ontwikkelaars in de loop van de tijd steeds minder nieuwe applicaties in Java zullen schrijven.

Deze trend houdt in dat Java uiteindelijk zal verdwijnen. Bedrijven over de hele wereld zullen Java-programmeurs blijven inhuren om verouderde codebases te onderhouden, maar dat zal niet eeuwig duren.

instagram viewer

Maar als je je carrière wilt richten op het bouwen van nieuwe dingen in plaats van het onderhouden van bestaande programma's, is Java misschien niet de beste keuze voor jou.

Programmeertaal mei 2022
Python 1
C 2
Javascript 3
C++ 4
C# 5
Visuele basis 6
Java 7
Assemblage taal 8
SQL 9
PHP 10

2. Java is niet eenvoudig

Java mag dan gemakkelijk te leren zijn, het is niet eenvoudig. De taal is gemakkelijk te leren omdat Java-code eenvoudig te schrijven, organiseren en compileren is. Maar het is niet eenvoudig, omdat code geschreven in Java vaak uitgebreider en vervelender is om te schrijven.

Je moet het ook compileren, wat Java veel minder handig maakt dan talen als Python. Dus als je een beginner bent die voor het eerst leert coderen, is Java geen goede taal om mee te beginnen.

Als u een professional bent die eenvoudige, elegante code wil maken en deze snel wil implementeren, is Java ook niet de ideale keuze.

3. Getters en Setters

Getters en setters zijn bijna een verplicht onderdeel van het gebruik van een taal en veel kaders moedigen het gebruik ervan aan. De getters en setters van Java kunnen echter onnodig uitgebreid zijn.

Het beheren van code die is versierd met Java-getters en -setters is een hel en ingewikkeld. Het ontbreken van een zinvolle oplossing voor het probleem van getters en setters is slechts het topje van de ijsberg.

openbaarklasVoertuig{
 privaat Snaar kleur;
// Getter
openbaar Snaar kleur krijgen(){
opbrengst kleur;
 }
// Zetter
openbaarleegtesetKleur(Tekenreeks c){
dit.kleur = c;
 }
}

4. Geen syntactische ijsvorming

Je werkt aan een collectie. U wilt het eerste item. Wat ben je aan het doen? Natuurlijk roep je de methode aan in plaats van de common te gebruiken [] exploitant. Allemaal omdat je operators niet kunt overbelasten.

Voor vrijwel elke bewerking moet u een veelomvattende methodenaam gebruiken, zelfs als een operator met één teken voldoende zou zijn.

Java ondersteunt het concept; de taal laat je strings samenvoegen met de + exploitant bijvoorbeeld. Het laat jou, de programmeur, gewoon niet hetzelfde doen.

5. De uitzonderingen aangeven die een methode kan veroorzaken

Java vereist dat u de uitzonderingen declareert die een methode kan genereren. Het lijkt nuttig, nietwaar? Door een bepaalde methode te gebruiken, weet u wat u kunt verwachten.

Het probleem is dat de code een levend organisme is, en het gebeurt dat de methode die je gebruikt meer uitzonderingen begint te genereren. Wat zal er dan gebeuren? Nou, je code is net gestopt met compileren.

U moet de situatie afhandelen of een uitzondering toevoegen aan de lijst met worpen. Laten we aannemen dat de API die u gebruikt niet verandert. Er bestaat zoiets als RuntimeException in Java. Als uw methode deze uitzondering of een van zijn afstammelingen kan genereren, moet u deze declareren.

De uitzonderingen van Java kunnen veel code-onderhoudsproblemen met zich meebrengen.

// Java-programma dat het gebruik van throw demonstreert
klasGooiExcep
{
statischleegte plezier()
 {
poging
 {
gooiennieuw NullPointerException ("demo");
 }
vangst (NullPointerException e)
 {
 Systeem.uit.println("Gevangen in plezier().");
gooien e; // de uitzondering opnieuw genereren
 }
 }
openbaar statischleegte voornaamst(Snaar argumenten[])
 {
poging
 {
 plezier();
 }
vangst (NullPointerException e)
 {
 Systeem.uit.println("Hoofdzakelijk gevangen.");
 }
 }
}

6. Gecompliceerde IDE's

Java-programmeurs gebruiken vaak een IDE zoals Eclipse of IntelliJ. Deze IDE's zijn krachtig, maar ze zijn complex om mee te communiceren, vooral voor een beginner of een halfgevorderde ontwikkelaar. U zult veel moeite moeten doen om uw IDE van binnen en van buiten te leren, zodat deze productiever en minder pijnlijk voor u is.

7. Platformonafhankelijkheid is minder belangrijk in 2022

Het feit dat Java erg platformonafhankelijk is, doet er tegenwoordig misschien minder toe dan 10 of 20 jaar geleden.

De reden hiervoor is dat we in een door software gedefinieerde wereld leven. Tegenwoordig maken virtuele machines, containers en cloudservices het gemakkelijk om een ​​applicatie uit te voeren waar je maar wilt, zonder je zorgen te hoeven maken over de onderliggende omgeving.

Met andere woorden, u hoeft uw code niet te wijzigen om uw app te laten werken waar u hem nodig heeft. U kunt in plaats daarvan de hostingomgeving wijzigen.

Dit wil niet zeggen dat de overdraagbaarheid van applicaties er niet meer toe doet. Het is gewoon niet zo kritisch als vroeger, en dat maakt Java bij uitbreiding een beetje minder belangrijk.

8. Statisch typen

Java voert typecontrole uit tijdens het compileren. Dit betekent dat u tijdens het compileren het type van elke variabele moet declareren. Hetzelfde geldt voor talen als C en C++, maar andere talen, zoals Scala en Haskell, bieden een vorm van type-inferentie.

Bij statisch typen mogen variabelen over het algemeen niet van type veranderen. Dit maakt de Java-syntaxis een beetje ingewikkeld, vooral bij het schrijven van code voor een groot project.

Veel programmeurs geven de voorkeur dynamisch programmeren waar typecontrole plaatsvindt tijdens runtime. Dit betekent dat het type van een variabele gedurende zijn levensduur kan veranderen.

Leer nieuwe programmeertalen

Het is niet zo dat Java nergens goed voor is, maar de syntaxis is onhandig en niet bevorderlijk voor het lezen van code. Het afhankelijkheidsbeheer van Java maakt misbruik mogelijk en leidt tot moeilijk te detecteren bugs.

Technologie blijft veranderen en als ontwikkelaar is het altijd handig om up-to-date te zijn met opkomende programmeertalen. Wat vandaag in de mode is, kan binnenkort het nieuws van gisteren zijn.