[IN] Java - Bluej - Overerving - Abstractie

[sean_b]

Beste lezer,

Ik zit met een vraagstuk over de volgende opdracht uit mijn bluej boek.

Oefening 10.59:
Bekijk de volgende code. Veronderstel dat je vijf types (klassen of interfaces) (U,G,B,Z en X) hebt en bij elk type een variabele.

U u;
G g;
B b;
Z z;
X x;

De volgende toekenningen zijn allemaal toegestaan:

u = z;
x = b;
g = u;
x = u;

De volgende toekenningen zijn geen van alle toegestaan:

u = b;
x = g;
z = u;
g = x;

Wat kun je, op basis van deze informatie, zeggen over de types een hun onderlingen relaties? (Hoe verhouden ze zich ten opzichte van elkaar?)

Omdat ik vandaag vanwege persoonlijke redenen niet naar college ben geweest en ik toch graag verder wil met de stof, is het noodzakelijk dat ik zeker weet of ik het goed doe.

Mijn uitwerking heb ik als bijlage toegevoegd, graag correcties of tips !

[ILUsion]

Die oplossing ziet er goed uit (het voldoet aan alle gestelde beperkingen). Alleen of je met klassen of interfaces te doen hebt, is een ander paar mouwen.

Je kan uit die gegevens niet afleiden wat de interface is. Vermits u zich gedraagt zoals twee ouders (x en g namelijk; dat haal je uit x = u; g = u; ), en Java enkel single inheritance kent (vandaar het bestaan van interfaces), wilt dat zeggen dat X en/of U een interface moet zijn; maar uit de gegevens kan je niet halen welke van beide dat moet zijn.

Bovendien kan je zelf ook makkelijk je oplossing controleren door het gewoon te implementeren en je editor (ik vermoed dat BlueJ ook genoeg features biedt; anders moet je eens kijken naar bv. Eclipse) alles te laten controleren. Dus bv. met onderstaande test bench:

public class TestBench {

	/* Mogelijkheid 1 */
	class G {}

	interface X {}

	class B implements X {}

	class U extends G implements X  {}

	class Z extends U {}

	/* Mogelijkheid 2 */  
	//  interface G {}
	//  
	//  class X {}
	//  
	//  class B extends X {}
	//  
	//  class U extends X implements G  {}
	//
	//  class Z extends U {}

	/* Mogelijkheid 3 */
	//  interface G {}
	//  
	//  interface X {}
	//  
	//  class B implements X {}
	//  
	//  class U implements X,G  {}
	//
	//  class Z extends U {}

	public static void main(String[] args) {
		U u;
		G g;
		B b = null;
		Z z = null;
		X x;

		u = z;
		x = b;
		g = u;
		x = u;

		u = b;
		x = g;
		z = u;
		g = x;
	}

}

Ik werk zelf met Eclipse en dan krijg je voor de lijn waar een fout instaat een rood symbooltje. Voor de correcte lijnen zal dus niets verschijnen, voor de incorrecte lijnen zal je foutmeldingen krijgen. Bij het compileren zal alles daarop dus ook foutmeldingen spuwen.

Je kan trouwens ook de commando's in commentaar eens decommentariëren (en de overeenkomstige code daarvoor in commentaar zetten) en je zal merken dat die oplossingen ook werken; maar dan met interface en klasse omgewisseld tussen G en X of allebei interfaces in plaats van klassen.

[sean_b]

Dag ILUsion,

Bedankt voor je duidelijke uitleg, ik ga de opdracht maandag opnieuw inleveren, de docent wou inderdaad meerdere uitwerkingen zien, zoals je al zij: "Alleen of je met klassen of interfaces te doen hebt, is een ander paar mouwen."

Maar daar kom ik nu ook uit

Bedankt !

Groeten,
Sean.