**Java** programazio-lengoaia bat da. James Gosling-ek diseinatu zuen, Sun Microsystems enpresan ziharduela, 1990eko hamarkadan. "*Write once, run anywhere*" filosofiari jarraitu zion; kodea plataforma desberdinetan exekutatu ahal izatea lortu nahi zen, behin eta berriz konpilatu beharrik izan gabe. Sintaxi aldetik C eta C++ programazio-lengoaien antza du. Objektuei orientatutako lengoaia bat da.

Aplikazio eta webgune askok ez dute funtzionatzen Java instalatuta eduki ezean. Java azkarra, segurua eta fidagarria da eta nonahi dago: konputagailu eramangarrietan, datu-zentroetan, jokoetarako kontsoletan, superkonputagailuetan, telefono mugikorretan, Interneten, etab. 2012az geroztik, programazio-lengoaia erabilienen artean dago, batez ere web bezero eta zerbitzarien aplikazioetarako.

Hasierako Java-konpiladoreak, makina birtualak eta liburutegiak Sun Microsystems enpresak garatu zituen software jabedun moduan. Gerora, ordea, Java teknologia gehienen lizentzia-motak aldatu eta GNU Lizentzia Publiko Orokor moduan jarri ziren. Badira teknologia horien ordezko diren beste inplementazio batzuk ere, Javarako GNU konpiladorea edo GNU Classpath, adibidez.

Javak eta JavaScriptek ez dute haien artean zerikusi zuzenekorik, nahiz eta biek C-ren antzeko sintaxia erabili.

Historia
--------

Telebista interaktiboa lortzea helburu zuen proiektu baten barruan sortu zen Java Sun Microsystems enpresan. *The Green Project* izeneko proiektua hamahiru lagunek osatutako taldeak garatu zuen James Gosling-en zuzendaritzapean. C++ programazio-lengoaiaren antzeko egitura eta sintaxia zituen lengoaia eta makina birtuala inplementatu nahi zituzten. 1994an proiektuan lanean ari zirela, eta sortu berri zen Mosaic web-nabigatzaileak Interneta interaktibo bihurtuko zuela sinetsita, proiektua Web-era bideratzea erabaki eta web-nabigatzaile prototipo bat sortu zuten: WebRunner, beranduago HotJava izenez ezagutuko zena. 1995ean Java programazio-lengoaia eta HotJava web-nabigatzailea argitaratu ziren. Netscape enpresaren sortzaile Marc Andreessen-ek haien Netscape nabigatzaileak Java jasango zuela iragarri zuen.

Programazio-lengoaiak hasieran *Oak* izena hartu zuen, Goslingen bulegoaren kanpoaldean zegoen haritzagatik. Marka komertzial hori dagoeneko erregistratuta zegoela ikusi zenean, lengoaiak *Green* izena hartu zuen, baina azkenean *Java* izenez izendatu zuten. Egia esan, ez dago argi *Java* izenaren jatorria zein den. Iturri batzuek diotenez, lengoaia diseinatu zutenen izenetatik eratorritako akronimo bat da: ***J**ames Gosling, **A**rthur **V**an Hoff, eta **A**ndy Bechtolsheim*, baina badira akronimoak beste jatorri bat duela diotenak ere: ***J**ust **A**nother **V**ague **A**cronym*. Beste hipotesi batek dio, gertuko kafetegian ematen zuten Java uharteko kafeagatik aukeratu zutela izena. Horrek azalduko luke lengoaiaren logoa kafe kikara bat izatea eta konpilatzaileak sortzen dituen .class fitxategien hasiera 0xCAFEBABE izatea, idazkera hamaseitarrean. Hala ere, izena hitzen ausazko zerrenda batetik atera zutela dioten teoriak ere badira.

Lengoaia plataformaren independentea izatea zen helburua, "*Write once, run anywhere*", behin Java aplikazio bat sortu ondoren, hedapen handieneko plataformetan arazorik gabe exekutatu ahal izateko, exekuziorako *Java virtual machine (JVM)* doako ingurune arinaren bidez. Exekuzio ingurunea nahiko segurua zen, eta web-nabigatzaile nagusiek laster gehitu zuten zuten web-orrietan txertatutako Java applet edo aplikazio txikiak exekutatzeko aukera.

Sortu zenetik, Javak aldaketa ugari jaso ditu. Hona hemen bertsio egonkorrenen zerrenda, hasieran Java Development Kit (JDK) moduan izendatua, eta gerora Java Standard Edition (JSE) laburduraz emana:

* JDK 1.0 (1996ko urtarrila)
* JDK 1.1 (1996ko otsaila)
* J2SE 1.2 (1998ko abendua)
* J2SE 1.3 (2000ko maiatza)
* J2SE 1.4 (2002ko otsaila)
* J2SE 5.0 (2004ko iraila)
* Java SE 6 (2006ko abendua)
* Java SE 7 (2011ko uztaila)
* Java SE 8 (2014ko martxoa)
* Java SE 9 (2017ko iraila)
* Java SE 10 (2018ko martxoa)
* Java SE 11 (2018ko iraila)
* Java SE 12 (2019ko martxoa)
* Java SE 13 (2019ko iraila)

Lengoaiaren bilakaera Java Community Process (JCP) taldeak arautzen du eta Java Specification Requests (JSRs) dokumentuan zehazten dira proposatu nahi diren aldaketak.

Filosofia
---------

Java programazio-lengoaia bost helburu nagusirekin sortu zen:

1. Objektuetara orientatutako programazioaren paradigma erabili beharko luke.
2. Programa bera plataforma desberdinetan exekutatzeko aukera eman beharko luke.
3. Sareko lanerako euskarria eskaini beharko luke.
4. Urruneko sistemetan kodea modu seguruan exekutatzeko diseinatu beharko litzateke.
5. Erabilerraza izan beharko luke, eta objektuetara orientatutako beste lengoaietatik, C++ adibidez, onena jaso beharko luke.

Duten garrantziagatik, objektuetara bideratua izatea eta plataformaren independentzia (1. eta 2. ezaugarriak) sakonago azaltzen dira behean. Sareko lanerako euskarria eta urruneko kodearen exekuzioa lortzeko (3. eta 4. helburuak), Javako programatzaileek batzuetan, CORBA (Common Object Request Broker Architecture), Internet Communications Engine edo OSGi moduko hedapenak erabiltzen dituzte.

### Objektuetara bideratua

Programazio-lengoaia bat objektuetara bideratua dagoela esaten denean, programazio-metodoari eta lengoaiaren diseinuari egiten zaio erreferentzia. Horrek funtsean esan nahi duena da, datu-mota bakoitza harekin eragiteko definitu diren eragileekin lotu dela diseinu fasean; datuak eta kodea (funtzioak edo metodoak) batera datoz objektuetan. Horrela, objektua "egoera" (datuak) eta "portaera" (kodea) gordetzen dituen paketea dela esan daiteke. Aldatzen dena aldatzen ez denetik bereiztea da ideia. Izan ere, datu-egitura bat aldatzeak datu-mota horrekin lan egiten duen kodea aldatzea dakar, gehienetan. Banaketa horrek software-sistema bat diseinatzeko oinarri egonkorragoa eskaintzen du. Proiektu handiak garatzean, kudeatzen errazak izatea lortu nahi da, haien kalitatea hobetuz.

Objektuetara orientatutako programazioaren beste helburu bat *objektu* entitate generikoen sorrerarekin software-proiektuen artean softwarea berrerabili ahal izatea da; Izan ere, software-ingeniaritzaren funtsezko premisetako bat da hori. Objektu generiko batek portaera-multzo bera izan beharko luke hainbat proiektutan, batez ere proiektu horiek neurri batean bat datozenean, erakunde handietan gertatzen den bezala. Alde horretatik, objektuak berriz erabiltzeko moduko pieza gisa ikus daitezke, hainbat proiektutan erabil daitezkeenak. Horrela, softwarearen industriak tamaina handiko proiektuak eraiki ahal izango ditu, lehendik sortuak dauden eta kalitate onekoak diren osagaiak erabiliz, garapen-denbora izugarri murriztuz.

Adibide bat jartzearren, demagun objektua "Aluminioa" dela. Datuak (dentsitatea, xaflakortasuna, etab.) eta bere "portaera" (bi pieza soldatu, etab.) definitu ondoren, "Aluminio" objektua berrerabil daiteke eraikuntzaren hainbat esparrutan: automobilen eraikuntzan, hegazkingintzan etab. Hala ere, softwarearen berrerabilpenaren ideiak bi zailtasun nagusi aurkitu izan ditu: benetan generiko diren objektuen diseinua ez da ondo ulertua izan, eta berrerabilpenerako aukeren komunikaziorako metodologia falta da. Badira arazo horri aurre egiteko laguntza eskaintzen duten komunitateak.

### Plataformaren independentea

Java programazio-lengoaia plataformaren independentea dela esaten denean, Java lengoaian idatzitako programak edozein hardwaretan exekuta daitezkeela esan nahi du, Javaren "*Write once, run anywhere*" axiomak dioenari jarraituz. Java-n idatzitako iturburu-kodea konpilatu ondoren, Java bytecode izeneko kode eramangarria sortzen da. Jatorrizko iturburu-kodearen eta konputagailuak ulertzen duen makina-kodearen artean dagoen kode hori *Java virtual machine (JVM)* makina birtualean exekutatzen da. Kontuan izan behar da, nahiz eta konpilazio-fase jakin bat egon, sortutako kode eramangarria Just In Time (JIT) konpiladoreak exekuzio-fasean interpretatu eta bihurtzen duela makina-kode. Dispositibo bakoitzaren ezaugarrietara iristeko, liburutegi gehigarriak ere eskaintzen dira.

Kodearen eramangarritasuna lortzeko, hasierako inplementazioek makina birtual interpretatu bat erabiltzen zuten. Baina horrela exekutatutako programak C edo C++ lengoaietan idatzitako programak baino motelagoak ziren. Horrela irabazi zuen Javak errendimendu moteleko lengoaia izatearen ospea. JVMren azken inplementazioekin aurrekoekin baino askoz azkarrago exekutatzen dira programak, nahiz eta oraindik ere beste lengoaia batzuk baino motelagoak izaten jarraitzen duten.

Eramangarritasuna lortzea teknikoki zaila da eta Javak neurri batean eramangarri izatea lortu badu ere, haren arrakasta ez da erabatekoa izan. Egia da posible dela arkitektura desberdineko plataformetan ondo exekutatzen diren Java programak idaztea, baina erroreak izaten dira. Horrek eraginda, Sun Microsystems-en "*Write once, run anywhere*" eslogana ("*idatzi behin, exekutatu edonon*") beste "*Write once, debug everywhere"* ("*idatzi behin, zuzendu leku guztietan*") esloganarekin parodiatu izan da.

Esan beharra dago, Javaren eramangarritasunak arrakasta handia izan duela web-zerbitzarien aplikazioetan, txertatutako Java inguruneak erabiliz: Web zerbitzuetan, zerbitzarien ahalmenak hedatzen dituzten servlets-etan, JavaBeans-etan, *Open Services Gateway initiative (*OSGi)-etan oinarritutako sistema txertatuetan, etab.

Aplikaziorako esparruak
-----------------------

Informatikaren industriaren hainbat esparrutan Java izan da hazkuntza handienetakoa eta erabilera zabalenetakoa lortu dituen programazio-lengoaia, haren diseinuari, eskaintzen duen sendotasunari eta lortu duen eramangarritasun mailari esker. Honakoetan aurkitzen da, batez ere:

* Gailu mugikorretan eta sistema txertatuetan. Java Micro Edition (Java ME) plataforma bereziki diseinatuta dago baliabide mugatuak dituzten dispositiboetarako, eta horri esker Java erraz aurki daiteke PDA (*Personal Digital Assistant*) edo laguntzaile digital pertsonaletan, telefono mugikorretan, etxetresna elektrikoetan, etab.
* Web-nabigatzaileetan. Javaz idatzitako aplikazio txikiak (*applet*-ak) web-orrietan erraz txerta daitezke. Web-nabigatzaileek *Java virtual machine (JVM)* makina birtuala plugin edo hedapen moduan konfiguratuta izaten dute eta bertan exekutatzen dira. Exekuzio aldetik motelak izateagatik, denboratekin web-orrietarako bestelako teknologiak garatu izan dira: ActiveX, Java Web Start, etab
* Zerbitzari-sistemetan. Java *servlet* espezifikazioa eta *Java Server Pages* (JSP) sortu zirenetik, sekulako arrakasta lortu du zerbitzari-sistemetan. Zerbitzariaren ahalmenak handitzeko klaseak dira *servlet*-ak, normalean web-zerbitzarietan ostatu duten aplikazioak hedatzeeko erabiltzen direnak; web-zerbitzarietan exekutatzen diren Java *applet* modukoak dira. *JavaServer Pages* (JSP)-ak web-orri dinamikoak garatzeko teknologia bat dira, PHP-ren modukoa, baina Java pogramazio-lengoaia erabiltzen duena. *servlet-ak eta JSP-*ak funtsezkoak bihurtu dira zerbitzarietarako web-aplikazio dinamikoen garapenean.
* Mahaigaineko aplikazioetan: Oinarrian Java duten aplikazio grafiko ugari dago gaur egun, ordenadore pertsonaletan ohikoen diren sistema eragileetan erabiltzeko modukoak. Java-aplikazio askok paketean bertan txertatzen dute, aplikazioa konputagailu guztietan exekutatu dadin. Java programetarako GUI erabiltzaile-interfaze grafikoa ahalbidetzen duen Swing tresnari esker Javaz idatzitako mahaigaineko aplikazioak asko zabaldu ziren.

Ohikoenak diren plataforma guztietarako existitzen da JVM makina birtuala: Microsoft Windows, Apple Mac OS, GNU/Linux, etab. nahiz eta denek ez duten hura lehenetsita ekartzen.

Erlazionatutako industria
-------------------------

Sun Microsystems enpresak, Java programazio-lengoaiaren eta Java Development Kit (JDK) garapenerako ingurunearen sortzaile izanik, lengoaiaren eta makina birtualaren espezifikazio bat mantentzeko politika sendoa dauka. Ahalegin horri esker, Java *de facto* estandar bat da, Java Community Process (JCP) mekanismo formalak kontrolatua.

Javarako aplikazioak garatzen dituzten edota teknologia horrekin buru-belarri lanean ari diren konpainiak asko dira. Hona hemen batzuk:

* Telefonia mugikorraren industriak Java teknologiaren eragin handia jasotzen du.
* Netbeans eta Eclipse garapen-inguruneek arrakasta handia dute Java garatzaileen komunitatean.
* Apache fundazioak garrantzia handia du Javan oinarritutako liburutegi eta zerbitzarietarako osagaien garapenean.
* IBM eta Oracle enpresek, adibidez, Javan eta Javarako sortutako produktu asko eta interes handia dituzte.

Sintaxia
--------

Javaren sintaxia C++ lengoaiatik dator neurri handi batean. Hala ere, C++ ez bezala, Java hasieratik objektuetara orientatua izateko diseinatu zen. Javan dena da objektu bat (salbuespen batzuk izan ezik), eta dena dago klaseren batean (klasea objektuak sortzeko moldea da).

C++ek ez bezala, Javak ez du eragileen gainkargarik onartzen, hau da, ez da posible izen bereko eragile desberdinak definitzea eta klaseek ez dute herentzia anizkoitzik onartzen, hau da, ezin dituzte super-klase bat baino gehiagotatik portaerak edo ezaugarriak hartu

Ezaugarriak
-----------

### Datu-motak

Aldagaiei hasierako balio bat esleitu ohi zaie, horrela aldagaiari balioaren mota hori lotzen baitzaio.

Javak ondoko oinarrizko datu-motak ezagutzen ditu:

|  |  |
| --- | --- |
| **Datu mota** | **Klase bilgarria** |
| `byte` | `java.lang.Byte` |
| `char` | `java.lang.Character` |
| `short` | `java.lang.Short` |
| `int` | `java.lang.Integer` |
| `long` | `java.lang.Long` |
| `float` | `java.lang.Float` |
| `double` | `java.lang.Double` |
| `boolean` | `java.lang.Boolean` |
| `void` | `java.lang.Void` |

### Agindu-motak

Oinarrizko aginduak esleipena (datu\_mota *aldag\_izena* = *balioa*) eta datu-idazketak (*System.out.println*) dira.

***Adibidea:***

```
//Oinarrizko esleipenaren adibidea
int Adina = 24;
//Oinarrizko datu pantailaratzearen adibidea
System.out.println(Adina);

```

### Kontrol-egiturak

#### Baldintzapeko egiturak

*if* egiturak balio du agindu-multzo bat soilik kasu batzuetan egikaritzeko, baldintza bat betetzen denean, alegia. Kontrol-egitura hau programazio-lengoaia guztietan dago.Egituraren eredua hau da:

```
if (baldintza) {
 baldintza hori egia bada gauzatuko diren aginduak
} else {
 baldintza hori gezurra bada gauzatuko diren aginduak
}

```
***Adibidea*:**

```
if (i > 0) {
 System.out.println("i aldagaiaren balioa 0 baino handiagoa da");
} else {
 System.out.println("i aldagaiaren balioa ez da 0 baino handiagoa");
}

```
Baldintza espresio boolear baten bidez adierazten da. Baldintza betetzen bada, segidan duen agindu multzoa egikarituko da. Baldintza bete ezean, *else* adarra baldin badago adar horri dagokion agindu-multzoa egikarituko da. Ez badago *else* adarra, berriz, egitura honetan ez da ezer egingo. Hautazkoa da *else* adarra idaztea.

*if* egiturak konplexuagoak egin daitezke *else if* erabiliz:

```
if (baldintza 1) {
 baldintza 1 egia bada gauzatuko diren aginduak
} else if (baldintza 2) {
 baldintza 1 gezurra bada eta baldintza 2 egia bada gauzatuko diren aginduak 
} else {
 bi baldintzak gezurra badira gauzatuko diren aginduak
}

```
***Adibidea:***

```
if (i > 0) {
 System.out.println("i aldagaiaren balioa 0 baino handiagoa da");
} else if (i < 0) {
 System.out.println("i aldagaiaren balioa 0 baino txikiagoa da");
} else {
 System.out.println("i aldagaiaren balioa 0 da");
}

```

#### Iterazio-egitura

##### *while loop* kontrol-egitura

Egitura errepikakor orokorrena da while. Honela erabiltzen da:

```
while (baldintza) {
 agindua 1;
 agindua 2;
 ...
 agindua n;
 }

```
***Adibidea:***

```
int Karratua200BainoHandiagoa = 0;

while (Karratua200BainoHandiagoa \* Karratua200BainoHandiagoa < 200) {
 Karratua200BainoHandiagoa = Karratua200BainoHandiagoa + 1;
}

```

##### *do...while loop* kontrol-egitura

*while loop* kontrol-egituraren antzekoa da baina honetan baldintza agindua exekutatu ondoren ebaluatzen da:

```
do {
 agindua;
 } while (baldintza);

```

##### *for loop* kontrol-egitura

Egitura errepikakor honekin posible da zerrenda eta datu-egitura batzuetan (zerrendak, bektoreak edo matrizeak, batez ere) elementu bakoitzerako agindu batzuk errepikatzea. Honela idazten da:

```
for (baldintza) {
 agindua;
}

```
***Adibidea:***

```
for (int i = 0; i < 100; i++) {
 System.out.println(i + "\t" + i \* i);
}

```

##### *foreach loop* kontrol-egitura

*foreach* kontrol-egiturak multzo bateko elementu guztietatik banan-banan iteratzea ahalbidetzen du adierazitako datu-mota mantentzen den bitartean:

```
for (elementu\_mota elementua: multzoa) agindua;

```
***Adibidea:***

```
String[] egunak = {"Astelehena", "Asteartea", "Asteazkena", "Osteguna", "Ostirala", "Larunbata", "Igandea"};

for (String eguna : egunak) {
 System.out.println(eguna);
}

```

### Azpiprogramak, funtzioak

Funtzioek, agindu multzo bat exekutatu eta emaitza bat itzultzen dute. Oso erabilgarriak dira algoritmo zailak ebaztean, gure problema azpiproblema sinpleagotan banatzea eta azpiproblema bakoitza bere aldetik ebaztea ahalbidetzen dutelako. Emaitza, sarrera-parametroen araberakoa izan daiteke, eta honela eraikitzen da:

```
 emaitza\_mota funtzioaren\_izena (parametro\_mota parametro\_izena, ... ) {
 agindua 1;
 agindua 2;
 ...
 agindua n;
}

```

  

### Aplikazio autonomoak

Adibide honek azalpen txiki bat behar du.

* Javan dena klase baten barruan dago, programa autonomoak barne.
* Iturburu-kodea artxiboetan gordetzen da Artxibo horiek, barruan duten klasearen izen bera eta ".java" luzapena dute.
* Konpiladoreak klase-fitxategi bat sortzen du ("*.class*" luzapenarekin) iturri-fitxategian definitutako klase bakoitzeko.
* Modu independente eta autonomoan gauzatzen diren programek `"main()"` metodoa izan behar dute.
* `"void"` hitz erreserbatuak, main metodoak ez duela ezer itzultzen adierazten du .
* Main metodoak, String motako objektuen array bat onartu behar du. Adostasunez, `"args"` gisa aipatzen da, baina beste edozein identifikatzaile erabil daiteke.
* `"static"` hitz erreserbatuak, metodoa klase-metodo bat dela adierazten du, klaseari lotua, haren instantzia bati lotua egon beharrean. Main metodoa, estatikoa edo "klasekoa" izan behar da.
* `**public**` hitz erreserbatuak, metodo bat beste klase batzuetatik deitua izan daitekeela esan nahi du, edo klasea, klase horren hierarkiatik kanpoko beste klase batzuek erabil dezaketeela. Beste sarbide mota batzuk `"private"` edo `"protected"` dira.
* Inprimatzeko baliagarritasuna (pantailan, adibidez) Javaren liburutegi estandarraren parte da: ''System'' klaseak ''out'' izeneko eremu publiko estatikoa definitzen du. Out objektua ''PrintStream'' ren instantzia bat da, pantailan datuak iraultzeko ''println (String) '' metodoa eskaintzen duena (irteera estandarra).
* Aplikazio autonomoak, Javaren exekuzio-inguruneari erabili beharreko klasearen izena emanez gauzatzen dira. Adibidez, `java –cp. Kaixo` formako komando lerro batek (Unixen edo Windowsen) adibideko programa exekutatuko du (aldez aurretik konpilatuta eta "Kaixo.class" sortuta).

  

Kaixo mundua -ren adibideak:

  

```
public class KaixoMundua {
 public static void main(String[] args) { 
 System.out.println("Kaixo, mundua!"); 
 } 
}

```

```
public class KaixoMundua {
 public static void main(String[] args) {
 System.out.print("Kaixo,");
 System.out.print(" mundua!");
 }
}

```

Java applet-ak
--------------

Java applet bat Java programazio-lengoaian idatzitako aplikazio txiki bat da, Java bytecode edo kode eramangarri moduan konpilatu dena eta erabiltzaileei banatzen zaiena. Normalean web-orrietan txertatuta egoten dira applet-ak eta erabiltzailearen *Java virtual machine* (JVM) makina birtualean exekutatzen dira, web-nabigatzailean baina aparteko prozesu baten moduan.

normalean, nabigatzaile batean to Java bytecode, and delivered to users in the form of Java bytecode. The user launched the Java applet from a web page, and the applet was then executed within a A Java applet could appear in a frame of the web page, a new application window, Sun's AppletViewer, or a stand-alone tool for testing applets.bat.

```
// Kaixo.java
import javax.swing.JApplet;
import java.awt.Graphics;

public class Kaixo extends JApplet {

 public void paint(Graphics g) {
 g.drawString("Kaixo, mundua!", 65, 95);
 }

}

```
  

```
 <!-- Kaixo.html -->
<html>
  <head>
    <title>Applet Kaixo Mundua.</title>
  </head>
  <body>
    <applet code="Kaixo.class" width="200" height="200">
    </applet>
  </body>
</html>
```
Gaur egun, HTML 5ek <applet> etiketaren erabilera ezabatu du. Hala ere, oraindik badago HTML5en erabiltzeko modua. (Ingelesezko testua) Java Applets in HTML5.

**`import`**sententziak, Javako konpilatzaileari **java.applet. Applet** eta **java.awt. Graphics** klaseak barne har ditzala adierazten dio, izenen arabera aipatu ahal izateko, iturburu-kodean erabili nahi diren bakoitzean ibilbide osoa lehenetsi behar izan gabe.

`**Kaixo**` klasea `Applet;` klasera hedatzen (`extends`) da , hau da, honen azpiklasea da. `Applet` klaseari esker, aplikazioak appletaren egoera erakutsi eta kontrolatu dezake. `Applet` klasea AWT (Abstract Window Toolkit) delakoaren osagaia da, eta appletak erabiltzaile-interfaze grafikoa edo GUI (Graphical User Interface) erakustea eta erabiltzaileak sortutako gertaerei erantzutea ahalbidetzen du.

`Kaixo` klasea **paint (Graphics)** metodoaz gainkargatzen da (`Applet` , kasu honetan), marrazteaz arduratzen den kodean sartzeko. `paint()` metodoak **`Graphics`** objetu bat jasotzen du, appleta marrazteko testuinguru grafikoa duena. **`paint()`** metodoak objektuaren drawString (String, int, int) metodoari deitzen dio.

Programazioa
------------

### Adierazpenak

Adierazpenak elementu edo token segida bat dira, literalekin ere bai, emaitza bat kalkulatzeko ebaluatu behar direnak. Tokenak programetako elementu txikienak dira, konpilatzailearentzat ulergarriak direnak. Javan tokenak bost kategoriatan banatzen dira:

*Identifikatzaileak*: Javaren kodean aldagai, mota, pakete, metodo eta konstanteei esleitutako izenei ematen zaizkien irudikapenak dira, konpiladoreak identifika ditzan eta programatzaileak uler ditzan. Javan, identifikatzaileek letra larriak edo xeheeak bereiz ditzakete, *case sensitive* delako; beraz, "Nirealdagaia" izena duen aldagaia ez da "nirealdagaia" ren berdina, Javak aldagai desberdin gisa identifikatzen baititu. Zenbakiak ere erabil daitezke, edo "\_" zeinua, identifikatzaile bat esleitzeko.

*Gako-hitzak*: Javak kodean eta konpiladorean helburu espezifiko bat betetzeko erreserbatutako identifikatzaileak dira, modu mugatuan eta kasu espezifikoetan erabiltzen direnak. Javak erabiltzen dituen hitz gakoak honako hauek dira:

|  |  |  |  |  |
| --- | --- | --- | --- | --- |
| abstract | boolean | break | byte | case |
| catch | char | class | continue | default |
| do | double | else | extends | false |
| final | finally | float | for | if |
| implements | import | instanceof | int | interface |
| long | native | new | null | package |
| private | protected | public | return | short |
| static | super | switch | syncronized | this |
| throw | throws | transient | true | try |
| void | volatile | while | var | **rest** |
| **byvalue** | **cast** | **const** | **future** | **generic** |
| **goto** | **inner** | **operator** | **outer** |  |

Letra lodiz dauden hitzak, gaur egungo Javaren bertsioan erabiltzen ez badira ere, hitz gakoak dira, hurrengo bertsioetan txertatu nahi direnak.

*Literalak eta konstanteak*: Literalak, aldagai bati balioak esleitzeko elementuak dira, hau da, aldagai batek har dezakeen balioa (zenbakizkoa izan daitekeen balio konstante bat ere bada). Konstanteak, balio finkoa duten aldagaiak dira, kodean zehar alda ezin daitezkeenak; *final* eta *static* aldatzaileen bidez deklaratzen dira.

```
final static double pi= 3.1416;

```
*Operadoreak*: Identifikatzaile edo konstante bati buruz objektu edo datu bati aplikatzen zaion ebaluazio bat adierazten digutenak dira. Operadoreen adibide batzuk batuketa, kenketa edo biderketa izan daitezke.

*Bereizgailuak*: Javako konpiladoreari kodeko elementuen kokapena adierazteko erabiltzen dira. Javak onartzen dituen bereizgailuak hauek dira: { },:;

Javako konpiladoreak iruzkinak ere identifikatzen eta ezabatzen ditu, baita espazio hutsak eta tabulaziokoak ere, eta, beraz, ez dira token baten zatitzat hartzen.

Adierazpenak aldagaien, operadoreen eta metodoen konbinazioa izan daitezke. Adierazpenak kalkuluak egiteko, aldagaiei balioak esleitzeko edo programaren fluxua kontrolatzeko erabiltzen dira.

### Operadoreak

Javaren adierazpenak dira, eragiketa bat egin ondoren emaitza bat itzultzen dutenak. Operadore batek maneiatzen duen operadore kopuruaren arabera, bi motatakoa izan daiteke: unarioa edo bitarra.

Operadore unarioak balio bat itzultzeko operadore bakarra behar dutenak dira.

| Operadorea | Deskribapena |
| --- | --- |
| - | Zeinu aldaketa |
| ! | NOT operadorea |
| ~ | 1-ari osagarria |

Operadore bitarrak balio bat itzultzeko bi operadore edo gehiago behar dituztenak dira.

| Operadoreak | Deskribapena |
| --- | --- |
| + - \* / % | Operadore aritmetikoak |
| == != < > <= >= | Operadore erlazionalak |
|
| && || ^ | Operadore boolearrak |
| ^ << >> >>> | Operadoreak bit mailean |
| + | Kateen kateatzea |

***Adibidea:***

```
public class Operadoreak {
 public static void nagusia(String[] args) {
 int x = 5;
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Gehiketa ---");
 x = 5;
 System.out.println("x + 2 = "+ (x + 2));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Kenketa ---");
 x = 5;
 System.out.println("x - 4 = "+ (x - 4));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Biderketa ---");
 x = 5;
 System.out.println("x \* 3 = "+ (x \* 3));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Osokoen Zatiketa ---");
 x = 5;
 System.out.println("x / 2 = "+ (x / 2));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Modulua ---");
 x = 5;
 System.out.println("x % 2 = "+ (x % 2));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Batez inkremetatua ---");
 x = 5;
 System.out.println("++x = "+ (++x ));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Batez dekrementatua ---");
 x = 5;
 System.out.println("--x = "+ (--x ));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Batez postinkremetatua ---");
 x = 5;
 System.out.println("x++ = "+ (x++ ));
 System.out.println("x = "+ x);
 System.out.println();
 
 System.out.println("--- Batez postdekrementatua ---");
 x = 5;
 System.out.println("x-- = "+ (x-- ));
 System.out.println("x = "+ x);
 System.out.println();
 }
}

```
**BIT mailako operadoreak**

~ 1-ari osagarriak digituak inbertitzen ditu, 0tik 1era eta 1etik 0ra aldatuz. Adibide bat izan daiteke:

```
  11001011
~ 11001011 emaitza 00110100
```
Ikus daitekeenez, balioak 0tik 1era eta 1etik 0ra aldatzen dira.

& *AND* bit-mailan, AND eragiketa egiten du bit-zenbaki biren artean. Eragiketa horretan, bi bitak 1 baldin badira, emaitza 1 izango da; bestela 0 izango da. Adibide bat izan daiteke:

```
 egoera
   01001101
 & 10011011 
______________ 
   00001001
```
|
 *OR* bit-mailan, OR eragiketa bat egiten du. Eragiketa horretan, bi bitetako bat 1 bada, emaitza 1 izango da. Adibide bat izan daiteke:

```
   11001101
 | 01011101
______________
   11011101
```
^ *XOR* bit-mailan, XOR eragiketa egiten du. Eragiketa horretan, bi zenbakiak berdinak badira, emaitza 0 izango da; bestela, 1 izango da. Adibide bat izan daiteke:

```
  00101001
^ 01101101
______________
  01000100
```
< < *Desplazamendua ezkerrera*, operadore horrek bitak n posizio mugitzen ditu ezkerrera. Adibidez, n=1 izanda:

```
01101110
01101110 << 1 = 11011100
```
Desplazamenduan ikus daitekenez, 0 digitu bat txertatzen da eskuinetara.

### Operadoreen lehentasuna

Operadoreak adierazpenen zati nagusi bat dira, eta erabilera mota eta modua funtsezkoa da programatzeko orduan, baina horiek erabiltzeko arau batzuk hartu behar dira kontuan, operadoreen lehentasuna, esaterako.

Operadoreak beren lehentasunaren arabera exekutatzen dira: lehentasun handiagoa badute, lehentasun txikiagoko operadoreak baino lehenago ebaluatuko dira; kasualitatez lehentasun-maila bereko operadoreak aurkezten badira, horiek eskuinetik ezkerrera ebaluatuko dira; eta operadore bitarrak badira (esleipen-operadoreak izan ezik), ezkerretik eskuinera ebaluatuko dira. Hala ere, "()" parentesien bidez, Javari adieraz dakioke zein operadore ebaluatu behar duen lehendabizi, bere lehentasuna kontuan izan gabe; horrela, Javaren konpiladoreak, lehenik parentesien barruan dauden eragiketak gauzatu behar dituela interpretatzen du, eta gero gainerako operadoreekin jarraitu.

Taula honetan Javan erabilitako operadoreak sailkatzen dira haien lehentasun-mailaren arabera, maila altuena goian kokatua egonik:

| Operadore motak | Operadoreak |
| --- | --- |
| Operadore posfinkoak | [ ]. (parametroak) espr++ espr-- |
| Operadore unarioak | ++espr --espr +espr -espr ~ ! |
| Sortzea edo bihurtzea | New (mota) espr |
| Biderketa, Zatiketa, MOD (hurrenez hurren) | \* / % |
| Gehiketa, Kenketa | + - |
| Desplazamendua | << >> >>> |
| Konparaketa | < > <= >= instanceof |
| Berdintasuna | == != |
| AND bit-mailan | & |
| OR bit-mailan | | |
| XOR bit-mailan | ^ |
| AND logikoa | && |
| OR logikoa | || |
| Baldintza | ? : |
| Asignazioa | = += -= \*= /= %= &= ^= |= <<= >>= >>>= |

Javako operadoreen lehentasunaren adibide bat honako hau izan daiteke: kode bat dugu, eragiketa aritmetiko batzuk egiteaz arduratuko dena:

```
int zenbakia1 = 3;
int zenbakia2 = 4;
int emaitza;
emaitza = zenbakia1 + zenbakia2 \* 3;
System.out.println (emaitza); //Honek pantailaratuko du 15 zenbakia.

```
Operadoreen lehentasunaren arabera, "\*" biderketak, "+" batuketak baino lehentasun handiagoa du; beraz, lehenik biderkatzea gauzatzen da eta gero batuketa egiten da.

```
int zenbakia1 = 3;
int zenbakia2 = 4;
int emaitza;
emaitza = (zenbakia1 + zenbakia2) \* 3;
System.out.println (emaitza); //Honek 21 zenbakia pantailaratuko du.

```
Kasu horretan, emaitza aldatu egiten da; izan ere, lehenik, parentesiaren barruan dauden parametroak ebaluatzen dira, eta ondoren gainerakoak. Javak garapenerako ematen duen gomendioetako bat 3 operadore baino gehiagoko eragiketetan parentesiak erabiltzea da; horrela, kodea irakurtzea errazagoa egiten da eta akatsak saihesten dira konpilatzeko unean.

### Sententziak

Sententziak, egiten diren ekintza sekuentzia baten irudikapena dira. Javako sententziak, esleipen-sententziak, baldintzazko-sententziak, begizta-sententziak eta jauzi-sententziak izan daitezke, eta oro har, instantzia batek eta operadore batek osatzen dituzte. Sententzia bat amaitu dela eta hurrengoarekin jarrai dezakeela adierazten duen adierazlea puntu eta koma (;) zeinua da. Adibide bat esleipen-sententzia da, aldagai bateko instantzia batek, esleipen-zeinuak eta esamolde batek osatzen dutena. Hona hemen adibide bat:

```
int aldagaia = 12+2;

```
Esleipen-sententzietan, balio bat esleitzen zaio aldagai edo konstante bati. Baldintzazko-sententziak, programaren exekuzio-fluxua definitzeko baldintza bat adierazten dutenak dira; besteak beste, *if-else* eta *switch* ditugu. Begizta-sententziek ekintza bat egiten dute denbora jakin batez, edo baldintza bat bete arte; horien artean ditugu *while*, *do-while*, eta *for*. Jauzi-sententziek konpilatzailea  programako puntu zehatz batera edo hurrengo sententziara eramaten dute konpilatzailea; besteak beste, *break*, *continue* eta *return* ditugu.

Kritikak
--------

Java software konplexuaren kudeaketan bide berri bat irekitzeko sortua izan zela esan ohi da, bere *"Write once, run anywhere"* filosofiari jarraituz, eta oro har, ondo moldatu dela esan daiteke. Hala ere, Javak badu zer hobetua. Eramangarritasunaren aldetik izan ditzakeen akatsez gain honakoak aipoatu izan dira: exekuzio-abiadura, koma higikorreko aritmetikaren inplementazioa, segurtasuna, etab.

Kanpoko Loturak
---------------

### Oracle - Sun

* Javaren webgune ofiziala garatzaileentzat.
* Javaren espezifikazioak. (The Java Language Specification, Hirugarren edizioa)
* Sun-en tutoriala Java programazio lengoaiari buruz.
* Javaren liburu ofizial txuria.

### Tutorialak

* Thinking in Java Egilea: Bruce Eckel
* Introduction to Computer Science using Java Egilea: Bradley Kjell
* Java Course Egilea: A.B. Downey
* Computer books

### Kritikak

* Softpanorama Java Critique Page: Java vs Scripting Languages Egilea: Nikolai Bezroukov
* How Java’s Floating-Point Hurts Everyone Everywhere Egilea: W. Kahan und Joseph D. Darcy

Erreferentziak
--------------

1. ↑   **(Gaztelaniaz)** F.P.  (2007-02-28). «Sun microsystems: una historia de éxitos (y de estancamiento)» *El País* ISSN 1134-6582. (Noiz kontsultatua: 2019-11-28).
2. 1 2 3 4   **(Gaztelaniaz)** RubénBC, por.  (2016-06-09). «"Write Once, Run Anywhere"» *NXTER.ORG* (Noiz kontsultatua: 2019-11-28).
3. ↑   «Programming Language Popularity» *web.archive.org* 2009-01-16 (Noiz kontsultatua: 2019-10-17).
4. ↑   «TIOBE Index | TIOBE - The Software Quality Company» *www.tiobe.com* (Noiz kontsultatua: 2019-10-17).
5. ↑   «GNU Classpath - GNU Project - Free Software Foundation (FSF)» *www.gnu.org* (Noiz kontsultatua: 2019-11-28).
6. ↑   **(Gaztelaniaz)** «JavaScript» *Documentación web de MDN* (Noiz kontsultatua: 2019-11-28).
7. ↑   **(Gaztelaniaz)** Pastor, Javier.  (2018-04-28). «Cuando Mosaic dominaba el mundo (de los navegadores)» *Xataka* (Noiz kontsultatua: 2019-11-28).
8. ↑   «The HotJava Browser» *www6.uniovi.es* (Noiz kontsultatua: 2019-11-28).
9. ↑   **(Ingelesez)** «Internet | Top Ten Reviews» *www.toptenreviews.com* (Noiz kontsultatua: 2019-11-28).
10. ↑   «JUST ANOTHER VAGUE ACRONYM. JAVA stands for Chat and Slang» *www.special-dictionary.com* (Noiz kontsultatua: 2019-11-28).
11. ↑   «Jonathan Schwartz's Blog: Different Isn't Always Better, But Better's Always Different» *web.archive.org* 2009-09-05 (Noiz kontsultatua: 2019-10-17).
12. ↑   «The Java Community Process(SM) Program» *www.jcp.org* (Noiz kontsultatua: 2019-11-28).
13. ↑   «The Java Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 901» *jcp.org* (Noiz kontsultatua: 2019-11-28).
14. ↑   **(Ingelesez)** «Internet Communications Engine | Semantic Scholar» *www.semanticscholar.org* (Noiz kontsultatua: 2019-11-28).
15. ↑   **(Gaztelaniaz)** «OSGI: UNA PLATAFORMA MODULAR Y LIGERA PARA CONSTRUIR APLICACIONES BASADAS EN SERVICIOS - COMPLETO - Euskadi+innova» *www.spri.eus* 2007-07-12 (Noiz kontsultatua: 2019-11-28).
16. ↑   **(Gaztelaniaz)** «Programación Orientada a Objetos - EcuRed» *www.ecured.cu* (Noiz kontsultatua: 2019-11-28).
17. ↑   «Understanding JIT compiler (just-in-time compiler)» *Aboullaite Med* 2017-08-31 (Noiz kontsultatua: 2019-11-28).
18. ↑   **(Gaztelaniaz)** «JSP-Servlet: Qué es un Java Bean?» *Programación Web Full Stack* 2017-10-24 (Noiz kontsultatua: 2019-11-28).
19. ↑   «Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle» *www.oracle.com* (Noiz kontsultatua: 2019-10-25).
20. ↑   «Java SE Specifications» *docs.oracle.com* (Noiz kontsultatua: 2019-10-27).
21. ↑   «Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle» *www.oracle.com* (Noiz kontsultatua: 2019-10-27).
22. ↑   «Eclipse IDE for Java Developers | Eclipse Packages» *www.eclipse.org* (Noiz kontsultatua: 2019-11-28).
23. ↑   «Welcome! - The Apache HTTP Server Project» *httpd.apache.org* (Noiz kontsultatua: 2019-11-28).
24. ↑   **(Ingelesez)** Archiveddocs. «Operator Overloading (C# vs Java)» *docs.microsoft.com* (Noiz kontsultatua: 2019-10-25).
25. ↑   «Statements - Wikibooks, open books for an open world» *en.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
26. ↑   «Classes, Objects and Types - Wikibooks, open books for an open world» *en.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
27. 1 2   «Conditional blocks - Wikibooks, open books for an open world» *en.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
28. 1 2 3 4   «Loop blocks - Wikibooks, open books for an open world» *en.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
29. ↑   «Programación en Java/Funciones - Wikilibros» *es.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
30. ↑   Ambiente, Medio.  (2009-02-15). «programacion java: APLICACIONES AUTONOMAS» *programacion java* (Noiz kontsultatua: 2019-11-28).
31. 1 2   **(Ingelesez)** «Java Applets» *W3schools* (Noiz kontsultatua: 2019-11-28).
32. ↑   «Deploying Applets in a Mixed-Browser Environment» *web.archive.org* 2006-06-29 (Noiz kontsultatua: 2019-10-25).
33. ↑   «Keywords - Wikibooks, open books for an open world» *en.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
34. ↑   «Arithmetic expressions - Wikibooks, open books for an open world» *en.wikibooks.org* (Noiz kontsultatua: 2019-11-28).
35. ↑   *docs.oracle.com* (Noiz kontsultatua: 2019-11-28).
36. 1 2 3   **(Ingelesez)** Fernández, Juan. *ORDEN DE PRIORIDAD DE LOS OPERADORES EN JAVA.*  (Noiz kontsultatua: 2019-11-28).
37. ↑   «Expresiones, sentencias y bloques en Java» *Manual Web* 2019-11-25 (Noiz kontsultatua: 2019-11-28).

Kanpo estekak
-------------

1. Programación en Java
2. Java Programming

|  |  |
| --- | --- |
| Autoritate kontrola | 
* **Wikimedia proiektuak**
* Wd Datuak: Q251
* Commonscat Multimedia: Java (programming language)

---

* **Identifikadoreak**
* BNE: XX540033
* BNF: 12533207m (data)
* GND: 4401313-9
* LCCN: sh95008574
* NKC: ph117027
* **Hiztegiak eta entziklopediak**
* Britannica: url

 |

* Wd Datuak: Q251
* Commonscat Multimedia: Java (programming language)

* JAVA kafe hutsa ala informatikaren etorkizuna? Zientzia.net atarian