[java] uitleg gevraagd over enkele java problemen

[Verwijderd]

Ik zou graag wat hulp krijgen bij het begrijpen van java code want ik snap van een aantal dingen werkelijk niets. Met name het declareer gedeelte, dus ik hoop dat er iemand is die de volgende codes extreem uitgebreid kan uitleggen zodat iedere gek het snapt. Hopelijk wordt ook dit topic met respect behandeld ondanks dat het niveau lager is dan jullie gewend zijn.

Als bij de uitleg gebruik gemaakt moet worden van woorden als velden, atributen en andere vage java uitdrukkingen, wil je dan aub die woorden ook even in heeel simpel nederlands uitleggen?

1. Ik denk dat hier een array wordt aangemaakt met 4 indexnummers waar alleen het type string in opgeslagen kan worden. Maar waarom moet ik 2 keer het woord String hebben (Sting[] en String [4])?

code:

String[] boektitel = new String[4];

2. Hier is de integer maxaantal= 30. Wat doet de volgende code nu eigenlijk precies? Hier staat nog een extra woord: Leerling[]. Wat is nu eigenlijk het verschil qua werking met voorbeeld 1? Wat doet Leerling[]? Ik dacht dat String[] bedoelt was om aan te geven: Let op er komt een array. Heb ik dat verkeerd begrepen?

code:

private Leerling [] leerlingRij = new Leerling [maxaantal]

3. Hoe stuur ik een volledige array naar een klasse en hoe krijg ik een volledige array uit een klasse (de klasse is in mijn geval een appart bestand dat ik implementeer). Een variable kun je naar een stukje code in een klasse doorsturen op deze manier:

klasse
public Dobbelsteen(int zijden){....}
programma: dobbelsteen.Dobbelsteen(6);
Een variable uit een klasse ontvangen kun je met return:
public getWorp(){return worp;}
programma: int Worp=dobbelsteen.getWorp();

Maar hoe doe ik dat nu als ik een volledige erray wil opvragen uit de klasse, of wil versturen naar de klasse?


4. Een java klasse is opgebouwd uit de volgende onderdelen:
-velden
-constructor
-methoden
Ik snap niet wat deze onderdelen nu eigenlijk doen in een klasse.

5. private Dobbelsteen dobbelsteen1= new Dobbelsteen(); Dit is een soort gelijke vraag als met de array. Als ik dit begrijp heb ik de variable dobbelsteen1 die ik als het ware bind aan de klasse Dobbelsteen. Maar waar heb ik die variable dan voornodig? Waarom kan ik niet bijvoorbeeld zeggen: worp = Dobbelsteen.getworp()? Dit moet zijn: worp = dobbelsteen1.getworp(). Dus met andere woorden, waar is de eerste Dobbelsteen voor, het woord dobbelsteen1 en tot slot Dobbelsteen()?

De vraag over de lijst uitlezen is inmiddels min of meer gelukt. Hopelijk zijn mijn vragen zo goed.

Wat moet ik mij hier bij voorstellen en hoe werkt het?

-------------------------------------------------------------------------------------
Ik heb al verschillende tutorials inclusief mijn schoolboek doorgespit, maar ik snap er nog steeds niets van. Voor mijn begrip van de programmeertaal java lijkt mij dit toch noodzakelijk om te begrijpen.

[ Voor 38% gewijzigd door Verwijderd op 07-11-2004 00:13 ]

[Grijze Vos]

Koop een eenvoudiger boek. Java for dummies zal vast bestaan.

[Verwijderd]

Grijze Vos schreef op 06 november 2004 @ 22:23:
Koop een eenvoudiger boek. Java for dummies zal vast bestaan.

Ik heb een heel dik boek: En dan is er java, maar daar kon ik nog steeds sommige gegevens niet uit begrijpen. Daarnaast heb ik nog uitleg aan mijn leraar informatica gevraagd, maar hij kon alleen exact vertellen wat er in mijn boek ook staat, wat het geheel voor mij nog steeds niet helder maakt. Nu heb ik as dinsdag een toets over java en dan zou ik het leuk vinden als ik ook dit gedeelte zou snappen, ondanks dat ik prima programmatjes kan maken zonder echt te begrijpen hoe het geheel nu in elkaar steekt. Dus ik hoop dat ik een beetje uitleg kan krijgen.

[Kwistnix]

Dit is echt basiskennis die goed uitgelegd staat in het boek wat jij al in je bezit hebt. Dat weet ik, want ik ben zelf met dat boek begonnen.

[Verwijderd]

Welk boek heb je eigenlijk?

[Bergen]

Zoals je in de FAQ had kunnen lezen, behandelen we op GoT geen huiswerkvragen. Op zich zou ik je best willen helpen (en anderen ook vat wel), maar ik vind dat je eerst moet aangeven wat je precies niet snapt. Dus niet gewoon je vraag op 't forum neerkwakken en vragen hoe 't werkt.

Neem nu vraag 1. Er wordt gewoon een string aangemaakt. Wat snap je dan precies niet? Vraag 2 is eigenlijk precies 't zelfde als vraag 1.

Voor de overige vragen geldt heel simpel: wat heb je zelf al geprobeerd? Laat eens wat code zien en geef aan wat je niet snapt.

[ Voor 5% gewijzigd door Bergen op 06-11-2004 22:59 ]

[Verwijderd]

Als je het uit je eigen boek niet begrijpt, kun je ook deze nog proberen:
Thinking in Java - Bruce Eckel

(een gratis online boek)
te vinden op: (of anders via google)
http://64.78.49.204/TIJ-3rd-edition4.0.zip

Verder moet je gewoon even de tijd nemen je boek te lezen om je het principe van object georienteerd programmeren eigen te maken.

(als je een for-lus gebruikt om waarden in een integer array op te slaan, zou het dan niet logisch zijn om ook een for-lus te gebruiken om de waarden af te drukken?)

[Johnny]

Verwijderd schreef op 06 november 2004 @ 22:15:
Ik zou graag wat hulp krijgen bij het begrijpen van java code want ik snap van een aantal dingen werkelijk niets. Met name het declareer gedeelte, dus ik hoop dat er iemand is die de volgende codes extreem uitgebreid kan uitleggen zodat iedere gek het snapt. Hopelijk wordt ook dit topic met respect behandeld ondanks dat het niveau lager is dan jullie gewend zijn.

Als bij de uitleg gebruik gemaakt moet worden van woorden als velden, atributen en andere vage java uitdrukkingen, wil je dan aub die woorden ook even in heeel simpel nederlands uitleggen?

1.

code:

String[] boektitel = new String[4];

2. Hier is de integer maxaantal= 30. Wat doet de volgende code nu eigenlijk precies?

code:

private Leerling [] leerlingRij = new Leerling [maxaantal]

Je maakt een lijst van 30 Leerling objecten.

3. Hoe stuur ik een volledige array naar een klasse en hoe krijg ik een volledige array uit een klasse (de klasse is in mijn geval een appart bestand dat ik implementeer).

Door een publieke methode in die klasse te zetten die een Array als invoer accepteert en er ook weer eentje terug stuurt (return).

code:

public Leerling[] stuurTerug(Leerling[] mijnKlasgenoten) {

return mijnKlasgenoten;
}

4. Stel ik heb een venster voor een lijst gemaakt. Hoe kan ik de inhoud van een lijst laten printen in dat vak? Neem bijvoorbeeld het volgende stuk code:

code:

private int aantal = 10
private int[] intRij = new int[aantal];
// De intRij wordt vervolgens gevuld door een forloop 
met 10 willekeurige getallen. Hoe laat ik die intrij dan op mijn scherm printen?

Ook met een for loop, zet daar gewoon de methode in die je gebruikt om het op het scherm te zetten (waarschijnlijk gebruik je iets met drawString of System.out.println)

5. Een java klasse is opgebouwd uit de volgende onderdelen:
-velden
-constructor
-methoden

Wat moet ik mij hier bij voorstellen en hoe werkt het?

Constructor is de eerste methode in je klasse die dezelfde naam heeft als de klasse.

Methoden zijn je eigen gemaakte functies (hebben haakjes() na de naam).

Alle andere dingen zijn velden.

[sirdupre]

code:

String[] boektitel = new String[4];

Hier wordt een array van strings aangemaakt. Een string is een willekeurig stukje tekst. Een array is een soort "lijst", waar je aan de hand van een index door moet lopen. In java kan je het = teken vaak beter als "wordt" doorlezen. Ook werken arrays in java eigenlijk als objecten. Daarom staat er een new codewoord. new gebruik je altijd als je een nieuw object aan wilt maken.
Kortom, vertaald in "nederlands" staat hier:
De variabele boektitel, van het type "een array van Strings", wordt een verwijzing naar een nieuwe array van Strings, welke 4 elementen bevat.
Kortom, je kunt nu in het vervolg met de variabele boektitel, bij een lijst komen die 4 losse String objecten bevat.

2. Hier is de integer maxaantal= 30. Wat doet de volgende code nu eigenlijk precies?

code:

private Leerling [] leerlingRij = new Leerling [maxaantal]

private geeft aan dat het hier om een object variabele gaat. Wat private wil zeggen, is dat alleen het object zelf aan deze variabele kan komen. In java heb je nog twee andere codewoorden om methodes & objectvariabelen mee te beschermen (of niet), namelijk "public", wat in feite gewoon betekent dat alles en iedereen bij die methode of dat object kan, en "protected", wat iets ingewikkelder is. Bij protected komt het erop neer dat alleen het object zelf en objecten die van het object "afstammen" erbij kunnen. Ga over dat laatste trouwens voorlopig je hoofd nog maar niet breken.
Leerling geeft aan dat het hier om een variabele van het type Leerling gaat. de [] geeft aan dat het wéér, zoals bij vraag 1, om een array gaat. maxaantal is hier gewoon een int, waarschijnlijk, en dat wil dus zeggen dat de variabele leerlingRij een hoeveelheid elementen gaat bevatten, die in maxaantal staat. Als maxaantal dus de waarde 30 heeft, zal leerlingRij een lijst met 30 elementen worden, van het type Leerling.

3. Hoe stuur ik een volledige array naar een klasse en hoe krijg ik een volledige array uit een klasse (de klasse is in mijn geval een appart bestand dat ik implementeer).

Hmmm, in principe implementeer je interfaces, maar ik vermoed dat je dat niet bedoelt. Wat je hier wel wilt doen, snap ik niet precies, het is nogal vaag omschreven. Als je een instantie van een klasse maakt, oftewel een object, roep je met behulp van het "new" codewoord de constructor van die klasse aan. Een optie zou kunnen zijn deze constructor als parameter een array object te laten accepteren. Op die manier kan je er weer mee verder in een andere klasse.

4. Stel ik heb een venster voor een lijst gemaakt. Hoe kan ik de inhoud van een lijst laten printen in dat vak? Neem bijvoorbeeld het volgende stuk code:

code:

private int aantal = 10
private int[] intRij = new int[aantal];

Ik zou zeggen, loop met een for-loop die lijst gewoon door en print elk element afzonderlijk. Je krijgt dan iets als:

code:

for (int t=0; t < intRij.length; t++) venster.print(intRij[t]);

5. Een java klasse is opgebouwd uit de volgende onderdelen:
-velden
-constructor
-methoden

Wat moet ik mij hier bij voorstellen en hoe werkt het?

Tsja, velden zijn eigenlijk gewoon variabelen. Je kunt het een beetje zien als de eigenschappen van een klasse. Als je een klasse Auto hebt, zou je bijvoorbeeld weer "velden" genaamd motor (van het type Motor), wielen (van het typen Wielen) en schakelbak (van het type Schakelbak) kunnen hebben. Denk er ook nog een primitieve variabele als "zitplaatsen" (van het type int) bij en je hebt op zich een aardige omschrijven van een auto. Typen als Motor, Wielen en Schakelbak zijn dan op zichzelf ook weer aparte klassen, die ook weer eigen velden kunnen hebben. Let dus op dat een klasse eigenlijk omschrijft wat de eigenschappen van een object van die klasse zijn en wat je met een object van die klasse kan doen (wat je ermee kan doen, zijn eigenlijk de methoden). Je kunt dus verschillende objecten hebben die wel verschillend zijn. Het verschil zit het dan in de inhoud van de "velden".

Een constructor is eigenlijk een soort aparte methode. Als je een nieuw object van een klasse aanmaakt, roep je die constructor aan. Die constructor zorgt vervolgens dat de velden van een klasse een waarde krijgen. Verder werkt het eigenlijk gewoon als een methode. Oh ja, een contructor heeft altijd een object van het type van de klasse zelf, als methode-resultaat.

Een methode is eigenlijk gewoon een stukje programma code. Vaak maakt een methode gebruik van de "velden" van de klasse waar de methode zich in bevindt. Een methode kan ook parameters accepteren. Om weer terug te komen op het Auto object, je zou je voor kunnen stellen dat één van de eigenschappen van een auto, de plaats waar die zich bevindt, is. Een auto zou dan een methode rij kunnen hebben die als parameter hoeveel meter hij dan moet rijden accepteert. Stel nu dat je een variabele fiat hebt van het type Auto. Je zou dan een methode aan kunnen roepen als volgt:

code:

fiat.rij(10);

Door dit aan te roepen, zou het Auto-object fiat dan dus 10 meter verplaatsen. Maar stel je nou voor dat een Auto object ook een veld "handrem" heeft. Als je probeert te rijden terwijl de handrem er nog op zit, verandert de positie niet. Kortom, de methode rij zou er als volgt uit kunnen zien:

code:

public void rij (int afstand])
{
if (handrem==false) positie = positie + afstand;
}

Let op het gedeelte tussen de haakjes achter de naam van de methode, namelijk (int afstand). Dit is dus de parameter. Verder zijn handrem en positie dus object variabelen, oftewel "velden". Overigens kan je de if regel een stuk korter schrijven, maar dat is meer voor als je wat verder bent:

code:

if (!handrem) positie += afstand;

Als laatste zal ik nog een voorbeeld van een methode met een resultaat geven. Stel je weer de auto voor. Je hebt een Auto object, laten we weer zeggen met de naam fiat. Stel, je hebt een tweede Auto object, met de naam mercedes. Je wilt controleren, of deze auto's niet op dezelfde positie zitten (wat dan zijn ze waarschijnlijk op elkaar geknald). Dit kan door een methode met een methode resultaat te gebruiken. Je kunt dit een beetje zien als aan een object een vraag stellen. Het methode resultaat is dan zeg maar het antwoord, wat je van het object krijgt. Een stukje code:

code:

public int geefPositie()
{
return positie;
}

Let op het woord int voor geefPositie en op het woord return. Het type voor de naam van de methode, geeft aan wat voor antwoord de methode teruggeeft. Met de speciale opdracht return, geef je ook daadwerkelijk iets terug. positie moet dus van het type int zijn, anders zal de compiler een foutmelding geven.
Terug op het botsing scenario, een stukje voorbeeld code:

code:

if (fiat.positie == mercedes.positie) venster.print("Oh jee, een botsing!");
else venster.print("Gelukkig, geen botsing!");

Hopelijk zijn bepaalde dingen nu wat duidelijker. Suc6 in ieder geval.

[ Voor 7% gewijzigd door sirdupre op 07-11-2004 00:04 . Reden: BBCode in code blokken werkt niet.... ]

[Verwijderd]

Om te beginnen al heel erg bedankt voor de uitleg. Het wordt al veel duidelijker. Er zijn nog 2 kleine dingen die ik niet optimaal snap:

Leerling geeft aan dat het hier om een variabele van het type Leerling gaat.

. Wat moet ik mij hier bij voorstellen? Van het type string zou ik begrijpen, maar moet je hier niet duidelijk maken wat dat type inhoud?

Vraag 5 (zie topic start) is er nog bij gekomen. Ik wil hem graag eerst zelf even proberen te snappen:

dobbelsteen1 is een verwijzing naar de nieuwe klasse Dobbelsteen(). De variable is van het type dobbelsteen.

Klopt dit min of meer? En ook hier, wat wordt dan bedoelt met het type dobbelsteen?

[Verwijderd]

tja veel dingen zijn voor de meeste hier cristal clear, maar ja voordat je het hele OO verhaal totaal snapt, bent je alweer een tijdje verder. Ik zou zeggen, lees boeken over het ontwerpen van klassen waarin wordt uitgelegd, wat je in welke klasse moet stoppen. Want de mensen hier doen wel stoer, maar het is best ingewikkeld om echt goed te snappen hoe je het hele OO optimaal kan gebruiken en hoe je optimale klasses kan maken. Dat kost best nadenken en zelfstudie.

Maarre nog over vraag 5, stel je doet alleen maar Dobbelsteen.getWorp(), als die methode onafhankelijk van de klasse is, is dit de beste oplossing, dat wordt een statische methode genoemd. Maar bij veel klassen( stel je bijvoorbeeld een enemy in een spelletje voor), de instanties daarvan hebben allemaal unieke waardes. de een staat op die plek, de ander heeft nog maar zoveel energie etc. Als je zoiets hebt, moet je dus steeds een apart object maken ala Dobbelsteen dobbelsteen1= new Dobbelsteen();. Maar al zou je bijvoorbeeld willen weten op welke plek een letter in het alfabet staat, heb je geen objecten nodig, dan zeg je bijvoorbeeld int plaats = AlfabetTools.getPlek( "x" ); suc6

[Johnny]

Verwijderd schreef op 07 november 2004 @ 00:29:
Om te beginnen al heel erg bedankt voor de uitleg. Het wordt al veel duidelijker. Er zijn nog 2 kleine dingen die ik niet optimaal snap:


[...]
. Wat moet ik mij hier bij voorstellen? Van het type string zou ik begrijpen, maar moet je hier niet duidelijk maken wat dat type inhoud?

Wat denk je dat het type String inhoud?

Een String is ook een object, (let op de hoofdletter, het is de gewoonte om klassenamen met een hoofdletter te schrijven, klasse is hetzelfde als een object). In dat String object zit een array van karakters (letters, cijfers enz) waardoor je er dus tekst in kunt stoppen.

Objecten van het type String hebben ook allerlei methoden. Zoals bijvoorbeeld toLowerCase() om de hoofdletters te veranderen in kleine letters.

code:

//maak een String object met de naam "test"
String  test = "Mijn Tekst";

//Schrijf het String object naar het scherm en vervang de hoofdletters.
System.out.println(test.toLowerCase());

Hetzelfde principe geldt voor een leerling. Een leerling heeft een aantal eigenschappen die je kunt instellen, bijvoorbeeld zijn leeftijd en naam.

code:

Leerling mijnIrritanteKlasgenoot = new Leerling();

//gebruik de zelfgemaakte methoden van de klasse Leerling om gegevens op te slaan
mijnIrritanteKlasgenoot.setName("Jantje");
mijnIrritanteKlasgenoot.setAge(16);

//haal de leeftijd weer op met een andere methode
mijnIrritanteKlasgenoot.getAge();

De klasse leerling zou er dan zo uit kunnen zien:

code:

class Leerling {

//variablen die in de klasse bewaard worden
private int age = 0;
private String name = null;

public void setName(String newName) {
//zet de variablen vanuit de methode in de klasse
name = newName;
}

public void setAge(int newAge) {
age = newAge;
}

public int getAge() {
return age;
}

}

[Kwistnix]

Je moet zorgen dat je de termen goed begrijpt. Dan wordt alles vanzelf duidelijk.


Voorbeeld:
_{Regels die beginnen met // zijn commentaar regels, geen functionele code!}

code:

//Klasse Huis. Deze klasse bevat slechts 1 attribuut en dat is een huisnummer.
//Verder bevat de klasse naast de Constructor een methode om dat huisnummer op te vragen.
class Huis{
  
  //Deze variabele bevat het huisnummer
  private int huisnummer;

  //Dit is de Constructor van deze klasse.
  //Wanneer je een nieuw Object aan wil maken van het type Huis roep je deze methode aan: new Huis();
  public Huis(int huisnummer){
     this.huisnummer = huisnummer;
  }

  //Met deze method vraag je het huisnummer op dat is toegekend aan het 
  //object tijdens bij het instantiëren (aanmaken). 
  public int getHuisnummer(){
     return huisnummer;
  }
}

De bovenstaande klasse is dus een blauwdruk voor een Huis object.
Iedere keer als jij new Huis(); aanroept wordt er een nieuw object aangemaakt die over 1 attribuut (huisnummer) en 2 mehoden (constructor en getHuisnummer) beschikt.

Stel je wilt een Huis object aanmaken, dat doe je zo:

code:

Huis mijnhuisje = new Huis(1);

Wanneer je van dit Huis object het huisnummer wilt weten, roep je de methode getHuisnummer van dat object aan:

code:

int huisnummer = mijnhuisje.getHuisnummer();

Stel je wilt een huizenblok aanmaken. Je moet dan meerdere instanties van de klasse Huis maken. Je kan als volgt doen:

code:

Huis mijnhuisje = new Huis(1);
Huis jouwhuisje = new Huis(2);
Huis hoekhuis = new Huis(3);

Bovenstaande code maakt 3 instanties aan van de klasse Huis.
Een andere manier om dit te bereiken is om een array van huizen te maken:

code:

Huis[] huizenblok = new Huis[3];

Bovenstaande code maakt een array (verzameling) aan, waar je maximaal 3 huis objecten in kan opslaan. Er zijn echter nog geen huis objecten gecreëert! De verzameling is nog leeg!

code:

for(int i=0; i<huizenblok.length; i++){
  Huis nieuwhuis = new Huis(i+1);
  huizenblok[i] = nieuwhuis;
}

Bovenstaande code vult de array huizenblok met Huis objecten, net zolang tot de array vol is. Hoe werkt het? Er wordt een for-lus gecreëerd. Als argument wordt er een int met de naam i aangemaakt. Dit is de teller, deze begint bij 0. Vervolgens wordt aangegeven dat de lus moet doorgaan zolang de waarde van de teller kleiner is dan de lengte van de array huizenblok. Zolang de teller kleiner is wordt de code tussen de accolades uitgevoerd en de teller met 1 opgehoogd (aangegeven door i++).

Wat gebeurd er binnen de lus?
Er wordt een nieuw huis object aangemaakt met een huisnummer dat gelijk is aan de huidige waarde van de teller + 1. Er wordt 1 bij opgeteld, omdat anders het eerste huisnummer 0 zou zijn en we willen dat de huisnummers bij 1 beginnen.
Vervolgens word het aangemaakte object in de array huizenblok gestopt.

Een array benader je aan de hand van een index. Die index begint bij 0.
In het code voorbeeld gebruiken we de waarde van de teller om aan te geven o aan welk index nummer het huis object gekoppeld moet worden. De eerste keer dat de lus doorlopen wordt wordt er een Huis object aangemaakt met huisnummer 1. Dit object wordt in de array huizenblok opgelsagen onder index 0. De tweede keer dat de lus wordt doorlopen wordt er een Huis object aangemaakt met huisnummer 2, deze wordt onder index 1 in de array huizenblok opgeslagen etc.

Je hebt nu dus een lijst met huis objecten. Nu wil je van het huis object op index nummer 1 het huisnummer graag weten. Hoe doe je dat?

code:

int huisnummer = huizenblok[1].getHuisnummer();

Vrij eenvoudig dus. Je geeft aan welk huis object je wilt benaderen door het indexnummer op te geven. Vervolgens roep je gewoon de methode getHuisnummer aan van het Object dat je benaderd hebt.


Uitleg termen:

Klasse: Een blauwdruk voor een object (zie klasse Huis).

Object: Een instantie van een klasse:

code:

Huis mijnhuis = new Huis(1);

Primitief type: Java beschikt over een aantal primitieve typen: byte, short, int, long, float, double, char, boolean. Primitieven zijn GEEN objecten. Er wordt dus geen instantie aangemaakt van een klasse (geen aanroep d.m.v. new()):

code:

int i = 1;
boolean waar = true;

Variabele: Een variabele verwijst naar een object of een primitief type. In het onderstaande voorbeeld zijn i en mijnhuis beide variabelen.

code:

int i = 1;
Huis mijnhuis = new Huis(i);

Methode: Een uitvoebaar stuk code dat deel uit maakt van een klasse. Een methode heeft altijd een type en een naam. Het type is afhankelijk van de variabele die als terugkeerwaarde dient (variabele achter het woord return).
Wanneer er geen terugkeerwaarde bestaat is het type ALTIJD void. Verder kan aan een methode verschillende parameters meegegeven worden. Deze worden binnen de ronde haken opgenomen. Een methode zonder parameters heeft wel altijd twee ronde haaken met niets er tussen.
Voorbeeld (twee verschillende methodes):

code:

public void setHuisnummer(int huisnummer){
  this.huisnummer = huisnummer;
}

public int getHuisnummer(){
  return huisnummer;
}

Constructor: Speciale methode die wordt aangeroepen om een nieuw object aan te maken (nieuwe instantie te maken van de klasse). Deze methode heeft ALTIJD dezelfde naam als de klasse.

Declareren: Het aanmaken van een variabele:

code:

int i;
Huis mijnhuis;
boolean waar;

Instantiëren: Aangeven dat er een nieuw object (nieuwe instantie van een klasse) aangemaakt moet worden (wordt aangegeven door new):

code:

Huis mijnhuis = new Huis();

Initialiseren: Een waarde toekennen aan een variabele:

code:

i = 0;
mijnhuis = new Huis(1);

Regels voor naamgeving:

• De naam van een klasse begint ALTIJD met een hoofdletter.
• De naam van een methode begint ALTIJD met een kleinde letter (behalve wanneer het een constructor methode is).
• De naam van een constructor methode is ALTIJD identiek aan de naam van de klasse.
• De naam van een variabele begint ALTIJD met een kleine leter.


Het domein van variabelen:

Er zijn twee soorten variabelen:
• Object-variabelen (niet verwarren met variabelen die naar een Object verwijzen!).
• Lokale variabelen.

Object-variabelen zijn variabelen die direct aan het begin van de klasse gedeclareerd worden. De variabele huisnummer in de klasse Huis is hier een voorbeeld van. Deze variabelen zijn overal binnen de klasse te benaderen. In iedere methode, binnen iedere lus etc.

Lokale variabelen zijn variabele die alleen binnen een bepaalde methode of zelfs alleen binnen een lus IN die methode te bereiken zijn.

Je kan niet twee variabelen met dezelfde naam declareren binnen hetzelfde domein. Het kan echter wel voorkomen dat je binnen een methode een lokale variabele aanmaakt die dezelfde naam heeft als een object-variabele.
In zo'n geval gaat Java er bij het aanroepen van de variabele ALTIJD vanuit dat de lokale variabele bedoeld wordt. Wanner je in zo'n situatie dus de object-variabele wilt bereiken moet je de this referentie gebruiken, zodat Java weet dat hij NIET de lokale variabele moet aanspreken:

code:

....

private int value;

....

public void setValue(int value){
  this.value= value;
}

....

In bovenstaande code wordt er een integer waarde als parameter meegegeven aan de methode setVariabele. Deze methode zorgt er voor dat de object-variabele waarde met de naam value de waarde aanneemt van de lokale variabele met de naam value.

[ Voor 19% gewijzigd door Kwistnix op 07-11-2004 11:14 ]

[Verwijderd]

Even een korte samenvatting (wordt hierboven overigens prachtig uitgelegd). Het enige verschil tussen String en Leerling, is dat String door iemand van Sun (de makers van Java) is gemaakt en Leerling waarschijnlijk door iemand anders (misschien jij zelf wel ).

Je hebt primitieven en objecten.
Primitieven:
int, double, float, enz.
Die beginnen met een kleine letter (soort afspraak).

Objecten:
String, Graphics, Applet, Frame, Leerling, Huis.
Die beginnen met een hoofdletter.

Eén klein addertje. Bij Sun dachten ze, die String, die wordt wel erg veel gebruikt, zou mooi zijn als het een primitieve was. Helaas, dat is het niet. Toch hebben ze het zo ingebouwd dat je zo ongeveer kunt doen alsof het een primitieve is. Laat je echter niet foppen !

[Verwijderd]

Iedereen heel erg bedankt voor de uitleg. Ik heb eindelijk het idee dat ik het snap. Ik heb nog iets waar ik nog niet helemaal uit ben. Stel ik heb een class met de volgende code:

code:

public class zoek{
 
 public String zoek(String[] boekRij, String titel)
{
    for (int t=0; t<boekRij.length; t++)
    {
        if(boekRij[t].equals(titel)){return boekRij[t]+"gevonden";}
    }
    return "Titel "+titel+ " niet gevonden.";
}   
    
}

In een ander bestand waar ik aan het coderen ben staat de volgende code:

code:

public zoek zoekopdracht = new zoek();
.......// staat nog van alles tussen. Het volgende stuk staat bij een action performed knop code.
boekRij[0]= "blaat1";
boekRij[1]= "blaat2";
titel = uitvoerveld.getText();
String uitvoer = zoekopdracht.zoek(boekRij[],titel);

Dit gaat niet werken. Waarom weet ik niet. Ik heb het idee dat ik de array niet goed doorstuur naar die klasse. Kan iemand mij nog vertellen hoe ik een volledige array naar die klasse stuur?

2. Stel ik laat in een klasse een array aanmaken met 10 variable getallen. Hoe stuur ik dan die array in zijn geheel (en dus niet de inhoud bij 1 index nummer) terug naar het hoofdbestand?

[ Voor 7% gewijzigd door Verwijderd op 08-11-2004 17:50 ]

[Glimi]

Nee het probleem is dat je methode zoek de constructor is van je classe zoek en een constructor maakt een object van het type zoek en kan dus als zodanig geen String teruggeven. Geef de methode zoek een andere naam en klaar ben je.

Vraag 2:

Java:

public class Utility {
   public int[] doSomething() {

      return new int[] { 3, 5, 10 };
   }
}
Utility util = new Utility();
int[] bla = util.doSomething();

[ Voor 7% gewijzigd door Glimi op 08-11-2004 18:25 ]

[Verwijderd]

Je hebt het princiepe van klassen nog niet helemaal door

Java:

//public, want je wil dat iedereen je klasse kan benaderen
//class, het is een klasse
//Zoek met hoofdletter Z. Klassen hebben ALTIJD een hoofdletter. (dit lijkt
//  misschien zeiken, maar onleesbare code is na een maand al waardeloos).
//  Wen je aan. Klassen altijd met een hoofdletter !!
public class Zoek{
  //eerst een constructor maken
  //wtf, hoofdletter? methoden toch altijd met kleine letter? 
  //nee, constructor is bijzonder
  //public, want constructor moet altijd te benaderen zijn
  //geen return-waarde, zelfs geen void. Een constructor kan dat niet,
  //  want die is puur voor initialisatie.
  //constructor heeft altijd de naam van de klasse (hej, hoofdletter)
  public Zoek(){
    //initialiseer hier eventueel attributen die deze klasse heeft.
    //gebruik daarvoor eventueel de mogelijkheid om dingen mee te geven aan 
    //de constructor
  }

  //methode
  //moet bereikbaar zijn voor iedereen, dus public
  //geeft iets terug, namelijk String[]
  //kleine letter, want dat hoort zo
  public String[] doSomething(){
    String[] stringArr;
    //do iets met stringArr
    return stringArr;
  }

}

Gaan we naar een andere klasse waarin je zoek gebruikt, daar ligt ik dan voor het gemak enkel een stukje uit.

Java:

//zoek is een ding, dus daar kunnen we nu gewoon een attribuut van maken
Zoek verzinMaarEenHandigeNaam;
//initialiseer de attribuut m.b.v. je constructor
//zolang je dat niet doet, kun je er niets mee
verzinMaarEenHandigeNaam = new Zoek();

//nu een attribuut waar we iets van Zoek in willen hebben
String[] zoekWaarden;
//i.p.v. deze te initialiseren met (een) constructor(s), zetten we datgene
//wat we van Zoek straks terugkrijgen erin. 
//Dat is in feite ook initialiseren
zoekWaarden = verzinMaarEenHandigeNaam.doSomething();

zo kun je dus allerlei objecten maken. Bijvoorbeeld ook een auto:

Java:

public class Auto{
  //attributen mogen eigenlijk nooit van buitenaf te benaderen zijn
  //private dus
  //zoals je nu ziet heeft alles eigenschappen en kunnen ze dingen
  //de auto heeft lichten en een kleur en kan dit veranderen en kan zichzelf tekenen
  private boolean lichtenAan;
  private Color kleur;
 
  //dan krijgen we de constructor weer
  //vergeet je die, dan verzint Java er toch één voor jou
  //je kunt hem dus beter zelf schrijven, weet je zeker dat het goed gaat.
  //voor de aardigheid doen we er nu ook wat mee.
  public Auto(Color kleur){
    this.kleur = kleur;
    lichtenAan = false;
  }

  //methoden moeten altijd een return-waarde hebben, wil je dat niet, return dan 
  //void (anders woord voor niks zegmaar)
  public void doeLichtenAan(){
    lichtenAan = true;
  }
  
  public void doeLichtenUit(){
    lichtenaan = false;
  }

  public void spuitOver(Color kleur){
    this.kleur = kleur;
  }

  public void tekenOpScherm(Graphics g){
    //code die op basis van wat de attributen zijn
    //een autootje in het meegegeven g-gedeelte tekent
  }
}

nu nog wat doen met die auto

Java:

//Wat gooien we nu in Color? Een Color.BROWN? Heeft Color soms
//ook attributen die public zijn? Ja, inderdaad.
//Maar waarom hoofdletters? Zijn ze niet echt attributen?
//zo ongeveer, ze kunnen niet veranderd worden. YELLOW, blijft ten alle tijden 
//YELLOW
Color bruin = new Color(Color.BROWN);
Color geel = new Color(Color.YELLOW);

Auto auto = new Auto(bruin);
auto.doeLichtenAan();
//die graphics heb ik voor het gemak al eerder ergens vandaan :P
auto.tekenOpScherm(g);
auto.spuitOver(geel);
auto.tekenOpScherm(g);

Ik hoop dat je nu een beetje een idee krijgt van wat klassen zijn binnen java en hoe je ze moet zien.

Je kan natuurlijk ook weer een Auto[] maken. Of een andere klasse die Auto kent, een Autoarray (Auto[]) laten returnen

[Verwijderd]

Het begint idd al helderder te worden. Er zit in ieder geval logica in . Het zelf produceren van die dingen zit er alleen nog niet geweldig in, maar met wat oefenening moet ook dat lukken. Het is nu duidelijk hoe je een array uit een klasse krijgt, maar wat ik nog steeds niet inzie, is hoe ik een array van buiten af in een klasse krijg .

Glimi schreef op 08 november 2004 @ 18:25:
Nee het probleem is dat je methode zoek de constructor is van je classe zoek en
een constructor maakt een object van het type zoek en kan dus als zodanig geen
String teruggeven. Geef de methode zoek een andere naam en klaar ben je.

Nee dat is het nog niet helemaal. Ik wil graag dat de hele array verstuurd wordt,
niet alleen de inhoud van index nr 2.

code:

public class Zoek{
 
 public String Boekzoek(String[] boekRij, String titel)
{
    for (int t=0; t<boekRij.length; t++)
    {
        if(boekRij[t].equals(titel)){return boekRij[t]+"gevonden";}
    }
    return "Titel "+titel+ " niet gevonden.";
}   
    
}

code:

public Zoek zoekopdracht = new Zoek();
.......// staat nog van alles tussen. Het volgende stuk staat bij een action performed knop code.
boekRij[0]= "blaat1";
boekRij[1]= "blaat2";
titel = uitvoerveld.getText();
String uitvoer = zoekopdracht.zoek(boekRij[],titel); //Dit mag niet! Die lege blokhaken geven een error: Array index required. Vul ik hier bijvoorbeeld het cijfer 1 in, dan krijg ik alsnog een error: Incompatible type for method. Can't convert java.lang.String to java.lang.String[]

Ik zal proberen uit te leggen wat mijn programmatje zou moeten doen.
1. De gebruiker vult een titel in en drukt op submit. In mijn code staat een array vol met boektitels. Deze array moet samen met de ingevoerde titel naar een klasse verhuizen. Hier moet de methode in de klasse bepalen of dat 1 van de titels in de array overeen komt met de ingevoerde titel. Is dit het geval, dan moet hij dat melden, is dat niet het geval, dan moet hij dat eveneens melden. Dit is het laatste stukje dat ik graag wil weten voor mijn toets morgen. We zullen waarschijnlijk een of andere lompe dobbelsteen moeten maken met wat zooi er om heen, maar ik zou het toch graag weten, ondanks dat deze kennis niet vereist is.

[Glimi]

Haal die haken gewoon weg. Je vrariabele heet boekRij en heeft het type String[]. Die blokhaken zijn alleen nodig voor het aangeven van het type of voor het benaderen van een index (die kun je zelfs zien als een easy way voor een get( i ) aanroep )

[Verwijderd]

Glimi schreef op 08 november 2004 @ 21:19:
Haal die haken gewoon weg. Je vrariabele heet boekRij en heeft het type String[]. Die blokhaken zijn alleen nodig voor het aangeven van het type of voor het benaderen van een index (die kun je zelfs zien als een easy way voor een get( i ) aanroep )

THANX dat was de truc. Hij doet het. Als ik het nu nog goed doe op de toets dat moet het goedkomen.

[Verwijderd]

boekzoek moet met een kleine letter beginnen. Is namelijk een methode en geen constructor [/zeurmodes]

[Verwijderd]

Verwijderd schreef op 08 november 2004 @ 21:31:
boekzoek moet met een kleine letter beginnen. Is namelijk een methode en geen constructor [/zeurmodes]

zeurmodes is wel terecht. ik ben begonnen met allemaal kleine letters om de kans te verkleinen dat ik een fout maakte in hoofdletters/kleine letters. Als ik maar 1 van beide aan hield, dan maakte ik daar ten minste geen fouten in.

Even een heel andere vraag. Toen ik java voor het eerst zag werd ik er helemaal gek van. Na 2 regels code had ik al minstens 4 fouten . Meestal waren dat van die dingen als: int test = 1 en 10 regels verder: int test = 2 waardoor java dacht dat het 2 verschillende variables waren. Ik werd niet goed van het aankondigen van variables. Nu is mijn vraag: Is dit nu echt nuttig en heeft dit voordelen tov een andere programmeertaal (bijvoorbeel php snapt uit zich zelf wat je in de variable hebt gestopt.)

[Soultaker]

Het voordeel is dat met declaraties je veel beter statisch kunt typeren. Talen die geen declaraties vereisen (en ze ook niet afleiden, zoals veel functionele talen) zijn bij mijn weten allemaal dynamisch getypeerd (wat betekent dat je er een waarde met een willekeurig type in kunt stoppen).

Als ik je posts in deze thread zo zie, dan denk ik niet dat je hier iets van begrijpt. Als je later Java onder de knie hebt, moet je je deze reactie nog maar eens herlezen. Ga er voorlopig maar van uit dat het in een taal als Java wel degelijk heel nuttig is.

Verder helpt het verplicht declareren je om je code helder te houden. Als je een beetje routine hebt, type je declaraties zonder er bij na te denken en kost het je ook nauwelijks tijd meer.

[ Voor 28% gewijzigd door Soultaker op 08-11-2004 22:49 ]

[Verwijderd]

Verwijderd schreef op 08 november 2004 @ 22:41:
[...]


zeurmodes is wel terecht. ik ben begonnen met allemaal kleine letters om de kans te verkleinen dat ik een fout maakte in hoofdletters/kleine letters. Als ik maar 1 van beide aan hield, dan maakte ik daar ten minste geen fouten in.

Even een heel andere vraag. Toen ik java voor het eerst zag werd ik er helemaal gek van. Na 2 regels code had ik al minstens 4 fouten . Meestal waren dat van die dingen als: int test = 1 en 10 regels verder: int test = 2 waardoor java dacht dat het 2 verschillende variables waren. Ik werd niet goed van het aankondigen van variables. Nu is mijn vraag: Is dit nu echt nuttig en heeft dit voordelen tov een andere programmeertaal (bijvoorbeel php snapt uit zich zelf wat je in de variable hebt gestopt.)

Ja, over een jaar ben je blij dat java daar zo goed in is.

qua namen in java, hij blijft de namen kennen als je ergens dieper ingaat, maar vergeet het als je het blok sluit waarin het was aangemaakt:

Java:

public class Voorbeeld{
   int eersteVariabele;   

   public void eenMethode(){
      int tweeVariabele;
      eersteVariabele = 5; //kan, want is hogerop bekend, dus ook hier
                                        //dit methodeblok valt binnen het klasseblok
      if(iets == iets) {
         int derdeVariabele;
            if(iets == ietsanders){ 
               int vierdeVariabele;
               eersteVariabele = 3; //kan, want is hogerop bekend, dus ook hier.
               derdeVariabele = 55; //kan dus ook(if block valt binnen het hogere ifblock)
            }
         vierdeVariabele  = 235; //FOUT, variabele is bij de eerste beste sluitbracket
                                               //van het niveau waarop hij is aangemaakt vergeten
         }
      derdeVariabele = 23; //dus ook fout, want we zijn ook al uit het if-statement
                                        //waar derdeVariabele in was aangemaakt
   }
}

Dat je moet zeggen dat iets een int is en dat java er niet zelf achterkomt, lijkt misschien wat extra moeite, maar houdt het wel overzichtelijk. Een string en een integer is overigens in weze ook totaal niet hetzelfde.
De voordelen hiervan zul je met de loop der tijd wel ontdekken.

Overigens, als je het goed wilt doen, moet je het commentaar erboven zetten, en niet zoals ik nu heb gedaan, erachter.

[12_0_13]

Het grooste risico is vind ik dit (in C++ in ieder geval, in java gaat het vast ook fout

Java:

class Foo()
{
   public int i;
   void foo()
   {
      int i=6;     //nieuwe i in locale scope, past dus NIET de int i member aan!
   }
}

[Verwijderd]

12_0_13 schreef op 09 november 2004 @ 18:09:
Het grooste risico is vind ik dit (in C++ in ieder geval, in java gaat het vast ook fout

Java:

class Foo()
{
   public int i;
   void foo()
   {
      int i=6;     //nieuwe i in locale scope, past dus NIET de int i member aan!
   }
}

Dat is inderdaad wel griezelig, daarom moet je met naamgeving altijd wel opletten en goed in de gaten hebben wanneer je iets declareert en wanneer je verdergaat met iets.
Als je het echter gewent bent is het soms ook wel weer frustrerend dat in php opeens weer wel die bovenste i daarmee wordt aangepast.

Als je er met een OO-oog en een programmeertechnische achtergrond naar kijkt, dan ik het heel logisch dat de voorbeeldcode werkt zoals het werkt in C++ en java, maar ik kan me wel voorstellen dat je er in het begin wel een keer de fout mee ingaat.

Persoonlijk zou ik dus gek worden als hij dan wel die oorspronkelijke i-member zou aanpassen. In feite is het zichtbaar en onzichtbaar zijn van bepaalde dingen ook een kracht van OO. Je weet immers vrij zeker dat jouw code niet gaat lopen 'kutten' met code van een ander in hetzelfde project.

[Verwijderd]

12_0_13 schreef op 09 november 2004 @ 18:09:
Het grooste risico is vind ik dit (in C++ in ieder geval, in java gaat het vast ook fout

Java:

class Foo()
{
   public int i;
   void foo()
   {
      int i=6;     //nieuwe i in locale scope, past dus NIET de int i member aan!
   }
}

Dit is makkelijk op te lossen door de globale variabelen te laten beginnen met een underscore. Zo zie je overal met wat voor variabelen je bezig bent

[Verwijderd]

Verwijderd schreef op 09 november 2004 @ 19:14:
[...]


Dit is makkelijk op te lossen door de globale variabelen te laten beginnen met een underscore. Zo zie je overal met wat voor variabelen je bezig bent

Dat maakt het geheel wel overzichtelijker, maar dat belet je nog steeds om heel stom weer int voor de _i te typen terwijl dat dus eigenlijk niet de bedoeling was.

[Macros]

Gebruik gewoon een IDE die fields blauw maakt en de andere variabelen zwart. (bv. Eclipse)