Mga partikular na halimbawa ng mga abstract na klase sa Java

Hi! Sa mga nakaraang aralin, nakilala namin ang mga interface at nalaman kung para saan ang mga ito. Ang paksa sa araw na ito ay uulitin ang nauna. Pag-usapan natin ang mga abstract na klase sa Java.

Bakit tinatawag na 'abstract' ang mga klase

Malamang naaalala mo kung ano ang 'abstraction' — nalampasan na natin ito. :) Kung nakalimutan mo, huwag kang matakot. Tandaan: isa itong prinsipyo ng OOP na nagsasabing kapag nagdidisenyo ng mga klase at gumagawa ng mga bagay, dapat nating tukuyin lamang ang mga pangunahing katangian ng entity at itapon ang minor. Halimbawa, kung kami ay nagdidisenyo ng isang SchoolTeacherklase, halos hindi namin kailangan ng isang ' taas ' na pag-aari. Sa katunayan, ang ari-arian na ito ay walang kaugnayan para sa isang guro. Ngunit kung gagawa tayo ng isang BasketballPlayerklase, kung gayon ang paglago ay magiging isang mahalagang katangian. Kaya makinig ka. Isang abstract na klaseay kasing abstract ng mga ito — isang hindi natapos na 'blangko' para sa isang grupo ng mga klase sa hinaharap. Ang blangko ay hindi maaaring gamitin bilang ay. Masyadong 'raw'. Ngunit ito ay naglalarawan ng ilang estado at pangkalahatang pag-uugali na pag-aari ng mga klase sa hinaharap na nagmamana ng abstract na klase.

Mga halimbawa ng abstract na mga klase ng 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, hindi ito espesyal :) Bakit natin ito kakailanganin? Una sa lahat, inilalarawan nito ang aming kinakailangang entity, isang kotse, sa pinaka-abstract na paraan na posible. May dahilan kung bakit ginagamit namin ang salitang abstract . Sa totoong mundo, walang 'abstract cars'. May mga trak, karera ng kotse, sedan, coupe, at SUV. Ang aming abstract na klase ay isang 'blueprint' na gagamitin namin sa ibang pagkakataon upang lumikha ng mga 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!");
   }

}

Ito ay halos kapareho sa napag-usapan natin sa mga aralin tungkol sa mana. Ngunit sa mga araling iyon, nagkaroon kami ng klase ng Kotse at ang mga pamamaraan nito ay hindi abstract. Ngunit ang solusyon na iyon ay may ilang mga kakulangan na naayos sa mga abstract na klase. Una at pangunahin, hindi ka makakalikha ng isang halimbawa ng abstract na klase :

public class Main {

   public static void main(String[] args) {

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

Partikular na idinisenyo ng mga tagalikha ng Java ang 'feature' na ito. Muli, bilang paalala: ang abstract na klase ay isang blueprint lamang para sa hinaharap na 'normal' na mga klase . Hindi mo kailangan ng mga kopya ng blueprint, tama? At hindi ka gumagawa ng mga instance ng abstract class :) Ngunit kung Carhindi abstract ang klase, madali kaming makakagawa ng mga instance nito:

public class Car {

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

   public void gas() {
       // Some logic
   }

    public void brake() {
       // Some logic
   }
}


public class Main {

   public static void main(String[] args) {

       Car car = new Car(); // Everything is fine. A car is created.
   }
}

Ngayon ang aming programa ay may isang uri ng hindi maintindihan na kotse — hindi ito isang trak, hindi isang karera ng kotse, hindi isang sedan, at ito ay ganap na hindi malinaw kung ano ito. Ito ang mismong 'abstract na kotse' na wala sa kalikasan. Maaari kaming magbigay ng parehong halimbawa gamit ang mga hayop. Isipin kung Animalclasses ( abstract animals ). Hindi malinaw kung anong uri ng hayop ito, kung anong pamilya ito, at kung anong mga katangian mayroon ito. Magiging kakaiba na makita iyon sa iyong programa. Walang mga 'abstract na hayop' sa kalikasan. Tanging mga aso, pusa, fox, nunal, atbp. Ang mga abstract na klase ay naghahatid sa amin mula sa mga abstract na bagay. Binibigyan nila tayo ng pangunahing estado at pag-uugali. Halimbawa, ang lahat ng kotse ay dapat may modelo , kulay , at pinakamataas na bilis , at dapat mong ilapat anggas at preno . Ayan yun. Ito ay isang pangkalahatang abstract na plano. Susunod na idisenyo mo ang mga klase na kailangan mo. Tandaan: dalawang pamamaraan sa abstract na klase ay itinalaga rin bilang abstract , at wala silang anumang pagpapatupad. Ang dahilan ay pareho: ang mga abstract na klase ay hindi gumagawa ng default na gawi para sa abstract na mga kotse. Ipinapahiwatig lamang nila kung ano ang dapat gawin ng bawat kotse. Gayunpaman, 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("Gas!");
   }

   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: "Gas!" Gaya ng nakikita mo, ipinatupad namin ang unang paraan sa abstract na klase, at hindi ang pangalawa. Bilang resulta, Sedannahahati sa dalawang bahagi ang pag-uugali ng aming klase: kung tatawagin mo ang gas()pamamaraan, ang tawag 'tumataas' hanggang sa Carabstract na klase ng magulang, ngunit nalampasan namin ang brake()pamamaraan sa Sedanklase. Ito ay lumalabas na napaka-maginhawa at nababaluktot. Ngunit ngayon ang aming klase ay hindi masyadong abstract ? Pagkatapos ng lahat, kalahati ng mga pamamaraan nito ay ipinatupad. Ito ay talagang isang napakahalagang tampok - ang isang klase ay abstract kung hindi bababa sa isa sa mga pamamaraan nito ay abstract. Isa sa dalawang pamamaraan, o hindi bababa sa isa sa isang libong pamamaraan — wala itong pinagkaiba. Maaari pa nga nating ipatupad ang lahat ng mga pamamaraan at wala ni isa sa kanila ang iwanan. Kung gayon ito ay magiging isang abstract na klase na walang mga abstract na pamamaraan. Sa prinsipyo, ito ay posible, at ang compiler ay hindi bubuo ng mga error, ngunit ito ay mas mahusay na iwasan ito: Ang salitang abstract ay nawawala ang kahulugan nito, at ang iyong mga kapwa programmer ay labis na mabigla :/ Kasabay nito, kung ang isang pamamaraan ay minarkahan gamit ang salitang abstract, dapat itong ipatupad o ideklara ng bawat klase ng bata bilang abstract. Kung hindi, bubuo ng error ang compiler. Siyempre, ang bawat klase ay maaaring magmana lamang ng isang abstract na klase, kaya sa mga tuntunin ng pamana ay walang pagkakaiba sa pagitan ng abstract at ordinaryong mga klase. Hindi mahalaga kung magmana tayo ng abstract na klase o ordinaryong isa, maaari lamang magkaroon ng isang parent class.

Bakit ang Java ay walang maraming inheritance ng mga klase

Nasabi na namin na walang multiple inheritance ang Java, pero hindi pa namin talaga na-explore kung bakit. Subukan nating gawin iyon ngayon. Ang katotohanan ay kung ang Java ay may maraming mana, ang mga klase ng bata ay hindi makakapagpasya kung aling partikular na pag-uugali ang dapat nilang piliin. Ipagpalagay na mayroon tayong dalawang klase — Toasterat NuclearBomb:

public class Toaster {


 public void on() {

       System.out.println("The toaster is on. Toast is being prepared!");
   }

   public void off() {

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


public class NuclearBomb {

   public void on() {

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

Tulad ng nakikita mo, parehong may on()pamamaraan. Para sa isang toaster, nagsisimula itong mag-ihaw. Para sa isang bombang nuklear, ito ay naglalabas ng isang pagsabog. Oops: / Ngayon isipin na nagpasya kang (huwag itanong sa akin kung bakit!) na lumikha ng isang bagay sa pagitan. At kaya may klase ka MysteriousDevice! Ang code na ito, siyempre, ay hindi gumagana, at ibinibigay lamang namin ito bilang isang halimbawa 'ngunit maaaring ito':

public class MysteriousDevice extends Toaster, NuclearBomb {

   public static void main(String[] args) {

       MysteriousDevice mysteriousDevice = new MysteriousDevice();
       mysteriousDevice.on(); // So what should happen here? Do we get toast or a nuclear apocalypse?
   }
}

Tingnan natin kung ano ang mayroon tayo. Ang mahiwagang aparato ay sabay-sabay na nagmamana ng Toaster at NuclearBomb. Parehong may on()mga pamamaraan. Bilang resulta, kung tatawagin natin ang on()pamamaraan, hindi malinaw kung alin ang dapat i-invoke sa MysteriousDevicebagay. Walang paraan na maaaring malaman ng bagay. At higit pa sa lahat: Walang off()paraan ang NuclearBomb, kaya kung hindi namin nahulaan nang tama, imposibleng i-disable ang device. Dahil mismo sa 'pagkalito' na ito, kung saan hindi alam ng object kung anong pag-uugali ang ipapakita, na inabandona ng mga tagalikha ng Java ang maramihang pamana. Gayunpaman, maaalala mo na ang mga klase ng Java ay maaaring magpatupad ng maramihang mga interface. Oo nga pala, sa iyong pag-aaral, naka-encounter ka na ng kahit isang abstract na klase!

public abstract class Calendar implements Serializable, Cloneable, Comparable<Calendar>

Ito ang dati mong kaibigan, ang Calendarklase. Abstract ito at may ilang anak. Ang isa sa kanila ay GregorianCalendar. Nagamit mo na ito sa mga aralin tungkol sa mga petsa. :) Mukhang malinaw na ang lahat. Mayroon lamang isang tanong: ano pa rin ang pangunahing pagkakaiba sa pagitan ng mga abstract na klase at mga interface? Bakit nila idinagdag pareho sa Java sa halip na limitahan lamang ang wika sa isa? Pagkatapos ng lahat, iyon ay magiging ganap na sapat. Pag-uusapan natin ito sa susunod na aralin ! hanggang dun nalang :)