Deel 1 : Basisprincipes van objectoriëntatie



Dovnload 74.98 Kb.
Datum27.08.2016
Grootte74.98 Kb.
Deel 1 : Basisprincipes van objectoriëntatie

HFST 1



  • een instantie = een bepaald object

  • namen van klassen  hoofdletter

  • namen van objecten  kleine letter

  • parameters = de extra waarden die bij sommige methodes ingevoerd moeten worden

  • een type geeft aan welke soort gegevens geschikt zijn als paramters

HFST 2



  • public class Naamvandeklasse

{

}



  • de inhoud van een klasse samengevat:

  1. de velden bevatten gegevens die het object moet gebruiken

  2. met de constructors kan een object op de juiste manier worden ingesteld op het moment dat het wordt aangemaakt

  3. met de methodes wordt het gedrag van de objecten geïmplimenteerd

  • een formele parameter is alleen beschikbaar voor een object binnen de body van een constructor of methode die deze declareert. Het bereik van een parameter is beperkt tot de body van de constructor of methode waarin deze wordt gedeclareerd.

  • Het bereik van een veld daarentegen is de hele klassedefinitie

  • De levensduur van een parameter is beperkt tot 1 aanroep van een constructor of methode

De levensduur van een veld daarentegen is gelijk aan de levensduur van het object waartoe het behoort

  • het is een absolute regel in Java dat een constructor geen returntype mag hebben

  • accessor = een methode die informatie over de toestand van een object teruggeeft

  • mutator = een methode die de toestand van een object verandert

  • conditioneel statement :

if (voer een test uit die alleen waar of niet waar uitkomt)

{

voer statements uit als resultaat waar was



}

else


{

voer deze statements uit als resultaat niet waar was

}


  • net als formele parameters hebben lokale variabelen een bereik dat beperkt is tot de statements van de methode waartoe ze behoren

  • kenmerken van variabelen: (velden, formele en lokale)

  1. alle 3 variabelen kunnen een waarde opslaan die overeenkomt met het voor hen gedefinieerde type

  2. velden worden buiten constructors en methodes gedefiniëerd

  3. velden worden gebruikt om gegevens op te slaan die gedurende de hele levensduur van een object bestaan. Op die manier beschrijven ze de huidige toestand van een object.

  4. Velden werken klassebreed; ze zijn benaderbaar vanuit de hele klasse en kunnen dus worden gebruikt binnen alle constructors en methodes van de klasse waarin ze gedefinieerd zijn.

  5. Zolang ze als private gedefinieerd zijn, kunnen velden niet van buiten de klasse waarin ze gedefinieerd zijn benaderd worden.

  6. Formele parameters en lokale variabelen bestaan alleen tijdens de periode dat een constructor of methode wordt uitgevoerd.

  7. Formele parameters worden gedefinieerd in de header van een constructor of methode. Ze krijgen hun waarde van buitenaf en worden geïnitialiseerd door de actuele parameterwaarden die een onderdeel zijn van de constructor of methode-aanroep.

  8. Formele parameters hebben een bereik dat beperkt is tot het bereik van de constructor of de methode waarin ze gedefinieerd wordt.

  9. Lokale variabelen worden gedefinieerd binnen de body van een constructor of methode. Ze kunnen alleen binnen de body van de constructor of methode gebruikt en geïnitialiseerd worden. Lokale variabelen moeten geïnitialiseerd worden voordat ze in een expressie worden gebruikt; ze hebben dus geen standaardwaarden.

  10. Lokale variabelen hebben een bereik dat beperkt is tot het blok waarin ze gedefinieerd zijn. Ze kunnen niet van buiten dat blok benaderd worden.

HFST 3



  • Java kent 2 sterk verschillende types:

    1. primitieve types: worden vooraf gedefinieerd in Java (opgeslaan in een variabele)

    2. objecttypes: worden gedefinieerd door klassen (opgeslaan in een verwijzing naar een object)

  • logische operatoren:

= gebruiken de boolean waarden als argument en produceren een nieuwe boolean waarde als resultaat.

en &&


of ||

niet !


  • integer convergeren in een String:

“” + getal

  • de syntax van een externe methode-aanroep:

object.methodenaam ( parameters );

  • de syntax van een interne methode-aanroep:

methodenaam ( parameter );
HFST 4


  • gebruiken van een Arraylist:

import java.util.ArrayList

{

private ArrayList … ;



{

a = new ArrayList () ;



}

{



a.add( a );

}

// we willen de grootte weten



{

return a.size ();

}

//we willen er eentje zien (welke)



{

System.out.println ( a.get( welke ) );

}


  • 3 belangrijke kenmerken van een ArrayList

  1. de klasse kan de interne capaciteit op verzoek aanpassen: wanneer er items aan toegevoegd worden maakt de klasse er gewoon ruimte voor

  2. de klasse houdt een eigen teller van het huidige aantal opgeslagen items. De methode size () retourneert het aantal opgeslagen objecten.

  3. De klasse houdt ook de volgorde van de opgeslagen items bij. Je kunt ze later in dezelfde volgorde ophalen.

  • om iets te verwijderen uit een ArrayList

a.remove ( index );

 de indexnummers van de overgebleven items verschuiven met 1 eenheid



  • while – lus

while ( loop conditie )

{

loop body;



}

  • een Iterator gebruiken

import java.util.Iterator;

// toont alle objecten uit de ArrayList



{

Iterator = a.iterator ();

while (it.hasNext () )

{

System.out.println ( it.next () );



}

}


  • het begrip null is een speciale waarde in Java met de betekenis ‘geen object’

  • Casten:

Een cast bestaat uit de naam van een type die tussen een paar haakjes geschreven wordt.

Casten wordt veel gebruikt wanneer objecten uit een collectie worden opgehaald. Casten is noodzakelijk omdat het mogelijk is om elk type in een collectie op te slaan. We moeten de compiler dus duidelijk maken welk type object we ophalen.



  • collectie met een vaste omvang : Array

hoewel de onveranderlijke omvang van arrays in veel situaties een belangrijk nadeel is, hebben ze tenminste 2 voordelen t.o.v. collectieklassen met een veranderlijke omvang:

  1. het benaderen van items in een array is vaak efficiënter dan het benaderen van items in een vergelijkbare collectie met veranderlijke omvang

  2. arrays kunnen objecten of waarden van het primitieve type bevatten. Collecties met veranderlijke omvang kunnen alleen objecten bevatten

  • gebruik van Arrays

private int [] a;

{

a = new int [ getal ];



}

// de lengte bepalen

{

return a.length;



}

  • for – lus

met name handig als

    1. we enkele statements een bepaald aanteel keer willen uitvoeren

    2. we een variabele binnen de lus nodig hebben waarvan de waarde steeds een regelmatig aantal verandert (meestal + 1)

for ( initialisering; conditie; actie na de body)

{

te herhalen statements;



}
HFST 5


  • String:

trim () doet spaties aan begin en einde weg

length () geeft lengte terug

toLowerCase () zet alles in kleine letters om

equals () vergelijkt

startsWith () begint met…


  • de klasse Random ()

import java.util.Random ;

Random rg ;

rg = new Random ;

int getal = rg.nextInt (eventueel een maximum);



  • public vs. private

    1. public geeft aan dat een constructie van een klasse, veld of methode voor iedereen zichtbaar is (= een onderdeel van de interface is)

    2. private geeft aan dat het niet zichtbaar is van buitenaf (=een onderdeel van de implementatie is)

  • het begrip static

      1. met het begrip static worden klassevariabelen in Java gedefinieerd. Klassevariabelen zijn velden die opgeslagen zijn in een klasse zelf en niet in een object

      2. klassevariabelen worden vaak gebruikt als een waarde altijd voor alle instanties van een klasse gelijk moet zijn

  • constanten

    1. het begrip static word vaak gebruikt voor het definiëren van constanten. In Java worden deze gedefinieerd met het begrip final:

private final int a = …;

    1. als een waarde niet mag veranderen is het een goed ideee om deze final te declareren. Daardoor wordt het onmogelijk om de waarde achteraf te veranderen. Elke poging om een veld met een constante te veranderen zal resulteren in een foutmelding bij het compileren.

  • in de praktijk komt het vaak voor dat constanten in alle instanties van een klasse gelden. In dat geval declareren we klasseconstanten als volgt

private static final int a = …;
HFST 6


  • elke afzonderlijke methode kan, zodra die geschreven en gecompileerd is getest worden

  • belangrijk bij het testen is om ervoor te zorgen dat de begrenzingen worden gecontroleerd

  • bij een regressietest wordt een test die eerder met succes werd uitgevoerd, opnieuw uitgevoerd om er zeker van te zijn dat de nieuwe versie ook met succes kan werken.

HFST 7



  • afhankelijkheid = de onderlinge verbondenheid van klassen (we streven naar een zwakke afhankelijkheid).

  • Cohesie = het aantal en de diversiteit van de taken waarvoor 1 afgebakend stuk van een toepassing verantwoordelijk is

  • Dupliceren van code is een kenmerk van een slecht ontwerp

  • Inkapselingsregel (de informatie over de implementatie verbergen) stelt dat alleen informatie over wat een klassse kan doen, zichtbaar moet zijn en niet hoe ze dit doet.

  • Ontwerpen op basis van verantwoordelijkheid: elke klasse moet zorgen voor de verwerking van de eigen gegevens.

  • We proberen een klasseontwerp te maken dat later gemakkelijk gewijzigd kan worden omdat de effecten van de wijziging goed te traceren zijn.

  • Slecht: impliciete afhankelijkheid is een situatie waarbij een klasse afhankelijk is van interne informatie van een andere klasse, maar waarbij deze afhankelijkheid niet meteen duidelijk is.

  • Waneer we het hebben over cohesie van methodes proberen we de ideale situatie te bereiken dat een methode verantwoordelijk is voor exact 1 goed omschreven taak.

  • Voordelen van cohesie:

        1. betere leesbaarheid

        2. mogelijkheid tot hergebruik

  • herschikken is de activiteit waarmee de structuur van bestaande klassen en methodes worden aangepast om ze te kunnen gebruiken wanneer de toepassing gewijzigd of uitgebreid worden.

  1. eerst wordt de toepassing herschikt zodat deze dezelfde functionaliteit heeft als de oorspronkelijke versie. Zodra we deze stap voltooid hebben, moeten we de regressietest uitvoeren om te kijken of we geen onbedoelde fouten geïntroduceerd hebben.

  2. Daarna (alleen als zeker is dat de functionaliteit van de eerste versie = functionaliteit van de tweede versie) verbeteren we het programma. Daarna testen we opnieuw.

 een methode is te lang als deze meer dan 1 logische taak uitvoert

 een klasse is te complex als deze meer dan 1 logische entiteit vormt

TOEPASSINGEN ZONDER BLUEJ


      • klasse methodes ( static methodes )

  • kunnen aangeroepen worden zonder instantie, alleen de klasse volstaat

  • een klassemethode word gedefinieerd door het begrip static voor de typenaam in het argument van de methode te plaatesen

bv. public static int aantaldagen ( ) { … }

  • zo’n methode kan worden aangeroepen door de naam van de klasse waarin deze gedefinieerd is te specifiëren voor het punt

bv. int days = Calendar.aantaldagen () ;

      • de methode main

  • in eerste instantie hebben we alleen klassen, dus de eerste methode die we toe kunnen passen moet een klassemethode zij: je specifiëert de klasse die gestart moet worden en Java zal dan een methode in die klasse aanroepen met de naam main

  • beperkingen van klassemethodes:

  1. een klassemethode mag geen instantievelden benaderen die gedefinieerd zijn in de klasse

  2. een klassemethode mag geen instantiemethode van de klasse aanroepen

bv. public static void main ( String [] args )

{

Game game = new Game ();



Game.start ();

}

Deel 2 : De structuur van toepassingen



HFST 8


  • overerving is een mechanisme waarmee we ons probleem van de gedupliceerde code kunnen oplossen.

  • Overerving is soms ook een ‘is een’-relatie genoemd, een subklasse is immers een specialisatie van de superklasse.

  • Het is mogelijk om meer dan 2 subklassen te laten erven van dezelfde superklasse en een subklasse kan op zijn beurt weer een superklasse zijn voor andere subklassen. De klassen vormen dan een overervingshiërarchie.

  • Overerving in Java

 public class Subklasse extends Superklasse

 het begrip super is een aanroep van de constructor van de superklasse

in Java moet een constructor van een subklasse altijd de constructor van de bijbehorende superklasse als eerste statement aanroep

als je deze aanroep van de constructor van de superklasse niet expliciet schrijft, zal de Java-compiler zo’n aanroep automatisch proberen in te voegen om er voor te zorgen dat de velden van de superklasse correct geïnitialiseerd worden. Het automatisch invoegen van deze aanroep zal alleen lukken als de superklasse een constructor zonder parameters heeft.



  • voordelen van overerving

  1. voorkomen van gedupliceerde code

  2. hergebruik van code

  3. gemakkelijk onderhoud

  4. uitbreidbaarheid

  • substitutie  we kunnen een subklasse object gebruiken waar een superklasse object verwacht worden, omdat het subklasse object een speciale uitvoering van de superklasse is. Maar omgekeerd is dit niet toegestaan.

  • Hoewel we een expliciete superklasse kunnen declareren, even alle klassen waarvoor geen superklasse gedeclareerd is, altijd impliciet van een klasse met de naam Object

  • Reden voor een superklasse voor alle objecten:

  1. de klasse Object kan methodes definiëren die dan automatisch beschikbaar zijn voor elk bestaand object

  2. we kunnen polymorfe variabelen declareren van het type object die een willekeurig object kunnen bevatten

  • Java-collecties  polymorfe collecties (ze kunnen gelijktijdig verschillende soorten constructies bevatten)

  • We kennen in Java primitieve types (int, boolean, char …) die geen objecttypes zijn. De oplossing zijn wrapperklassen: elk primitieve type in Java heeft een bijbehorende wrapperklasse die hetzelfde type representeert, maar een echt objecttype is

Bv. voor int  Integer
HFST 9


  • een subklasse erft de informatie van de superklasse, maar deze heeft geen kennis van de subklasse

  • we noemen het gedeclareerd type van de variabele het statische type, omdat het gedeclareerd is in de broncode

  • we noemen het type van het object dat opgeslagen is in een variabele het dynamische type, omdat het afhankelijk is van de toekenningen tijdens de uitvoering van het programma

  • in tegenstelling tot de super-aanroepen in constructors moet de naam van de methode van de superklasse expliciet geschreven worden

super.methodenaam ( eventule parameter );

  • in tegenstelling tot de super-aanroepen in de constructor moet de aanroep niet het eerste statement zijn

  • in tegenstelling tot de super-aanroepen in de constructor wordt een super-aanroep in methodes niet automatisch gegenereerd en zijn deze optioneel

  • de methode toString () wordt gebruikt om van een object een stringrepresentatie te maken.

HFST 10



  • je herkent een abstracte methode aan

  1. de definitie van de methode wordt voorafgegaan door abstract

  2. de definitie van de methode heeft geen body (de header wordt afgesloten met een puntkomma)

  • van abstracte klassen kunnen geen instanties worden gemaakt

  • alleen abstracte klassen kunnen abstracte methodes hebben; daardoor kunnen alle methodes in concrete klassen altijd uitgevoerd worden. Als we een abstracte methode in een concrete klasse zouden toestaan, zouden we een instantie van een klasse kunnen maken zonder een implimentatie voor een methode

  • abstracte klassen met abstracte methodes zorgen ervoor dat subklassen de abstracte methodes overschrijven en implimenteren. Als een subklasse geen implimentatie voor een geërfde abstracte methode heeft, is deze zelf abstract en kunnen er geen instanties gemaakt worden. Een subklasse is alleen concreet als deze implimentatiees bevat voor alle geërfde abstracte methodes

  • doel van abstracte methodes = hoewel ze geen implimentatie leveren, garanderen ze toch dat alle subklassen een implimentatie van deze methode hebben

  • meervoudige overerving bestaat in gevallen waarbij 1 klasse van meer dan 1 superklasse erft. De subklasse heeft dan alle kenmerken van de superklassen plus de kenmerken die gedefinieerd zijn in de subklasse zelf

  • in Java is meervoudige overerving niet toegestaan, maar men heeft wel interfaces, waarmee een zekere vorm van meervoudige overerving mogelijk is:

 de methodes van interfaces hebben geen body ( ze lijken dus erg op abstracte klassen waarin alle methodes abstract zijn)

 public interface Naam { … }

 alle methodes in een interface zijn abstract;; de methodes mogen geen body hebben, het begrip abstract is NIET nodig

 de zichtbaarheid moet niet gedeclareerd worden (= het begrip public moet niet voor elke methode gedeclareerd worden)

 een interface mag alleen velden hebben als waarde van een constante; de begrippen public, static en final mogen weggelaten worden.

 een klasse kan van een interface op dezelfde manier erven als van een andere klasse, Java gebruikt het begrip implements voor overervende intercaces

 als een klasse zowel een klasse uibreidt als een interface implimenteert, dan moet het begrip extends als eerste in de header worden ingeschreven

 het aantal interfaces dat geïmplimenteerd kan worden, is onbeperkt

public class Naam implements nr1, nr2 { … }


  • wanneer de klasse bedoeld is om implimentaties voor een paar methodes te bevatten, moeten we een abstracte klasse gebruiken; als we kunnen kiezen, genieten interfaces onze voorkeur

  • als we een type als een abstracte klasse definiëren, kunnen subklassen geen andere klasse uitbreiden. Omdat interfaces meervoudige overerving mogelijk maken, kunnen we deze daar dus wel voor gebruiken

HFST 11



  • een exception opgooien:

throw new Exeption type ( “Uitleg” );

  • alle subklassen van de Java-standaardklasse RunTimeExeption zijn ongecontroleerde exeptions; alle andere subklassen van Exeption zijn gecontroleerde exeptions

  • Gecontroleerd = waar je een fout kan verwachten

  • Ongecontroleerd = normaal geen fouten ( programmeerfouten)

  • Gebruik ongecontroleerde exeptions voor situaties die leiden tot een programmeerfout (meestal omdat te verwachten is dat een logische fout het programma zal doen stoppen)

  • Een gecontroleerde exeptions gebruik je dus best voor situaties waar er een probleem ontstaat dat mogelijk door de gebruiken kan worden opgelost

  • Ongecontroleerde exeptions gebruik je voor situaties die redelijkerwijs hadden voorkomen kunnen worden. Het is dan ook duidelijk dat gecontroleerde exeptions gebruikt moeten worden in situaties waarover de programmeur geen macht heeft

  • Wanneer een exeption wordt opgegooid, wordt de uitvoering van de opgooiende methode onmiddellijk stopgezet  een specifiek gevolg daarvan is dat een methode met een returntype anders dan void verplicht is om returnstatements uit te voeren op een pad dat een exeption opgooit  als de exeption niet opgevangen wordt zal het programma beëindigd worden met een foutmelding

  • Voor het opgooien van een ongecontroleerde exeption gebruik je een throw- statement

Bv. throw new IllegalArgumentexeption (“Foute”);

 opgegooid door een constructor of methode om aan te geven dat de waarde van een of meerdere argumenten ongeldig zijn



  • meestal is er een exeption-handler in de vorm van een try-blok:

try

{

// benadert 1 of meerdere statements



}

catch ( Exeptiontype e )

{

// meldt een exeption en lost het op



}

catch ( Exeptiontype e)

{

// tweede probleemsoort



}

  • het doorgeven van exeptions wordt veel gebruikt wanneer de aanroepende methode zelf geen oplossing kan bieden voor de exeption; naar methodes die dit wel kunnen op een hiërarchisch hoger niveau

  • de try-blok kan nog een derde component bevatten: de finally-clausule ( gebruikt voor statements die altijd, ongeacht de aanwezigheid van een exeption, uitgevoerd worden na een bewaakt statement)

 een finally-clausule wordt ook uitgevoerd als er een returnstatement uitgevoerd wordt in de try- of catch-clausule

 als er een exeption opgegooid wordt in de try- of catch-clausule die niet opgevangen wordt, wordt de finally-clausule toch uitgevoerd



  • als de standaard exeptionklasse niet passend genoeg is voor een bepaald probleem, kan je zelf nieuwe meer specifieke exeptionklassen definiëren en daarbij overerving gebruiken

  • meestal zal de belangrijkste reden voor het nieuw definiëren van een exeptionklasse zijn om de aanvullende informatie op te nemen in het exeption-object om een betere foutdiagnose en oplossing van de fout mogelijk te maken

  • fouten oplossen:

 een eerste vereiste voor het met succes oplossen van fouten is dat de gebruiker iets doet met de ontvangen foutmelding. Het try-blok van Java is de manier om een foutenoplossingsmechanisme te leveren bij een opgegooide exeption. De oplossing van een fout zal meestal bestaan uit 1 of meerdere handelingen binnen de catch-clausule gevolgd door een nieuwe poging. Om pogingen te herhalen kan het try-blok in een lus geplaatst worden

  • fouten voorkomen:

om fouten te voorkomen is vaak een nauwe samenwerking nodig tussen programmeur en gebruiker.




De database wordt beschermd door het auteursrecht ©opleid.info 2019
stuur bericht

    Hoofdpagina