Egy



Az összes tudás, amelyet az emberek az évszázadok során felhalmoztak Egy-ről, most már elérhető az interneten, és mi a lehető legkönnyebben hozzáférhető módon összegyűjtöttük és rendszereztük az Ön számára. Szeretnénk, ha gyorsan és hatékonyan hozzáférhetne mindenhez, amit a Egy-ről tudni szeretne; hogy a látogatás élményszerű legyen, és hogy úgy érezze, valóban megtalálta a keresett információt a Egy-ről.

Céljaink elérése érdekében nemcsak arra törekedtünk, hogy a Egy-ről a legfrissebb, legérthetőbb és legigazabb információkat szerezzük be, hanem arra is, hogy az oldal kialakítása, olvashatósága, betöltési sebessége és használhatósága a lehető legkellemesebb legyen, hogy Ön a lényegre, a Egy-ről elérhető összes adat és információ megismerésére koncentrálhasson, és ne kelljen semmi mással foglalkoznia, erről már gondoskodtunk Ön helyett. Reméljük, hogy elértük a célunkat, és hogy megtalálta a kívánt információt a Egy-ről. Üdvözöljük Önt, és arra biztatjuk, hogy továbbra is élvezze a scientiahu.com használatának élményét.

A tudásreprezentáció , objektum-orientált programozás és tervezés (lásd objektum-orientált programot architektúra ), is-a ( is_a vagy egy ) egy subsumption közötti kapcsolat absztrakciók (pl típusok , osztályok ), ahol az egyik osztály A egy alosztálya egy másik osztályú B (és így B jelentése superclass az a ). Más szavakkal, az A típus egy B típusú altípus, ha A specifikációja B specifikációját jelenti. Vagyis minden objektum (vagy osztály), amely kielégíti A specifikációját, megfelel B specifikációjának is, mert B specifikációja gyengébb.

Az is-a kapcsolatot szembe kell állítani a típusok (osztályok) közötti has-a ( has_a vagy a ) kapcsolattal; A has-a és az- a relációk összekeverése gyakori hiba az objektum és az alárendeltje közötti valós viszony modelljének (pl. számítógépes programjának ) megtervezésekor . Az is-a kapcsolat is ellentétben áll az eset: az objektumok közötti (példányok) és típus (osztály): lásd a Type-token különbséget .

Összefoglalva a kapcsolatokat, a következk vannak:

  • hiperonimia - hiponím ( szupertípus / szuperosztály altípus / alosztály) viszonyok a taxonómiai hierarchiát meghatározó típusok (osztályok) között, ahol
    • egy szublimációs reláció esetében: a hiponímnak (altípus, alosztály) a hiponimájával (szupertípus, szuperosztály) van egy típusú kapcsolata ( is-a );
  • holoním - meroním (egész / entitás / konténer rész / alkotóelem / tag) a birtokos hierarchiát meghatározó típusok (osztályok) közötti kapcsolatok, ahol
    • Egy összesítés (vagyis anélkül, hogy tulajdon) kapcsolatban:
      • egy holonym (egészében) van egy has-egy kapcsolata a meronym (rész),
    • Egy készítmény (azaz tulajdon) kapcsolatban:
      • a meroním (alkotóelem) részben kapcsolódik holonimájához (entitásához),
    • Egy elszigetelés kapcsolatban:
      • egy meronym (tag) van egy tagja-a kapcsolata a holonym ( konténer );
  • koncepció objektum (típus token) kapcsolatok a típusok (osztályok) és az objektumok (példányok) között, ahol
    • egy token (objektum) példány- kapcsolatban áll a típusával (osztályával).

Példák az altípusra

Az altípus lehetvé teszi egy adott típus helyettesítését egy másik típussal vagy absztrakcióval. Az altípusról azt mondják , hogy a nyelv típusától függen létrejön egy kapcsolat az altípus és néhány létez absztrakció között, akár hallgatólagosan, akár kifejezetten. A kapcsolat kifejezetten kifejezhet az öröklés útján azokban a nyelvekben, amelyek támogatják az öröklést mint altípus.

C ++

Az alábbi C ++ kódot létrehozza kifejezett öröklés közötti kapcsolat osztályok B és A , ahol B jelentése egyaránt egy alosztálya, és egy altípusa A , és fel lehet használni, mint egy A , ahol egy B van megadva (via egy referencia, egy mutatót vagy magának a tárgynak ).

class A
{ public:
   void DoSomethingALike() const {}
};

class B : public A
{ public:
   void DoSomethingBLike() const {}
};

void UseAnA(A const& some_A)
{
   some_A.DoSomethingALike();
}

void SomeFunc()
{
   B b;
   UseAnA(b); // b can be substituted for an A.
}

Piton

A következ python kódot hoz létre explicit öröklés közötti kapcsolat osztályok B és A , ahol B jelentése egyaránt alosztálya és altípusa A , és fel lehet használni, mint egy A , ahol a B van szükség.

class A:
    def do_something_a_like(self):
        pass

class B(A):
    def do_something_b_like(self):
        pass

def use_an_a(some_a):
    some_a.do_something_a_like()

def some_func():
    b = B()
    use_an_a(b)  # b can be substituted for an A.

A következ példa az (a) típus "normál", a típus ((a) típus) pedig metatípus. Míg az elosztott típusok mindegyikének ugyanaz a metatípusa ( PyType_Type , amely egyben a saját metatípusa is), ez nem követelmény. A klasszikus osztályok típusa, más néven type.ClassType , szintén külön metatípusnak tekinthet.

>>> a = 0
>>> type(a)
<type 'int'>
>>> type(type(a))
<type 'type'>
>>> type(type(type(a)))
<type 'type'>
>>> type(type(type(type(a))))
<type 'type'>

Jáva

A Java -ban az egyik osztály vagy interfész típusparaméterei és a másik típusparaméterei közötti összefüggést a kiterjesztési és végrehajtási záradék határozza meg .

A Gyjtemények osztályok használatával az ArrayList <E> megvalósítja a List <E> -et, a List <E> pedig kiterjeszti a <E> gyjteményt. Tehát az ArrayList <String> a <String> lista egyik altípusa, amely a Collection <String> altípusa. Az altípus kapcsolata automatikusan megmarad a típusok között. Egy olyan felület, a PayloadList definiálásakor, amely minden elemhez társítja a P általános típus opcionális értékét , deklarációja így nézhet ki:

interface PayloadList<E, P> extends List<E> {
    void setPayload(int index, P val);
    ...
}

A PayloadList alábbi paraméterezései a <String> lista altípusai:

PayloadList<String, String>
PayloadList<String, Integer>
PayloadList<String, Exception>

Liskov helyettesítési elv

A Liskov-szubsztitúciós elv megmagyaráz egy tulajdonságot: "Ha minden S típusú o1 objektumhoz tartozik egy T típusú o2 objektum, úgy hogy az összes T programban definiált P program esetében P viselkedése változatlan, ha o1 helyettesíti o2-t, akkor S a T altípusa " . A következ példa az LSP megsértését mutatja be.

void DrawShape(const Shape& s)
{
  if (typeid(s) == typeid(Square))
    DrawSquare(static_cast<Square&>(s));
  else if (typeid(s) == typeid(Circle))
    DrawCircle(static_cast<Circle&>(s));
}

Nyilvánvaló, hogy a DrawShape függvény rosszul van formázva. Tudnia kell a Shape osztály minden származékos osztályáról. Ezenkívül meg kell változtatni, amikor a Shape új alosztálya jön létre. Az objektum-orientált tervezés során sokan ennek felépítését tekintik anathemának.

Íme egy finomabb példa az LSP megsértésére:

class Rectangle
{
  public:
    void   SetWidth(double w)  { itsWidth = w; }
    void   SetHeight(double h) { itsHeight = h; }
    double GetHeight() const   { return itsHeight; }
    double GetWidth() const    { return itsWidth; }
  private:
    double itsWidth;
    double itsHeight;
};

Ez jól mködik, de amikor a Square osztályról van szó, amely a Téglalap osztályt örökli, akkor az megsérti az LSP-t, annak ellenére, hogy fennáll a kapcsolat a Téglalap és a Négyzet között. Mivel a négyzet négyszögletes. Az alábbi példa felülír két funkciót, a Setwidth és a SetHeight, a probléma megoldásához. De a kód javítása azt jelenti, hogy a tervezés hibás.

public class Square : Rectangle
{
  public:
    virtual void SetWidth(double w);
    virtual void SetHeight(double h);
};
void Square::SetWidth(double w)
{
    Rectangle::SetWidth(w);
    Rectangle::SetHeight(w);
}
void Square::SetHeight(double h)
{
    Rectangle::SetHeight(h);
    Rectangle::SetWidth(h);
}

A következ példa a g függvény csak a Téglalap osztálynál mködik, a Square esetében azonban nem, ezért a nyitott-zárt elv sérült.

void g(Rectangle& r)
{
  r.SetWidth(5);
  r.SetHeight(4);
  assert(r.GetWidth() * r.GetHeight()) == 20);
}

Lásd még

Megjegyzések

Hivatkozások

Opiniones de nuestros usuarios

Gabriella Seres

Ez a bejegyzés a Egy segített abban, hogy az utolsó pillanatban befejezzem a holnapi munkámat. Már láttam magam előtt, hogy visszamegyek a Wikipédiához, amit a tanárnő megtiltott nekünk. Köszönöm, hogy megmentettél

Adrienne Sári

Nagyon érdekes ez a bejegyzés a Egy., Azt hittem, már mindent tudok a Egy., Nagyon érdekes ez a bejegyzés a Egy.

Eszter Angyal

Ebben a Egy szóló bejegyzésben olyan dolgokat tudtam meg, amiket nem tudtam, úgyhogy most már mehetek aludni