Coffee break #133. Paano makakuha lamang ng bahagi ng isang array sa Java. Mga Interface at Abstract na Klase sa Java

Paano makakuha lamang ng bahagi ng isang array sa Java

Pinagmulan: Asyncq Ang pagkopya ng bahagi ng isang array ay isang pangkaraniwang operasyon na nararanasan ng bawat developer. Sa artikulong ito, makikita natin ang tradisyunal na istilong imperative at modernong declarative style code na may lambda expression at streaming API.

Imperative na diskarte

Ang imperative na istilo ng programming ay matagal nang karaniwan sa Java. Samakatuwid, natural para sa mga developer ng Java na isulat ang code sa ibaba upang kopyahin ang isang partikular na bahagi ng orihinal na array. Upang gawin ito, ulitin lamang ang mga elemento, i-filter lamang ang mga kailangan, at isulat ang mga ito sa huling hanay.

private static int[] copyArray(){
       int[] numbers = {1,2,3,4,5,6,7};
       int[] subArray = new int[numbers.length-3];
       int j =3;
       for (int i=0;i<subArray.length;i++){
           subArray[i] = numbers[j+i];
       }
       System.out.println(Arrays.toString(subArray));
       return subArray;
   }

Madalas nakakalimutan ng marami sa atin na ang library ng Java Arrays ay may maginhawang paraan ng copyOfRange . Ang pamamaraang ito ay maaaring gamitin upang kopyahin ang bahagi ng isang array sa pamamagitan ng pagpasa sa at mula sa index.

private static int[] copyArray1(){
  int[] numbers = {1,2,3,4,5,6,7};
  int[] subArray = Arrays.copyOfRange(numbers,3,numbers.length);
  System.out.println(Arrays.toString(subArray));
  return subArray;
}

Deklarasyon na diskarte

Dahil ang Java 8 ay magagamit natin ang Streams API upang kopyahin ang bahagi ng isang array. Sa code sa ibaba, maaari nating ipasa ang int[] at i-filter lamang ang mga value na higit sa 3 at sa wakas ay kopyahin ang mga ito sa isang array.

private static void copyArray2(){
        int[] numbers = {1,2,3,4,5,6,7};
        // copy with values
        int[] subArray = Arrays.stream(numbers).filter(a-> a>3).toArray();
        System.out.println(Arrays.toString(subArray));
    }

Ang code sa itaas ay isang value-based na kopya ng isang bahagi ng array, ngunit maaari rin naming kopyahin batay sa isang index. Sa ibaba ng code na ini-broadcast namin ng Intstream mula sa i=0; i=len(array) . Karaniwan sa imperative code nagsusulat kami ng for loop mula sa start index hanggang sa end index at umuulit sa bawat elemento. Magagawa natin ang parehong bagay gamit ang Intstream at i-access ang elemento ng index .

// copy with index
int[] subArray1 = IntStream
                .range(0, numbers.length)
                .filter(i -> i > 3)
                .map(a->numbers[a]).toArray();

System.out.println(Arrays.toString(subArray1));

Habang gumagana ang pamamaraan sa itaas, mayroon kaming isa pang paraan kung saan magagamit namin ang AtomicInteger upang kopyahin ang bahagi ng array. Mayroon itong getAndIncrement method na mahalagang nagbibigay ng index at dinadagdagan ito ng 1.

// copy with index
AtomicInteger atomicInteger = new AtomicInteger();
int[] subArray2 = Arrays.stream(numbers).filter(i -> atomicInteger.getAndIncrement() > 3).toArray();
System.out.println(Arrays.toString(subArray2));

Konklusyon

Sa artikulong ito, tinalakay namin kung paano mo makokopya ang bahagi ng isang array ng Java gamit ang mga istilong imperative at declarative. Mas gugustuhin kong magtrabaho sa istilong deklaratibo dahil ginagawa nitong mas nababasa ang aking code at hindi gaanong verbose.

Mga Interface at Abstract na Klase sa Java

Pinagmulan: Devgenius Kapag nag-aaral ng wikang Java, tiyak na nakatagpo tayo ng isang konsepto na tinatawag na Mga Interface. Ang mga interface ay isa sa mga pangunahing tampok ng Java, kaya dapat malaman ng bawat developer kung paano gamitin ang mga ito. Mahalagang tandaan na ang mga interface ay may parehong mga pakinabang at disadvantages. Sumisid tayo nang mas malalim sa pag-unawa sa mga interface. Kapag nagpapatupad ng mga interface, nakatagpo kami ng mga abstract na klase. Ano ang mga abstract na klase? Ano ang kailangan nila? Ano ang isang interface? Paano ginagamit ang mga ito? Bakit gumagamit ang mga interface ng mga abstract na klase? Makakakuha ka ng mga sagot sa lahat ng mga tanong na ito sa artikulong ito.

Ano ang isang interface?

Ang interface ay isang espesyal na mekanismo sa Java na naglalarawan ng pag-uugali at tumutulong na makamit ang abstraction. Ito ay katulad ng isang klase sa maraming paraan dahil mayroon itong mga static na constant at abstract na pamamaraan. Ang mga interface ay maaari lamang magkaroon ng mga abstract na pamamaraan (mga pamamaraan na walang katawan). Maikling pagkakaiba sa pagitan ng interface at abstract na klase:

• Ang interface ay walang anumang mga pamamaraan na ipinatupad; lahat sila ay pampubliko at walang mga variable ng klase.
• Ang abstract na klase ay isang klase na walang isa o higit pang mga pamamaraan na ipinatupad.

Mula noong Java 9, maaari rin kaming gumamit ng private , default , at static na pamamaraan sa mga interface . Ngayon ay lumipat tayo sa simpleng interface logic na ginagamit upang makamit ang abstraction.

Ano ang abstraction?

Kumuha tayo ng isang tunay na halimbawa sa buhay. Lahat tayo ay gumagamit ng mga app sa ating mga mobile phone. Sa tuwing gusto naming gumamit ng anumang application, kailangan naming lumikha ng isang account dito. Kapag nagparehistro kami sa pamamagitan ng aming numero ng telepono, isang beses na password ang ipinapadala sa aming mobile phone. Alam namin na ang password ay natanggap pagkatapos i-click ang "Kumuha ng Password" na buton sa application, ngunit hindi namin alam kung paano gumagana ang system na ito sa backend at kung ano ang aktwal na nangyayari pagkatapos ng pag-click sa pindutan. Ngayon, ang proseso ng matagumpay na pagkumpleto ng mga gawain nang hindi ipinapakita sa user kung ano ang aktwal na nangyayari sa backend ay kilala bilang abstraction. Sa Java, makakamit natin ang abstraction gamit ang mga interface at abstract na klase.

Bakit gagamitin ang interface?

May tatlong dahilan para gamitin ang interface:

• Upang makamit ang abstraction.
• Upang suportahan ang maramihang pagpapagana ng mana.
• Upang makamit ang maluwag na pagkabit.

Paano gamitin ang interface?

Ang isang interface ay ipinahayag gamit ang interface na keyword . Nagbibigay ito ng abstraction, ibig sabihin, idineklara nito ang istruktura ng klase. Ang lahat ng mga pamamaraan sa isang interface ay abstract at nakatakda sa public, static, at final bilang default ( public , static , final ). Anuman ang klase na nagpapatupad ng isang interface ay dapat ipatupad ang lahat ng mga pamamaraan na ipinahayag sa interface.

interface <interface_name>{

     // declare constant fields
     // declare methods that abstract
     // by default.
 }

Katulad ng abstraction ng interface, maaari ding makamit ang abstraction gamit ang mga abstract na klase.

Ano ang mga abstract na klase?

Ang mga abstract na klase ay mga klase na may abstract na keyword sa harap nila. Naglalaman ang mga ito ng parehong abstract at kongkreto na mga pamamaraan (na may katawan). Ang mga abstract na klase ay hindi maaaring i-instantiate, dapat silang palawigin at ang kanilang mga pamamaraan ay dapat ipatupad. Ang isang abstract na klase ay naglalarawan ng ilang abstract na bagay (kotse, tao, atbp.), hindi lamang pag-uugali. Tandaan:

• Ang isang abstract na klase ay dapat ideklara gamit ang abstract na keyword .
• Maaaring may abstract at non-abstract na pamamaraan.
• Ang isang halimbawa ng isang abstract na klase ay hindi maaaring gawin.
• Maaari itong magkaroon ng mga constructor at static na pamamaraan.
• Maaari itong magkaroon ng mga panghuling pamamaraan na pipilitin ang subclass na huwag baguhin ang katawan ng pamamaraan.

Halimbawa ng abstract na klase na may abstract na pamamaraan: Sa halimbawang ito , ang Bike ay isang abstract na klase na naglalaman lamang ng isang abstract na paraan ng pagtakbo. Ang pagpapatupad nito ay ibinigay ng klase ng Honda .

abstract class Bike{
  abstract void run();
}
class Honda4 extends Bike{
void run(){System.out.println("running safely");}
public static void main(String args[]){
 Bike obj = new Honda4();
 obj.run();
}
}

Abstract class na mayroong constructor, data member at method: Ang abstract class ay maaaring magkaroon ng data member, abstract method, method body (non-abstract method), constructor at kahit na main() method .

//Example of an abstract class that has abstract and non-abstract methods
 abstract class Bike{
   Bike(){System.out.println("bike is created");}
   abstract void run();
   void changeGear(){System.out.println("gear changed");}
 }
//Creating a Child class which inherits Abstract class
 class Honda extends Bike{
 void run(){System.out.println("running safely..");}
 }
//Creating a Test class which calls abstract and non-abstract methods
 class TestAbstraction2{
 public static void main(String args[]){
  Bike obj = new Honda();
  obj.run();
  obj.changeGear();
}
}

Ngayon ang pangunahing tanong ay lumitaw. Kung ang mga interface at abstract na klase ay makakatulong sa abstraction, alin ang mas mahusay na gamitin? Ang sagot ay hindi sinusuportahan ng Java ang maramihang pamana tulad ng ginagawa ng C++. Iyon ay, kung kailangan nating makamit ang maramihang mana, dapat tayong gumamit ng mga interface. Sa madaling salita, nakakatulong ang mga abstract na klase mula 1 hanggang 100% ng mga kaso, at nakakatulong ang mga interface sa 100% ng mga kaso. Kung kailangan natin ng pag-uugali, kailangan nating gumamit ng interface. Kung pinag-uusapan natin ang tungkol sa isang konseptong bagay, dapat tayong gumamit ng abstract na klase.

Halimbawa ng Java Interface

Sa halimbawang ito, ang Drawable interface ay may isang paraan lamang. Ang pagpapatupad nito ay ibinigay ng mga klase ng Rectangle at Circle . Sa isang tunay na sitwasyon, ang interface ay tinukoy ng ibang tao at ang pagpapatupad nito ay ibinigay ng iba't ibang mga provider ng pagpapatupad. Bukod dito, ito ay ginagamit ng ibang tao. Ang bahagi ng pagpapatupad ay itinago ng user gamit ang interface.

//Interface declaration: by first user
interface Drawable{
void draw();
}
//Implementation: by second user
class Rectangle implements Drawable{
public void draw(){System.out.println("drawing rectangle");}
}
class Circle implements Drawable{
public void draw(){System.out.println("drawing circle");}
}
//Using interface: by third user
class TestInterface1{
public static void main(String args[]){
Drawable d=new Circle();//In real scenario, object is provided by method e.g. getDrawable()
d.draw();
}}

Maramihang Pamana sa Java Gamit ang Interface

Kung ang isang klase ay nagpapatupad ng maraming interface o ang isang interface ay nagpapalawak ng maraming interface, ito ay tinatawag na multiple inheritance.

interface Printable{
void print();
}
interface Showable{
void show();
}
class A7 implements Printable,Showable{
public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}

public static void main(String args[]){
A7 obj = new A7();
obj.print();
obj.show();
 }
}

Tanong: Ang maramihang pamana ay hindi sinusuportahan sa pamamagitan ng isang klase sa Java, ngunit ito ay posible sa pamamagitan ng isang interface, bakit? Gaya ng ipinaliwanag na sa seksyon ng inheritance, hindi sinusuportahan ang multiple inheritance sa halimbawa ng klase dahil sa kalabuan. Gayunpaman, sinusuportahan ito ng halimbawa ng interface dahil walang kalabuan dito. Ang dahilan ay ang pagpapatupad nito ay ibinigay ng klase ng pagpapatupad.