Coffee break #133. Bagaimana untuk mendapatkan hanya sebahagian daripada tatasusunan di Jawa. Antara Muka dan Kelas Abstrak di Jawa

Bagaimana untuk mendapatkan hanya sebahagian daripada tatasusunan di Jawa

Sumber: Asyncq Menyalin sebahagian daripada tatasusunan ialah operasi yang sangat biasa yang dihadapi oleh setiap pembangun. Dalam artikel ini, kita akan melihat gaya imperatif tradisional dan kod gaya deklaratif moden dengan ekspresi lambda dan API penstriman.

Pendekatan imperatif

Gaya pengaturcaraan imperatif telah lama menjadi kebiasaan di Jawa. Oleh itu, adalah wajar bagi pembangun Java untuk menulis kod di bawah untuk menyalin bahagian tertentu tatasusunan asal. Untuk melakukan ini, hanya lelaran melalui elemen, menapis hanya yang diperlukan, dan tuliskannya ke dalam tatasusunan akhir.

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;
   }

Ramai di antara kita sering terlupa bahawa perpustakaan Java Arrays mempunyai kaedah copyOfRange yang mudah . Kaedah ini boleh digunakan untuk menyalin sebahagian daripada tatasusunan dengan menghantar ke dan dari indeks.

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;
}

Pendekatan deklaratif

Sejak Java 8 kita boleh menggunakan API Streams untuk menyalin sebahagian daripada tatasusunan. Dalam kod di bawah, kita boleh menghantar int[] dan menapis hanya nilai yang lebih besar daripada 3 dan akhirnya menyalinnya ke dalam tatasusunan.

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));
    }

Kod di atas ialah salinan berasaskan nilai sebahagian daripada tatasusunan, tetapi kita juga boleh menyalin berdasarkan indeks. Di bawah kod yang kami siarkan Intstream daripada i=0; i=len(array) . Biasanya dalam kod imperatif kita menulis gelung for dari indeks permulaan hingga indeks akhir dan lelaran ke atas setiap elemen. Kita boleh melakukan perkara yang sama menggunakan Intstream dan mengakses elemen indeks .

// 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));

Walaupun kaedah di atas berfungsi, kita mempunyai cara lain di mana kita boleh menggunakan AtomicInteger untuk menyalin sebahagian daripada tatasusunan. Ia mempunyai kaedah getAndIncrement yang pada asasnya menyediakan indeks dan menambahnya sebanyak 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));

Kesimpulan

Dalam artikel ini, kami telah membincangkan cara anda boleh menyalin sebahagian daripada tatasusunan Java menggunakan gaya imperatif dan deklaratif. Saya lebih suka bekerja dalam gaya deklaratif kerana ia menjadikan kod saya lebih mudah dibaca dan kurang bertele-tele.

Antara Muka dan Kelas Abstrak di Jawa

Sumber: Devgenius Apabila mempelajari bahasa Java, kita pasti akan menemui satu konsep yang dipanggil Antara Muka. Antara muka adalah salah satu ciri utama Java, jadi setiap pembangun harus tahu cara menggunakannya. Adalah penting untuk diingat bahawa antara muka mempunyai kelebihan dan kekurangan mereka. Mari kita selami lebih mendalam ke dalam memahami antara muka. Apabila melaksanakan antara muka, kami menghadapi kelas abstrak. Apakah kelas abstrak? Untuk apa mereka diperlukan? Apakah antara muka? Bagaimana ia digunakan? Mengapa antara muka menggunakan kelas abstrak? Anda akan mendapat jawapan kepada semua soalan ini dalam artikel ini.

Apakah antara muka?

Antara muka ialah mekanisme khas dalam Java yang menerangkan tingkah laku dan membantu mencapai abstraksi. Ia serupa dengan kelas dalam banyak cara kerana ia mempunyai pemalar statik dan kaedah abstrak. Antara muka hanya boleh mempunyai kaedah abstrak (kaedah tanpa badan). Perbezaan ringkas antara antara muka dan kelas abstrak:

• Antara muka tidak mempunyai sebarang kaedah yang dilaksanakan; semuanya terbuka dan tiada pembolehubah kelas.
• Kelas abstrak ialah kelas yang tidak mempunyai satu atau lebih kaedah yang dilaksanakan.

Sejak Java 9, kami juga boleh menggunakan kaedah private , default , dan static dalam antara muka . Sekarang mari kita beralih kepada logik antara muka mudah yang digunakan untuk mencapai abstraksi.

Apakah abstraksi?

Mari kita ambil contoh kehidupan sebenar. Kita semua menggunakan aplikasi pada telefon bimbit kita. Setiap kali kita ingin menggunakan mana-mana aplikasi, kita perlu membuat akaun di dalamnya. Apabila kami mendaftar melalui nombor telefon kami, kata laluan sekali sahaja dihantar ke telefon bimbit kami. Kami tahu bahawa kata laluan diterima selepas mengklik butang "Dapatkan Kata Laluan" dalam aplikasi, tetapi kami tidak tahu bagaimana sistem ini berfungsi di bahagian belakang dan apa yang sebenarnya berlaku selepas mengklik butang. Kini, proses berjaya menyelesaikan tugasan tanpa menunjukkan kepada pengguna apa yang sebenarnya berlaku di bahagian belakang dikenali sebagai abstraksi. Di Java, kita boleh mencapai abstraksi menggunakan antara muka dan kelas abstrak.

Mengapa menggunakan antara muka?

Terdapat tiga sebab untuk menggunakan antara muka:

• Untuk mencapai abstraksi.
• Untuk menyokong pelbagai fungsi warisan.
• Untuk mencapai gandingan longgar.

Bagaimana untuk menggunakan antara muka?

Antara muka diisytiharkan menggunakan kata kunci antara muka . Ia menyediakan abstraksi, iaitu, ia mengisytiharkan struktur kelas. Semua kaedah dalam antara muka adalah abstrak dan ditetapkan kepada awam, statik dan muktamad secara lalai ( public , static , final ). Apa sahaja kelas yang melaksanakan antara muka mesti melaksanakan semua kaedah yang diisytiharkan dalam antara muka.

interface <interface_name>{

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

Sama seperti abstraksi antara muka, abstraksi juga boleh dicapai menggunakan kelas abstrak.

Apakah kelas abstrak?

Kelas abstrak ialah kelas dengan kata kunci abstrak di hadapannya. Ia mengandungi kaedah abstrak dan konkrit (dengan badan). Kelas abstrak tidak boleh dijadikan instantiated, mereka mesti dilanjutkan dan kaedahnya mesti dilaksanakan. Kelas abstrak menerangkan beberapa objek abstrak (kereta, orang, dll.), bukan hanya tingkah laku. Ingat:

• Kelas abstrak mesti diisytiharkan dengan kata kunci abstrak .
• Terdapat kaedah abstrak dan bukan abstrak.
• Contoh kelas abstrak tidak boleh dibuat.
• Ia boleh mempunyai pembina dan kaedah statik.
• Ia boleh mempunyai kaedah akhir yang akan memaksa subkelas untuk tidak mengubah badan kaedah.

Contoh kelas abstrak dengan kaedah abstrak: Dalam contoh ini , Bike ialah kelas abstrak yang mengandungi hanya satu kaedah abstrak dijalankan. Pelaksanaannya disediakan oleh kelas 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();
}
}

Kelas abstrak yang mempunyai pembina, ahli data dan kaedah: Kelas abstrak boleh mempunyai ahli data, kaedah abstrak, badan kaedah (kaedah bukan abstrak), pembina dan juga kaedah main() .

//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();
}
}

Sekarang persoalan utama timbul. Jika antara muka dan kelas abstrak membantu dengan abstraksi, yang manakah lebih baik untuk digunakan? Jawapannya ialah Java tidak menyokong pelbagai warisan seperti C++. Iaitu, jika kita perlu mencapai pelbagai warisan, maka kita harus menggunakan antara muka. Dalam erti kata lain, kelas abstrak membantu daripada 1 hingga 100% kes, dan antara muka membantu dalam 100% kes. Jika kita memerlukan tingkah laku, kita perlu menggunakan antara muka. Jika kita bercakap tentang objek konsep, kita mesti menggunakan kelas abstrak.

Contoh Antaramuka Java

Dalam contoh ini, antara muka Drawable hanya mempunyai satu kaedah. Pelaksanaannya disediakan oleh kelas Rectangle dan Circle . Dalam senario sebenar, antara muka ditakrifkan oleh orang lain dan pelaksanaannya disediakan oleh penyedia pelaksanaan yang berbeza. Lebih-lebih lagi, ia digunakan oleh orang lain. Sebahagian daripada pelaksanaan disembunyikan oleh pengguna menggunakan antara muka.

//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();
}}

Pewarisan Berbilang dalam Java Menggunakan Antara Muka

Jika kelas melaksanakan berbilang antara muka atau antara muka memanjangkan berbilang antara muka, ia dipanggil warisan berbilang.

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();
 }
}

Soalan: Warisan berbilang tidak disokong melalui kelas di Java, tetapi mungkin melalui antara muka, mengapa? Seperti yang telah dijelaskan dalam bahagian warisan, warisan berbilang tidak disokong dalam contoh kelas kerana kekaburan. Walau bagaimanapun, ia disokong oleh contoh antara muka kerana tidak ada kekaburan di dalamnya. Sebabnya ialah pelaksanaannya disediakan oleh kelas pelaksanaan.