Mana sa Java

Ang Java ay isang object-oriented na wika. Nangangahulugan ito na ang lahat sa Java ay binubuo ng mga klase at kanilang mga bagay, at sumusunod sa mga paradigma ng OOP (object-oriented programming). Ang isa sa gayong paradigma ay ang pamana, isang mekanismo sa Java kung saan pinapayagan ang isang klase na magmana ng mga tampok (mga patlang at pamamaraan) ng isa pang klase. Sa madaling salita, sa Java, ang inheritance ay nangangahulugan ng paglikha ng mga bagong klase batay sa mga umiiral na.

Mga Pangunahing Aktor ng Pamana sa Java

• Ang inheritance ay ang konsepto na maaaring bahagyang o ganap na ulitin ng isang klase ang mga katangian at pamamaraan ng magulang nito (ang klase kung saan ito nagmamana).
• Ang child class, o subclass, o extended class, o derived class ay isang klase na nagmana mula sa ibang klase.
• Ang parent class, superclass, o base class ay isang klase na may ilang mga function, at ang mga function na ito ay maaaring ipasa (inherited) ng isa pang klase (child class).
• Ang pag-override ng pamamaraan ay ang pagbabago ng pag-uugali ng isang nagmula na pamamaraan ng klase. Ito ay karaniwang mas tiyak, pinong pag-uugali. Kung i-override mo ang isang paraan sa tagapagmana na nasa parent class na, papalitan nito ang paraan ng magulang.
• Ang isang klase ay maaaring magkaroon lamang ng isang ancestor class, ngunit ang bawat klase ay maaaring magkaroon ng maraming "anak".

Paano ito gumagana

Ang inheritance chain ay nakadirekta mula sa pinaka abstract na klase hanggang sa mas kongkreto. Iyon ay, ang superclass ay ang pinaka-abstract sa hanay ng mga klase. Kadalasan ito ay tinutukoy bilang abstract (base class na hindi nangangailangan ng pagpapatupad). Ang lahat ng karagdagang mga klase ay mas tiyak. Halimbawa, mayroong isang klase na tinatawag na "Gadget". Maaari itong magkaroon ng field (o estado) na "weight" field na kapasidad ng baterya, field charge level at mga pamamaraan (o gawi) na "work" at pag-charge. Sa kasong ito, ang mga pamamaraan ay maaaring abstract, iyon ay, wala silang isang tiyak na pagpapatupad. Bagama't hindi natin masasabi kung anong uri ito ng gadget, ito ay talagang anumang rechargeable na gadget. Gumawa tayo ng Phone subclass ng Gadget class. Hindi na nito kailangang muling tukuyin ang timbang at baterya, minana lang nito ang mga ito mula sa abstract na gadget. Ngunit ang pag-uugali ng trabaho ay kailangang linawin. Maaari ka ring magdagdag ng iba pang mga field na "diagonal ng screen", mga konektor, at iba pa. Maaari kang magdagdag ng bagong paraan na "I-update ang operating system". Susunod, makakagawa tayo ng dalawa pang klase at pareho silang mamamana mula sa Telepono, Android at iPhone. Ang parehong mga klase ay nagmamana ng lahat ng mga patlang at pamamaraan ng Gadget at Smartphone, at ang mga pamamaraan ay maaaring ma-override. Ang unang klase ay nangangailangan ng isang field na "Brand name", habang ang iPhone ay hindi nangangailangan ng field na ito, dahil isang kumpanya lamang ang gumagawa ng mga naturang smartphone.

class Gadget {
…
}
}
//subclass of Gadget class
class Phone extends Gadget {
…
}
//subclass of Phone class
class IPhone extends Phone {
…
}
//subclass of Phone class
class AndroidPhone extends Phone {
…
}

Ang isang child class ay nagmamana ng lahat ng pampubliko at protektadong miyembro ng parent class. Hindi mahalaga kung anong package ang subclass. Kung ang child class ay nasa parehong package ng parent class, mamanahin din nito ang package-private na miyembro ng magulang. Maaari mong gamitin ang mga minanang miyembro kung ano man, palitan sila, itago ang mga ito, o magdagdag ng mga bagong miyembro:

• Maaari mong gamitin ang mga minanang field nang direkta gaya ng anumang iba pang field.
• Maaari kang magdeklara ng field sa child class na may parehong pangalan tulad ng sa parent class. It's hiding it (so better not to do it).
• Maaari kang magdeklara ng mga bagong field sa child class (mga wala sa parent class).
• Ang mga minanang pamamaraan ay maaaring gamitin nang direkta nang hindi nag-o-override sa nagmula na klase.
• Maaari ka ring magsulat ng isang bagong paraan ng halimbawa sa isang subclass na may parehong lagda bilang isang pamamaraan sa klase ng magulang. Ino-override ito ng pamamaraang ito.
• Maaari kang magdeklara ng mga bagong pamamaraan sa child class na hindi idineklara sa Parent class.
• Maaari kang magsulat ng isang subclass constructor na tumatawag sa superclass constructor alinman sa implicitly o gamit ang super keyword.

Halimbawa

Gumawa tayo ng base MusicalInstrument class na may weight at trademark na mga field, pati na rin ang work() method. Tinutukoy din namin ang isang constructor.

public class MusicalInstrument {
   int weight;
   String tradeMark;

   public MusicalInstrument(int weight, String tradeMark) {
       this.weight = weight;
       this.tradeMark = tradeMark;
   }

   public void work() {
       System.out.println("the instrument is playing...");
   }
}

Ito ay ganap na hindi malinaw kung anong uri ng instrumentong pangmusika ito at kung paano ito tutugtugin. Gumawa tayo ng mas tiyak na instrumento, ang violin. Magkakaroon ito ng parehong mga field tulad ng sa Musical Instrument (tatawagin sila sa constructor gamit ang super keyword. Maaari din nating i-override ang work method at gumawa ng paraan para sa pagtatakda ng violin string sa pamamagitan ng string.

public class Violin extends MusicalInstrument {
   String master;
   String owner;
   int age;
   boolean isTuned;

   public Violin(int weight, String tradeMark, String master, String owner, int age, boolean isTuned) {
       super(weight, tradeMark);
       this.master = master;
       this.owner = owner;
       this.age = age;
       this.isTuned = isTuned;
   }

   @Override
   public void work() {
       System.out.println("THe violin's playing");

   }

   public void violinTuning () {
     System.out.println("I'm tuning 1st string...");
     System.out.println("I'm tuning 2nd string...");
     System.out.println("I'm tuning 3rd string...");
     System.out.println("I'm tuning 4th string...");
}


}

Gumawa tayo ng Demo class para subukan ang Violin class at makita kung paano gumagana ang inheritance.

public class InheritDemo {

   public static void main(String[] args) {

       Violin violin = new Violin(1, null, "Amati", "Kremer", 285, false);
       violin.violinTuning();
       violin.work();
   }
}

Sa kasong ito, ang output ng programa ay ang mga sumusunod: Iyon ay, kung mayroong isang overridden na pamamaraan sa klase ng bata, kung gayon ang pamamaraan ng ninuno ay hindi na tatawagin. Paano kung wala ito? Ibig sabihin, ganito ang hitsura ng klase ng Violin:

public class Violin extends MusicalInstrument {
   String master;
   String owner;
   int age;
   boolean isTuned;

   public Violin(int weight, String tradeMark, String master, String owner, int age, boolean isTuned) {
       super(weight, tradeMark);
       this.master = master;
       this.owner = owner;
       this.age = age;
       this.isTuned = isTuned;
   }

  // @Override


 //  }

   public void violinTuning () {
       System.out.println("I'm tuning 1st string...");
       System.out.println("I'm tuning 2nd string...");
       System.out.println("I'm tuning 3rd string...");
       System.out.println("I'm tuning 4th string...");
   }

}

Ang output ay: Iyon ay, ang pamamaraan ng ninuno ay awtomatikong tatawagin. Sa pamamagitan ng paraan, ang klase ng bata ay maaaring tukuyin sa pamamagitan ng ninuno, iyon ay, upang maisagawa ang upcasting:

Parent parent = new Child()

Ginagamit ang initialization na ito para ma-access lang ang mga miyembrong naroroon sa parent class at ang mga overridden na pamamaraan. Sa aming halimbawa ay magiging:

public class InheritDemo {

   public static void main(String[] args) {

       MusicalInstrument violin = new Violin(1, null, "Amati", "Kremer", 285, false);
       //violin.violinTuning();
       violin.work();
   }
}

Sa ganoong kaso, hindi namin ma-configure ang paraan ng violin. Gayunpaman sa parehong oras, ang work() na pamamaraan ng descendant class ay tatawagin, kung ito ay umiiral.

Ang Java Platform Class Hierarchy

Sa Java, ang lahat ay binubuo ng mga klase at sila ay nasa ilalim ng isang hierarchy. Ang tanong ay lumitaw: mayroon bang isang klase kung saan ang lahat ng iba ay minana? Ang sagot ay oo, talagang may ganitong klase. At ito ay tinatawag na simpleng Object . Ang klase ng Object mula sa java.lang package, ay tumutukoy at nagpapatupad ng gawi na karaniwan sa lahat ng mga klase, kabilang ang mga nilikha mo. Sa platform ng Java, maraming mga klase ang direktang nakukuha mula sa Object , ang ibang mga klase ay nakukuha mula sa ilan sa mga klase na ito, at iba pa, na bumubuo ng class hierarchy.

Mga Uri ng Pamana sa Java

I-highlight natin ang ilang uri ng inheritance sa Java. 1. Single Inheritance Ang uri na ito ay katulad ng sa aming halimbawa sa itaas, ang mga subclass ay namamana ng mga feature ng isang super class. Sa larawan sa ibaba, ang class A ay nagsisilbing base class para sa derived class na B. 2. Multilevel Inheritance Isa lamang itong chain of inheritance, ibig sabihin, mayroong base class A, class B ay minana mula dito, at class C ay minana mula sa klase B. Sa Java, hindi direktang ma-access ng isang klase ang mga miyembro ng lolo't lola. 3. Hierarchical Inheritance Sa Hierarchical Inheritance, ang isang klase ay nagsisilbing super class (base class) para sa higit sa isang subclass. Sa itaas, nagbigay kami ng halimbawa ng klase ng Telepono, na maaaring magkaroon ng dalawang "anak" — AndroidPhone at IPhone.

class A {
    public void printA() {
System.out.println("A");
 }
}

class B extends A {
    public void printB() {
 System.out.println(" B"); }
}

class C extends A {
    public void printC() {
System.out.println("C");
}
}

class D extends A {
    public void printD() {
System.out.println("D");
 }
}

public class Demo {
    public static void main(String[] args)
    {
        B objB = new B();
        objB.printA();
        objB.printB();

        C objC = new C();
        objC.printA();
        objC.printC();

        D objD = new D();
        objD.printA();
        objD.printD();
    }
}

Ang output ay: 4. Multiple inheritance, iyon ay, ang presensya ng ilang ninuno ... ngunit teka, classic multiple inheritance ay hindi sinusuportahan sa Java. Sa ilang lawak, maaari itong ipatupad gamit ang hindi mga klase, ngunit mga interface.

interface A {
   public void printA();
}

interface B {
   public void printB();
}

interface C extends A, B {
   public void print();
}
class InheritDemo implements C {
   @Override
   public void print()
   {
       System.out.println("Print something");
   }

   @Override
   public void printA() {
   }

   @Override
   public void printB() {
   }
}