Interface er mjög mikilvægt í java, þó það geri “ekki neitt”.
Interface er skilgreining á viðmóti þeirra klasa sem útfæra það.

Gefum okkur forrit sem þarf að geta lesið úr xml skrá og skrifað í gagnagrunn og öfugt.

í lausninni gæti maður þá …

1. Skrifað interface sem gæti lesið og skrifað úr einhverju.
2. Skrifað klasa sem útfærir interfaceið miðað við xml skrá.
3. Skrifað klasa sem útfærir interfaceið miðað við gagnagrunn.

Þá ertu kominn með lítið library sem hægt væri að nota við útfærslu verkefnisins, og þá er náttúrulega frábært að hafa eins viðmót á bæði xml og gagnagrunns klösunum.

Það má líta á þetta í þessu dæmi sem einskonar aðferð við að abstracta hönnunina en binda sameiginlega viðmótspunkta á klösum sem þurfa að eiga eins aðgerðir og breytur, þó það sem þeir geri sé ekki eins.

Kanski er þetta ekki eitthvað sem þarf að nota ef forritið er 3 klasar, en grunnhugsunin er í raun mjög þörf.
mæli með þessari lesningu :
http://java.sun.com/docs/books/tutorial/java/interpack/interfaceDef.html
mjög basic útskýringar og dæmi um interface þarna á ferðinni.

kv
-reynir.net<br><br>[reynir]::[reynir@reynir.net]

Mjög gott svar hjá Carvel, mæli með því að þú lesir tutorial-inn sem hann bendir á.

Að auki langar mig að benda á þau þægindi sem fylgja því að nota interface og notumst við dæmið hans Carvel.

Ef þú ert búinn að búa til interface sem skilgreinir lestur gagna, köllum það IReadData, þá geturðu eins og hann bendir á, búið til klasa með mismunandi virkni sem útfæra interface-ið.

Segjum að interface-ið líti svona út:

public interface IReadData{

public SomeObject read(){

}
}

Klasarnir líta þá svona út:

public ReadDB implements IReadData{
public SomeObject read();
}

public ReadXML implements IReadData{
public SomeObject read();
}

Í forritinu þínu ertu síðan að nota fall sem lítur svona út:

public void Read( IReadData iRead ){

// Láta hlutinn lesa
SomeObject ob = iRead.read();
// Gera eitthvað við hlutinn.
ob….
}

Þarna sérðu snilldina. Fallið þitt þarf ekki að vita annað en að færibreytan sem kemur inn er hlutur sem útfærir IReadData og samkvæmt skilgreiningunni hefur það fallið read(). Þú þarft ekki að vita hvort þetta er ReadDB hlutur eða ReadXML hlutur. Eina sem þú þarft að vita er að read() fallið skilar þér object af einhverju tagi sem þú getur notað.

Þetta er að sjálfsögðu einnig útfæranlegt með erfðum, en interface skilgreiningarnar innihalda engar útfærslur, heldur eru bara söfn af fallaskilgreiningum og föstum.

Ég þakka góð svör. Þó átta ég mig ekki enn alveg út á hvað interface gengur eða nauðsyn þess. Fyrir alls ekki svo löngu póstaði ég fyrirspurn hér um klasa. Þá kunni ég ekkert að nota þá en núna hef ég góðan skilning á klösum og get notað þá. Ætli það sé ekki svipað með ‘interface’, þ.e. brátt verður skilningur minn á því fyrirbæri öllu meiri en hann er þessa stundina..

Svona er gott Interface:
Gerum ráð fyrir að við þurfum að nota forritið ‘DaemaProf’ en þetta forrit er smíðað af einhverjum öðrum. Hönnun þess gæti verið svona:
—————————————————————-
/* Þessi klasi kemur úr einhverju skjalasafni (class library)
* og reiknar með að geta skoðað eitthvað. Þegar tilvik af
* honum er búið til, þarf að senda honum tilvik af skoðara sem
* getur þá skoðað eitthvað.
*/
public class DaemaProf
{
Skodari skoðarinn;

public DaemaProf(Skodari skoðarinn)
{
this.skoðarinn = skoðarinn;
}

public boolean stóðstPrófið(Object nemandinn)
{
return skoðarinn.skoða(nemandinn);
}
}

—————————————————————-
Við sjáum að til að nota forritið þurfum við að eiga sérsmíðaðan klasa sem getur verið hvað sem er, en verður að vera af tegundinni skoðari, sem eru skil, og gætu litið svona út:
—————————————————————-
/* Skil sem skilgreina skoðara. Ekki er vitað
* hvað verði skoðað, en við eigum forrit sem
* þarf stundum að nota skoðara,
*/
public interface Skodari
{
/* Aðferð sem skilar rökbreytu en leyfir skoðun á hlut.
* Merkingarfræðin (semantics) gerir ráð fyrir að aðferðin
* skili true fyrir að hafa skoðað, en false ef skoðun
* tókst ekki.
*/
public boolean skoða(Object hiðSkoðaða);
}
—————————————————————-
Við gætum gert það þannig:
—————————————————————–
/* Þessi Prófdómari er eitthvað sem við smíðum.
sá klasi þarf að vera skoðari svo forritið DæmaPróf geti
gert eitthvað.
*/
public class Profdomari implements Skodari
{
/* Prófdómari gerir ráð fyrir að hiðSkoðaða
* sé tilvik af klasanum Nemandi. Hér mætti gera
* ráð fyrir keyrslufráviki (RuntimeException)
*/
public boolean skoða(Object hiðSkoðaða)
{
Nemandi nn = (Nemandi)hiðSkoðaða;
if(hiðSkoðaða.stigafjöldi() >= 5)
return true;
else return false;
}
}
—————————————————————–

Klasasafnið frá Sun Microsystems er allt vaðandi í klösum sem við þurfum að nota við forritun, sérstaklega java.util, java.awt og javax.swing, svo lítið eitt sé nefnt. Mjög algengt er að þessir klasar krefjist þess að okkar klasar séu af einhverri sérstakri tegund sem þá er yfirleitt lýst í formi Skila.
Við höfum þannig frelsi til að gera okkar eigin klasa með okkar eigin virkni, en getum um leið útfært þá af tegund Skila, jafnvel margra í senn.
Sem forritari þá hefur þú hér fullkomið frelsi … in god we trust in this land of glory and … ehe :-)
Elli