Mga interface sa Java

1. Ipinapakilala ang mga interface

Ngayon ang araw mo para sa kaalaman. Ang isa pang bago at kawili-wiling paksa ay ang mga interface.

Ang konsepto ng isang interface ay ang bata ng mga prinsipyo ng abstraction at polymorphism. Ang isang interface ay halos kapareho sa isang abstract na klase, kung saan ang lahat ng mga pamamaraan ay abstract. Ito ay ipinahayag sa parehong paraan bilang isang klase, ngunit ginagamit namin ang interfacekeyword.

interface Feline
{
   void purr();
   void meow();
   void growl();
}

Narito ang ilang kapaki-pakinabang na katotohanan tungkol sa mga interface:

1. Pagdedeklara ng interface

interface Drawable
{
   void draw();
}

interface HasValue
{
   int getValue();
}

1. Sa halip na classkeyword, isinusulat namin ang interface.
2. Naglalaman lamang ito ng mga abstract na pamamaraan (huwag isulat ang abstractkeyword)
3. Sa katunayan, ang mga interface ay may lahatpublic ng mga pamamaraan

Ang isang interface ay maaari lamang magmana ng mga interface. Ngunit ang isang interface ay maaaring magkaroon ng maraming mga magulang. Ang isa pang paraan upang sabihin ito ay ang pagsasabi na ang Java ay may maraming pamana ng mga interface. Mga halimbawa:

interface Piece extends Drawable, HasValue
{
   int getX();
   int getY();
}

3. Pagpapamana ng mga klase mula sa mga interface

Ang isang klase ay maaaring magmana ng maraming interface (mula lamang sa isang klase). Ginagawa ito gamit ang implementskeyword. Halimbawa:

abstract class ChessItem implements Drawable, HasValue
{
   private int x, y, value;
   public int getValue()
   {
      return value;
   }

   public int getX()
   {
      return x;
   }

   public  int getY()
   {
      return y;
   }
}

Ang klase ng ChessItem ay idineklara na abstract: ipinapatupad nito ang lahat ng minanang pamamaraan maliban sa draw. Sa madaling salita, ang ChessItemklase ay naglalaman ng isang abstract na pamamaraan — draw().

Ang teknikal na kahulugan ng extendsat implementsmga keyword ay pareho: pareho ay mana. Ang pagkakaiba ay ginawa upang mapabuti ang pagiging madaling mabasa ng code. Sinasabi rin namin na ang mga klase ay minana (sa pamamagitan ng extends) at ang mga interface ay ipinatupad (sa pamamagitan ng implements)

4. Mga variable

Narito ang pinakamahalagang bagay: ang mga ordinaryong variable ay hindi maaaring ideklara sa mga interface (bagaman maaari ang mga static).

Ngunit bakit kailangan natin ng mga interface? Kailan sila ginagamit? Ang mga interface ay may dalawang malakas na pakinabang sa mga klase:

2. Paghihiwalay sa "paglalarawan ng mga pamamaraan" mula sa kanilang pagpapatupad.

Noong nakaraan, sinabi namin na kung gusto mong payagan ang mga pamamaraan ng iyong klase na matawag mula sa ibang mga klase, kung gayon ang iyong mga pamamaraan ay kailangang markahan ng publickeyword. Kung gusto mong tawagin ang ilan sa mga pamamaraang iyon mula lamang sa loob ng iyong klase, kailangan mong markahan ang mga ito ng privatekeyword. Sa madaling salita, hinahati namin ang mga pamamaraan ng klase sa dalawang kategorya: "para magamit ng lahat" at "para lamang sa aming sariling paggamit".

Nakakatulong ang mga interface na palakasin pa ang dibisyong ito. Gagawa kami ng espesyal na "klase para magamit ng lahat" pati na rin ang pangalawang klase "para lang sa sarili naming gamit", na magmamana ng unang klase. Narito ang halos kung ano ang magiging hitsura nito:

class Student
{
   private String name;
   public Student(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return this.name;
   }

   private void setName(String name)
   {
      this.name = name;
   }

interface Student
{
   public String getName();
}

class StudentImpl implements Student
{
   private String name;
   public StudentImpl(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return this.name;
   }

   private void setName(String name)
   {
      this.name = name;
   }
}

public static void main(String[] args)
{
   Student student = new Student("Alibaba");
   System.out.println(student.getName());
}

public static void main(String[] args)
{
   Student student = new StudentImpl("Ali")
   System.out.println(student.getName());
}

Hinati namin ang aming klase sa dalawa: isang interface at isang klase na nagmamana ng interface . At ano ang kalamangan dito?

Maraming iba't ibang klase ang maaaring magpatupad (magmana) ng parehong interface. At ang bawat isa ay maaaring magkaroon ng sariling pag-uugali. Halimbawa, ArrayList LinkedListay dalawang magkaibang pagpapatupad ng Listinterface.

Kaya, itinatago namin hindi lamang ang iba't ibang mga pagpapatupad, kundi pati na rin ang klase ng pagpapatupad mismo (dahil kailangan lang namin ang interface sa code). Nagbibigay-daan ito sa amin na maging napaka-flexible: habang tumatakbo ang program, maaari naming palitan ang isang bagay ng isa pa, binabago ang gawi ng isang bagay nang hindi naaapektuhan ang lahat ng klase na gumagamit nito.

Ito ay isang napakalakas na pamamaraan kapag pinagsama sa polymorphism. Sa ngayon, malayong malinaw kung bakit mo ito dapat gawin. Kailangan mo munang makatagpo ng mga programa na may dose-dosenang o daan-daang mga klase upang maunawaan na ang mga interface ay maaaring gawing mas madali ang iyong buhay kaysa wala sila.

3. Maramihang mana

Sa Java, ang lahat ng klase ay maaari lamang magkaroon ng isang parent class. Sa iba pang mga programming language, ang mga klase ay kadalasang maaaring magkaroon ng maraming klase ng magulang. Ito ay napaka-maginhawa, ngunit nagdudulot din ng maraming problema.

Ang mga tagalikha ng Java ay dumating sa isang kompromiso: ipinagbawal nila ang maramihang pamana ng mga klase, ngunit pinapayagan ang maramihang pamana ng mga interface. Maaaring magkaroon ng maraming interface ng magulang ang isang interface. Ang isang klase ay maaaring magkaroon ng maraming interface ng magulang ngunit isang parent class lamang.

Bakit nila ipinagbawal ang maramihang pamana ng mga klase ngunit pinapayagan ang maramihang pamana ng mga interface? Dahil sa tinatawag na diamond inheritance problem:

Kapag ang B class ay nagmana ng A class, wala itong alam tungkol sa C at D na klase. Kaya ginagamit nito ang mga variable ng A class ayon sa nakikita nitong akma. Ganoon din ang ginagawa ng C class: ginagamit nito ang mga variable ng A class, ngunit sa ibang paraan. At ang lahat ng ito ay nagreresulta sa isang salungatan sa klase ng D.

Tingnan natin ang sumusunod na simpleng halimbawa. Sabihin nating mayroon tayong 3 klase:

class Data
{
   protected int value;
}

class XCoordinate extends Data
{
   public void setX (int x) { value = x;}
   public int getX () { return value;}
}

class YCoordinate extends Data
{
   public void setY (int y) { value = y;}
   public int getY () { return value; }
}

Iniimbak ng klase ng Data ang valuevariable. Ang XCoordinate descendant class nito ay gumagamit ng variable na iyon para iimbak ang xvalue, at YCoordinateginagamit ito ng descendant class para iimbak ang yvalue.

At ito ay gumagana. Hiwalay. Ngunit kung gusto nating mamanahin ng XYCoordinates class ang XCoordinateat YCoordinatemga klase, pagkatapos ay makakakuha tayo ng sirang code. Ang klase na ito ay magkakaroon ng mga pamamaraan ng mga ninuno nitong klase, ngunit hindi ito gagana nang tama, dahil mayroon silang pareho value variable.

Ngunit dahil ang mga interface ay hindi maaaring magkaroon ng mga variable, hindi sila maaaring magkaroon ng ganitong uri ng salungatan. Alinsunod dito, pinapayagan ang maramihang pagmamana ng mga interface.