Mga konkretong halimbawa ng mga abstract na klase sa Java

Hi! Pag-usapan natin ang mga abstract na klase sa Java.

Bakit tinatawag na "abstract" ang mga klase?

Malamang naaalala mo kung ano ang abstraction — napag-usapan namin ito kanina :) Kung nakalimutan mo, huwag mag-alala. Tandaan, ito ay isang prinsipyo ng OOP na nagsasabing, kapag nagdidisenyo ng mga klase at gumagawa ng mga bagay, dapat mong katawanin lamang ang mga pangunahing katangian ng entity at itapon ang mga pangalawang. Halimbawa, kung kami ay nagdidisenyo ng isang SchoolTeacherklase, ang taas ay malamang na hindi magiging isang kinakailangang pag-aari ng isang guro. Sa katunayan, ang katangiang ito ay hindi mahalaga para sa isang guro. Ngunit kung gagawa tayo ng BasketballPlayerklase, ang taas ay isa sa pinakamahalagang katangian. Well, isang abstract na klaseay ang pinaka-abstract, "magaspang na workpiece" para sa isang pangkat ng mga klase sa hinaharap. Ang workpiece ay hindi maaaring gamitin nang direkta — ito ay masyadong "magaspang". Ngunit tinutukoy nito ang ilang partikular na estado at pag-uugali na magkakaroon ng mga klase sa hinaharap - ang mga inapo ng abstract na klase -.

Mga halimbawa ng abstract na klase sa Java

Isaalang-alang ang isang simpleng halimbawa sa mga kotse:

public abstract class Car {

   private String model;
   private String color;
   private int maxSpeed;
  
   public abstract void gas();

   public abstract void brake();

   public String getModel() {
       return model;
   }

   public void setModel(String model) {
       this.model = model;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getMaxSpeed() {
       return maxSpeed;
   }

   public void setMaxSpeed(int maxSpeed) {
       this.maxSpeed = maxSpeed;
   }
}

Ito ang hitsura ng pinakasimpleng abstract na klase. Tulad ng nakikita mo, walang espesyal :) Bakit kaya natin ito kailangan? Una, nagbibigay ito ng pinaka-abstract na paglalarawan ng entity na kailangan namin - isang kotse. Ang abstract na keyword ay may ibig sabihin dito. Sa totoong mundo, walang "kotse lang". May mga trak, karera ng kotse, sedan, coupe, at SUV. Ang aming abstract na klase ay isang "blueprint" lamang na gagamitin namin sa ibang pagkakataon upang lumikha ng mga partikular na klase ng kotse.

public class Sedan extends Car {
  
   @Override
   public void gas() {
       System.out.println("The sedan is accelerating!");
   }

   @Override
   public void brake() {
       System.out.println("The sedan is slowing down!");
   }
  
}

Sa maraming paraan, ito ay katulad ng napag-usapan natin sa mga aralin tungkol sa mana. Sa kasong iyon, mayroon kaming isang Carklase na ang mga pamamaraan ay hindi abstract. Ngunit ang gayong solusyon ay may ilang mga kawalan na naayos sa mga abstract na klase. Una at pangunahin, ang isang instance ng abstract class ay hindi maaaring gawin:

public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // Error! The Car class is abstract!
   }
}

Sinadya ng tagalikha ng Java ang "tampok" na ito. Muli, tandaan: ang abstract na klase ay isang blueprint lamang para sa hinaharap na "regular" na mga klase . Hindi mo kailangan ng mga kopya ng isang blueprint, tama? Katulad nito, hindi na kailangang gumawa ng mga instance ng abstract class :) At kung Carhindi abstract ang klase, madali tayong makakagawa ng mga instance nito:

public class Car {

   private String model;
   private String color;
   private int maxSpeed;
  
   public void go() {
       // ...some logic
   }

   public  void brake() {
       // ...some logic
   }
}


public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // This is okay. The car is created.
   }
}

Sa kasalukuyan, ang aming programa ay may ilang uri ng hindi maintindihang sasakyan. Ito ay hindi isang trak, hindi isang karera ng kotse, at hindi isang sedan, ngunit ito ay hindi talaga malinaw kung ano ito. Ito ay ang "isang kotse lamang" na hindi umiiral sa katotohanan. Ang parehong halimbawa ay maaaring ibigay sa mga hayop. Isipin kung ang iyong programa ay may Animalmga bagay (" hayop lang "). Hindi malinaw kung anong uri ito, kung anong pamilya ito, o kung anong mga katangian mayroon ito. Ito ay magiging kakaiba upang makita ang isa sa isang programa. Walang "hayop lang" sa kalikasan. Tanging mga aso, pusa, fox, nunal, atbp. Ang mga abstract na klase ang nagliligtas sa amin mula sa " mga bagay lang ". Binibigyan nila tayo ng baseline na estado at pag-uugali. Halimbawa, ang lahat ng sasakyan ay dapat may modelo , kulay at pinakamataas na bilis, at dapat din nilang mailapat ang gas at preno . Ayan yun. Ito ay isang pangkalahatang abstract blueprint na gagamitin mo sa ibang pagkakataon upang idisenyo ang mga klase na kailangan mo. Tandaan: ang dalawang pamamaraan sa abstract na klase ay abstract din , na nangangahulugang wala silang pagpapatupad. Ang dahilan ay pareho: ang mga abstract na klase ay hindi gumagawa ng "mga default na pag-uugali" para sa "mga kotse lang". Ipinapahiwatig lamang nila kung ano ang dapat gawin ng bawat kotse. Iyon ay sinabi, kung kailangan mo ng default na pag-uugali, maaari mong ipatupad ang mga pamamaraan sa isang abstract na klase. Hindi ito ipinagbabawal ng Java:

public abstract class Car {

   private String model;
   private String color;
   private int maxSpeed;

   public void gas() {
       System.out.println("Accelerating!");
   }

   public abstract void brake();
  
   // Getters and setters
}


public class Sedan extends Car {

   @Override
   public void brake() {
       System.out.println("The sedan is slowing down!");
   }

}

public class Main {

   public static void main(String[] args) {

       Sedan sedan = new Sedan();
       sedan.gas();
   }
}

Output ng console:

Accelerating!

Tulad ng nakikita mo, ipinatupad namin ang isang pamamaraan sa abstract na klase, ngunit hindi ang isa pa. Bilang resulta, ang pag-uugali ng aming Sedanklase ay nahahati sa dalawang bahagi: kung tatawagin namin ang gas()pamamaraan nito, ang pag-uugali ay "hugot" mula sa abstract Carna klase ng magulang, at ipinapatupad namin ang brake()pamamaraan sa Sedanklase. Iyan ay sobrang maginhawa at nababaluktot. Pero hindi na masyadong abstract ang klase natin ngayon, di ba ? Pagkatapos ng lahat, aktwal na ipinatupad nito ang kalahati ng mga pamamaraan. Ang katotohanan ay - at ito ay isang napakahalagang tampok - ang isang klase ay abstract kung kahit isa sa mga pamamaraan nito ay abstract. Isang paraan ng dalawa, o isa sa isang libo — hindi mahalaga. Maaari pa nga naming ipatupad ang lahat ng mga pamamaraan, na hindi nag-iiwan ng abstract. Ang resulta ay isang abstract na klase na walang anumang abstract na pamamaraan. Ito ay posible sa prinsipyo — ang compiler ay hindi gagawa ng anumang mga error — ngunit ito ay mas mahusay na huwag gawin ito, dahil ito ay deprives ang salitang abstract ng kahulugan nito. Magugulat din ang iyong mga kapwa programmer na makita ito :/ Sabi nga, kung ang isang pamamaraan ay minarkahan bilang abstract, ang bawat descendant na klase ay dapat ipatupad ito o ideklara bilang abstract. Kung hindi, ang tagatala ay magtapon ng isang error. Siyempre, ang bawat klase ay maaari lamang magmana ng isang abstract na klase, kaya walang pagkakaiba sa pagitan ng abstract at regular na mga klase sa mga tuntunin ng inheritance. Hindi mahalaga kung magmana tayo ng abstract na klase o isang regular — maaaring may isang parent class lang.

Bakit walang multiple class inheritance ang Java

Nasabi na namin na walang multiple inheritance sa Java, pero hindi talaga namin nalaman kung bakit. Subukan nating gawin iyon ngayon. Ang katotohanan ay kung ang Java ay nagkaroon ng maramihang mana, kung gayon ang mga klase ng bata ay hindi makakapagpasya kung aling pag-uugali ang pipiliin. Sabihin nating mayroon tayong dalawang klase: Toasterat NuclearBomb:

public class Toaster {
  
  
 public void on() {

       System.out.println("The toaster is on. We're toasting!");
   }
  
   public void off() {

       System.out.println("The toaster is off!");
   }
}


public class NuclearBomb {

   public void on() {

       System.out.println("Boom!");
   }
}

Tulad ng nakikita mo, ang parehong mga klase ay may isang on()pamamaraan. Para sa toaster, ang pamamaraan ay nagsisimula sa paggawa ng toast, ngunit sa kaso ng nuclear bomb, ito ay nagtatakda ng isang pagsabog. Uh-oh :/ Ngayon isipin na napagpasyahan mo (huwag mo akong tanungin kung bakit!) na lumikha ng isang bagay sa pagitan. Narito ang iyong klase: MysteriousDevice! Siyempre, hindi gagana ang code na ito. Ipinakita namin ito bilang isang halimbawa ng "kung ano ang maaaring nangyari":

public class MysteriousDevice extends Toster, NuclearBomb {

   public static void main(String[] args) {
      
       MysteriousDevice mysteriousDevice = new MysteriousDevice();
       mysteriousDevice.on(); // And what should happen here? Will we get toast or a nuclear apocalypse?
   }
}

Tingnan natin kung ano ang mayroon tayo. Ang mahiwagang aparato ay nagmula sa parehong Toaster at NuclearBomb sa parehong oras. Parehong may on()pamamaraan. Bilang resulta, hindi malinaw kung aling pagpapatupad ang dapat isagawa kung tatawag tayo on()sa isang MysteriousDevicebagay. Hindi mauunawaan ng bagay. At higit pa sa lahat, walang off()paraan ang NuclearBomb, kaya kung hindi natin hulaan nang tama, imposibleng i-off ang device. Ang "hindi pagkakaunawaan" na ito, kapag hindi malinaw kung aling pag-uugali ang dapat isagawa, ang mismong dahilan kung bakit tinanggihan ng mga tagalikha ng Java ang maramihang mana. Iyon ay sinabi, matututunan mo na ang mga klase ng Java ay maaaring magpatupad ng maraming mga interface.