Stap 3: Object Oriented Programming-Primer - klassen en objecten
Functies in een notendop:
Een functie is in wezen een stuk van de code die u meerdere keren kunt hergebruiken. Afbreken van een complexe schets in kleinere functies zorgen voor leesbaarheid (de code is beter leesbaar, omdat alle complexe code krijgt geabstraheerde; makkelijker te debuggen in dit stadium), modulariteit (verandert de code in modulaire stukken, zoals legos), en voorkomt dat de code van het krijgen van droog (droog staat voor Don't Repeat Yourself; herhalende middelen handmatig kopiëren/plakken code meerdere keren).
Hier is de algemene structuur van een functie:
data_type_of_returned_value"'void' als deze methode retourneert nothing"functionName(parameters) {}
de functie-definitie
}
Laten we een functie waarin onze kring, en een andere functie voor de beweging (dat is, jiggling) te implementeren:
float x = 200;
float y = 200;
VOID Setup {}
size(400,400);
Smooth();
}
VOID draw() {}
Background(255);
display (); het aanroepen van een functie
Move(); de tweede functie
}
de functies
VOID display () {}
noStroke();
Fill(140);
Ellipse(x,y,80,80);
}
VOID move() {}
x = x + random(-5,5);
y = y + random(-5,5);
}
Hoewel de code precies hetzelfde doet als voorheen, kijk hoe georganiseerd de draw() lus is nu! Merk op hoe ik "genaamd" of "ingeroepen" de respectieve functies uit binnen de lus draw().
Functies kunnen "parameters" te hebben. Parameters zijn "plaats-houders" voor waarden die u "doorgeven kunt" aan een functie. Na ontvangst van de waarden, kan de functie berekenen ze in overeenstemming met hoe u deze hebt gedefinieerd. Bijvoorbeeld, is hier een functie die uit twee parameters (x en y) haalt, en gebruikt de doorgegeven argumenten om te renderen van deze rare vorm:
VOID drawShape (float x, y float) {}
noStroke();
Fill(140);
Ellipse(x,y,80,80);
Ellipse(x-151,y+2,44,44);
Fill(68,234,66);
rect(x-131,y-5,92,18);
}
Zie afbeelding hierboven (eerste afbeelding).
In de bovenstaande functie, gebruikten we x en y als verwijst naar, en stel de parameters voor alle andere vormen "relatieve" aan x en y. Deze techniek heet "relatieve positionering". Bijvoorbeeld, als referentie x 400, en de x-waarde van sommige vorm 89, dan de positie van die shape ten opzichte van de referentie x is "x-311" (400-89 = 311).
Functies kunnen ook "return" waarden, maar dat is voor een andere dag!
Een Object en de klasse verhaal:
Zoals we hebben gezien een tijdje geleden, brengen functies over een zekere mate van organisatie naar onze code. Gebruik makend van objecten in onze code is echter een veel efficiëntere organisatie strategie.
Een object in wezen met elkaar verbindt gegevens (variabelen) en functionality(functions) van een bepaalde entiteit in een nette pakket. Om objecten te maken, moeten we een blue-print voor het. Dit heet de klasse.
In plaats van het brabbelen over een meer complexe concepten, laten we een klasse voor het genereren van jiggly cirkel objecten te maken:
klasse Circle {}
klassevariabelen (ook wel instantievariabelen)
float x;
float y;
float d;
kleur c;
de constructor van het object
Cirkel (float x, y drijven, zweven d, kleur c) {}
this.x = x;
this.y = y;
this.d = d;
this.c = c;
}
de methoden
VOID display () {}
noStroke();
Fill(c);
Ellipse(this.x,this.y,this.d,this.d);
}
ongeldig jiggle() {}
this.x = this.x + random(-2,2);
this.y = this.y + random(-2,2);
}
}
Dingen op te merken:
- Er is dit bizarre ding in de code de "constructor" genoemd. De constructor is de functie die eigenlijk een object, in combinatie met het sleutelwoord "new" (meer hierover in een beetje maakt). De constructor definitie moet code over hoe te bouwen objecten bevatten. De constructor-naam moet hetzelfde zijn als de klassenaam.
- het "dit" sleutelwoord wordt gebruikt om naar variabelen de behoort tot de klasse, en alleen de klasse! U kunt zien dat ik dezelfde variabele namen voor de klassevariabelen en de parameters van de constructor gebruikt heb. Met behulp van "deze", toestaan ik verwerking onderscheid maken tussen de twee. Vandaar, "this.x = x" geeft aan: de waarde doorgegeven aan x terwijl u het object in "this.x", de klasse variabele opslaan.
- De dezelfde functies die we hebben gezien voordat in de klasse wordt gebruikt. Een functie die is gekoppeld aan een klasse wordt een "methode" genoemd.
Het is een goede gewoonte om te houden van uw klassen in een apart bestand opslaan, zodat uw belangrijkste code ziet er netjes. U kunt dit doen door het creëren van een tweede tabblad op de bewerkingsomgeving. Opmerking, het tabblad de naam moet dezelfde zijn als die van de klasse. (zie afbeelding hierboven; ten derde foto).
Met behulp van de klasse voorwerpen te maken:
objecten declareren
Cirkel c;
Circle d;
VOID Setup {}
size(400,400);
Smooth();
objecten initialiseren
c = nieuwe Circle(200,200,80,color(100));
d = nieuwe Circle(344,355,20,color(62,177,137));
}
VOID draw() {}
Background(255);
met behulp van objecten
c.display();
c.jiggle();
d.display();
d.jiggle();
}
Zie uitkomst boven (tweede foto).
Objecten declareren - terwijl objecten te verklaren, is het gemakkelijker om te overwegen de klasse als een nieuw gegevenstype. Dus, betekent "Cirkel c" declareert u een variabele "c" soort "Circle" (vergelijk met "int c").
Initialiseren van objecten - Zie hoe we de constructor via het sleutelwoord "new" ingeroepen? Aangezien de definitie van de constructor cirkel had parameters, moeten wij argumenten om te initialiseren van het object doorgeven. Deze argumenten zijn toegewezen aan het object variabelen (x, y, c enz.). Daardoor kunnen we de dezelfde klasse gebruiken om objecten te maken met verschillende eigenschappen. In het bovenstaande voorbeeld verschillen cirkels c en d van elkaar in grootte en kleur.
U ziet ook dat de objecten worden geïnitialiseerd op Setup. Dat is logisch, want wij niet de intentie hebben van hetzelfde object over en weer in draw() initialiseren.
Met behulp van objecten - We gebruik maken van de dot "." exploitant tot methoden van het object, zoals hierboven gezien.
