De komende twee weken zijn 'seksweken' op Scholieren.com. Samen met de Sense Infolijn geven we antwoord op al jouw seksvragen.

 


Alles over seks Alles over seks


ADVERTENTIE
Geslaagd? Doneer je verslagen We zijn heel trots op je, supergoed gedaan. Waarschijnlijk ga je Scholieren.com nu voorgoed verlaten. Wil je ons nog bedanken voor 4, 5 of 6 jaar trouwe dienst? Upload dan nu al je verslagen en samenvattingen voor de generaties scholieren die na jou strijden voor dat diploma.

Nu uploaden
informatica samenvatting. hst3:
algoritme:Een beschrijving van stappen die gedaan moeten worden om een probleem op te lossen.bv.kookrecept.Bij grote algoritmes delen in deelalgoritmes. dit heten:procedures
computerprogramma:Als algoritme zo is beschreven dat een computer hem kan uitvoeren.
programmeren: 1. beschrijving van stappen die gedaan moeten worden(algoritme)
2. Algoritme omzetten in computertaal(programmeren)
Het schrijven van opdrachten in programmeertaal is laatste deel van programmeren.
Eerst moet programmeur oplossing voor probleem bedenken.*Speciaal schema:psd*
Er zijn drie basisstructuren: 1.opeenvolging(sequentie) 2.keuze 3.herhaling
in een psd worden de deze structuren zo weergeven:
sequentie keuze herhaling
Stap 1
Stap2
Stap3
schrijven computerprogramma:
1. beschrijving van het probleem
2.oplossing van het probleem. Planning, info verzamelen, probleem uitwerken in schema.
3.programma in programmeertaal schrijven.
4.programma testen of hij het verwachte resultaat oplevert.

--3.2
Er zijn verschillende talen waarin je kan programmeren->Java.
Moderne programma’s hebben user-interface met menu’s, knoppen enzovoorts. Voor het schrijven van een simpele user-interface moet er al voor programmacode worden ingetypt.Daarom zijn er geïntergreerde ontwikkelomgevingen(IDE:Intergrated Development Environment)op de markt gevracht, die het werk van programmeur verlichten. Wij gebruiken IDE: Visual Cafe for JAVA. Dit is een editor, interface-ontwerpprogramma,projectmanager en interpreter ineen. toekenning/assignment =naam. expressie(andere kant van =) waarde van variabele. variabelen=geheugenplaatsen. reserved words=int en while
declaratie=geven van een naam en type aan variabele.
double=decimale getallen
int=hele getallen
string=tekst
boolean=true of false
Rente applet: event-handler voor berekenKnop:
int beginkapitaal;
beginkapitaal = Integer.parseInt(beginkapitaalVeld.getText());
int rente;
rente = Integer.parseInt(renteVeld.getText());
int termijnen;
termijnen = Integer.parseInt(termijnenVeld.getText());
int kapitaal;
kapitaal = beginkapitaal;
int termijn;
termijn = 1;
while(termijn >=termijnen)
{
kapitaal = kapitaal + kapitaal * rente/100l
termijn = termijn + 1;
}
eindkapitaalVeld.setText(String.valueOf(kapitaal));

kapitaal = kapitaal + kapitaal * rente/100;
aan de rechterkant staat een expressie waarin verschillende operaties voorkomen. operaties: delen,optellen enz.
Operaties werken op operanden: hier 100 en variabelen kapitaal en rente
bij de toekenning aan de variabele kapitaal wordt eerst een expressie aan de rechterkant uitgerekend. Daarbij gebruik van oude waarde van kapitaal.Het resultaat van berekening wordt daarna toegekend aan de variabele kapitaal.
Herhaling met while:kapitaal + kapitaal * rente/100 staat in de herhalingslus
while(termijn <= termijnen)
{
kapitaal = kapitaal +kapitaal * rente/100;
termijn = termijn + 1;
}
while(zolang) geeft begin van lus aan.
While-opdracht heeft vorm: while(voorwaarde) [opdracht of opdrachten]
voorwaarde tussen de haakjes is een expressie. dit kan maar twee waarden aannemen. true/false. dit heet ook wel een logische expressie.als resultaat true is worden de opdrachten nogmaals uitgevoerd. anders lus beëindigd.
methode-oproep:
beginkapitaal = Integer.parseInt(beginkapitaalVeld.getText());
tweede methode-oproepen. Integer.parseInt(….); en beginkapitaalVeld.getText());
een methode-oproep heeft altijd volgende vorm: methode(argumenten)
Er zijn ook methodes die geen resultaat opleveren en dus niet in expressie kunnen voorkomen. Een aanroep van zo’n methode is setText(…) in eindkapitaalVeld.setText(String.valueOf(kapitaal));
conversie:omzetten van int naar string etc. Methode. omzetten van ene type naar andere type.
statements:opdrachten.
elementaire statements: declaratie: int beginkapitaal; en toekenning termijn =termijn +1 altijd afsluiten met ;
ook de while-opdracht is een statement, maar wel een samengesteld statement.
relationele operatoren:
groter dan <=kleiner dan of gelijk aan
>=groter dan of gelijk aan == is gelijk aan !=ongelijk aan
rente applet anders geschreven:
twee belangrijkste verschillen:
declaratie en toekenning in 1 statement:int termijn = 1;
for-statement ipv while-statement: for(int termijn =1; termijn <=termijnen; termijn++)
{
kapitaal = kapitaal + kapitaal * rente/100;
}
het deel tussen de ronde haakjes heeft drie onderdelen:
1. initialisatie: deze word gebruikt om variabele, die wel stuurvariabele van for-statement genoemd word, een beginwaarde te geven. 2. logische depressie: zolang antwoord true is word opdrachten uitgevoerd.
3.stapopdracht, statement termijn++ verhoogd termijn met 1.
decimale getallen omzetten naar binaire getallen.
int decGetal = Integer.parseInt(decimaalGetalVeld.getText());
String resultaat =””;
do
{
if(decGetal % 2==0)
resultaat =”0” + resultaat;
else
{
resultaat =”1” + resultaat;
decGetal--;
}
decGetal=decGetal/2;
}
while(decGetal > 0);
binairGetalVeld.setText(resultaat);
---
een do-while-statement heeft altijd volgende vorm: do{opdracht} while (voorwaarde);
twee verschillen met while-statement: - opdrachten tussen acclades word minstens 1x uitgevoerd.
- het berekenen van voorwaarde vind aan eind plaats
if-else-statement
tijdens de verweking van concersieApplet word keuze gemaakt. met if-else-statement. net als while-statement is dit een samengesteld statement. heeft deze vorm: if(logische expressie) opdracht1 else opdracht2

HST 8

objectgeoriënteerd programmeren
programmeerparadigma: methoden om computerprogramma te structurerenjava: objectgeoriënteerde paradigma.
objecten: -kunnen bewerkingen ondergaan -hebben eigenschappen
klassen: het model waarnaar alles gemaakt wordt. het object dat gemaakt word op grond van klasse heet de instantie van die klasse.
klasse dobbelsteen: drie dobbelstenen zijn e instantie van de klasse dobbelsteen.
constructor: zorgt voor het construeren van een object en initialisatie van de velden.
data-hiding:bij een objectgeorïenteerd programma de velden te verbergen voor buitenwerled. Dit verkleint de kans op oneigenlijk gebruik van de velden.
public:toegankelijk private; alleen methode binnen klasse kan aangeroepen worden,
pachage: alleen de klassen binnen deze package hebben toegang. voor de naam van de methode dobbel staat als resultaattype het woord void. Dit betekent leeg. Dat wilt zeggen dat deze methode geen resultaat heeft. maar wel effect, namelijk het wijzigen van veld worp.
return-statement: wanneer een methode een waarde moet teruggeven dan moet in de body van de methode staan welke waarde dat is.: return expressie;
expressie kan een getal zijn, een variabele, een berekening, een aanroep van een methode of combinatie hiervan. het resultaat van expressie moet een juiste type zijn, zoals gespecialiseerd in declaratie van methode, het resultaattype. verder zorgt hij voor dat de uitvoering van methode word beëindigd. dat opdrachten die na return-statement nooit uitgevoerd worden.

8.2

overerving(inheritance)=belangrijk kenmerk van objectoriëntatie. klasse kan hierdoor worden gedefinieerd als een uitbreiding van bestaande klassen. de nieuwe klasse die op die manier ontworpen word, erft alle velden en methoden en kan er nieuwe aan toevoegen.
overriding= applet kent al mothode init, deze methode word vervangen door de methode init van dobbelapplet.(vervangen dus)
dobbelsteen dsteen = new Dobbelsteen(); hier word een instantie van een klasse dobbelsteen gedeclareerd en gecreëerd.

8.3

variabelen=voorstellen als een doos met buitenkant een naam. in de doos zit ene waarde, die kan door programma gewijzigd worden, maar de naam niet. een variabele heeft een type, die bepaald welke waarden de variabele kan aannemen en welke operaties er kunnen worden uitgevoerd.
Java kent twee variabelen:
- variabelen die naar een object verwijzen: dergelijke variabelen worden referenties genoemd. De doos bevat dus niet het object zelf maar de verwijzing van de plek in het geheugen waar het object zich bevind.(vb.button, textfield)
-primitieve typen: byte, short, int, long, lfloat, double, char en boolean. Variabelen van dat type verwijzen niet naar object. de doos bevat de waarde zelf. primitieve getallen hebben geen velden, geen methode en hoeven niet met opdracht new gecreëerd worden.
numerieke variabelen.
int: dit type : hele getallen. daarvoor worden 32 bits gereserveerd om een waarde van dit type op te slaan. behalve het type int kent java ook nog de type byte, short, en long voor gehele getallen, het bereik verschilt.
double en float= voor het opslaan van reële getallen kent java het type double. een reëel getal noteer je in Java met ene decimaal punt. een waarde van het type double word opgeslagen in 64 bits. float: deze waarde worden in 32 bits opgeslagen. double kan grotere getalleen presenteren en is nauwkeuriger.
rekenkundige operatoren: voor het werken met numerieke variabelen kent java deze operatoren:
+ optellen - aftrekken *vermenigvuldigen /delen % rest
conversie van numerieke variabelen problemen.
hier niet: int x,y;
x = 10;
Y=20;
double r;
r=x+y;
in statement r=x+y komen twee tpe voor, maar java kan die zonder problemen converteren. de int-waarde van resultaat word geconverteerd naar double=inpliciete conversie
dit geeft wel probleem: double x,y;
x=1.5;
y=2.7
int g;
g=x+y;
wanneer er toch een conversie moet komen kan dat met behulp van expliciete conversie. dit word casting genoemd. om een expressie naar een bepaalde type en converteren schrijven we de typenaam tussen haakjes voor de expressie: (typenaam) expressie
hier dus getal van type double naar int: g x+y. door het woord int tussen haakjes voor de expressie te zetten, geef je java de opdracht om x + y te converteren naar int.
boolean: kan maar twee waarden hebben: true of false.
logische operatoren &&, || en ! het resultaat van een expressie met logische operatoren is van het type boolean.
in expressie x && y is het resultaat alleen true als zowel x als y true is.&&-operator = logische ^
x y X&&y
false false false
True False false
False True False
True true True
de ||-operator is de logische OF. in de expressie x || y is het resultaat true als x of y true is of beide true.
x y X || y
false false false
True False true
False True true
True true True
de !-operator is de llogische NOT. in de expressie !x is het resultaat true als x false is en is het resultaat false als x true is.
x !x
true false
false true
------------------------
Strings=rijen tekens. hiervoor kent java klasse String. 2021 en alan turing is een string. het feit dat string geen primitief type is maar een instante van de klasse String, maakt dat het werken met strings anders is dan het werken met een variabele van bv. int.
oorzaak: iedere klasse is een referentietype. de ==operator vergelijkt alleen de referenties, en niet de objecten zelf. om te controleren of twee strings de zelfde inhoud hebben kan je dus niet de == gebruiken, twee instanties van de klasse string kun je wel inhoudelijk vergelijken met de methode equals() deze methode geeft als resultaat een boolean-waarde: if(x.equals(y))
creëren van strings: door string-constructor aanroepen.
string naam=new String)”ikke”);
we hebben in het eerste deel gezien dat ook een directe toekenning mogelijk is:
String naam = “ikke”;
bijde statements werken.
concaternatie van strings=twee strings aan elkaar geplakt met + teken. ook mogelijk om zo getallen en namen aan elkaar te plakken.
Conversie van en naar string:
om een getal naar een string te converteren kent de klasse String de methode valueOf(). deze moethode kan als argument een variabele van het type int hebben maar ook van het type double. het resultaat is van het type String. valueOf gebruik je. voor conversie naar string. van string naar int: parseInt() van string naar double:parseDouble()
int g=1234;
double r=12.34;
String sg=String.valueOf(g);
String sr=String.valueOf(r);
uitvoerVeld.setText(sg+” “+ sr);
klasse string
compareTo(tekst)
vergelijk twee strings, wanneer het argument gelijk is aan de string, geeft deze methode een waarde o terug. wanneer de string groter is dan het argument geeft deze methode een waarde groter dan 0 terug en wanneer de string kleiner is dan het argument, geeft deze methode een waarde kleiner dan 0 terug.
equals(tekst)
vergelijkt twee strings. wanneer het argument gelijk is aan de string, geeft deze methode een boolean-waarde true terug, anders een false.
length()
bepaalt aantal tekens van string
replace(beginindex, eindindex)
vervangt een bepaald teken vervangen door een ander teken.
substring(beginindex
levert een nieuwe stirng op die een deel is van de oorspronkelijke string. het argument beginindex geeft positie in ed string aan dwaar de substring moet beginnen, eindindex geeft eind substring aan.
toLoverCase()
tekens in een string worden omgezet in kleine

REACTIES

Log in om een reactie te plaatsen of maak een profiel aan.