Rehat kopi #133. Cara mendapatkan hanya sebagian dari array di Java. Antarmuka dan Kelas Abstrak di Java

Cara mendapatkan hanya sebagian dari array di Java

Sumber: Asyncq Menyalin bagian dari array adalah operasi yang sangat umum yang ditemui setiap pengembang. Pada artikel ini, kita akan melihat gaya imperatif tradisional dan kode gaya deklaratif modern dengan ekspresi lambda dan API streaming.

Pendekatan imperatif

Gaya pemrograman imperatif telah lama menjadi hal yang umum di Java. Oleh karena itu, wajar bagi pengembang Java untuk menulis kode di bawah ini untuk menyalin bagian tertentu dari array asli. Untuk melakukan ini, cukup lakukan iterasi melalui elemen-elemen, saring hanya elemen-elemen yang diperlukan, dan tuliskan ke dalam array terakhir.

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

Banyak dari kita sering lupa bahwa perpustakaan Java Arrays memiliki metode copyOfRange yang mudah digunakan . Metode ini dapat digunakan untuk menyalin bagian dari array dengan meneruskan 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 dapat menggunakan Streams API untuk menyalin bagian dari array. Pada kode di bawah ini, kita dapat meneruskan int[] dan memfilter hanya nilai yang lebih besar dari 3 dan terakhir menyalinnya ke dalam 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));
    }

Kode di atas adalah salinan berbasis nilai dari sebagian array, tetapi kita juga dapat menyalin berdasarkan indeks. Di bawah kode kami menyiarkan Intstream dari i=0; i=len(array) . Biasanya dalam kode imperatif kita menulis perulangan for dari indeks awal ke indeks akhir dan mengulangi setiap elemen. Kita dapat melakukan hal 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));

Meskipun metode di atas berfungsi, kami memiliki cara lain untuk menggunakan AtomicInteger untuk menyalin bagian dari array. Ia memiliki metode getAndIncrement yang pada dasarnya menyediakan indeks dan menambahnya sebesar 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

Pada artikel ini, kita telah membahas bagaimana Anda dapat menyalin bagian dari array Java menggunakan gaya imperatif dan deklaratif. Saya lebih suka bekerja dalam gaya deklaratif karena membuat kode saya lebih mudah dibaca dan tidak terlalu bertele-tele.

Antarmuka dan Kelas Abstrak di Java

Sumber: Devgenius Saat mempelajari bahasa Java, kita pasti menjumpai sebuah konsep bernama Interface. Antarmuka adalah salah satu fitur utama Java, jadi setiap pengembang harus mengetahui cara menggunakannya. Penting untuk diingat bahwa antarmuka memiliki kelebihan dan kekurangannya masing-masing. Mari selami lebih dalam pemahaman antarmuka. Saat mengimplementasikan antarmuka, kita menemukan kelas abstrak. Apa itu kelas abstrak? Untuk apa mereka dibutuhkan? Apa itu antarmuka? Bagaimana cara penggunaannya? Mengapa antarmuka menggunakan kelas abstrak? Anda akan mendapatkan jawaban atas semua pertanyaan ini di artikel ini.

Apa itu antarmuka?

Antarmuka adalah mekanisme khusus di Java yang menggambarkan perilaku dan membantu mencapai abstraksi. Ini mirip dengan kelas dalam banyak hal karena memiliki konstanta statis dan metode abstrak. Antarmuka hanya dapat memiliki metode abstrak (metode tanpa isi). Perbedaan singkat antara antarmuka dan kelas abstrak:

• Antarmuka tidak menerapkan metode apa pun ; semuanya bersifat publik dan tidak ada variabel kelas.
• Kelas abstrak adalah kelas yang tidak mempunyai satu atau lebih metode yang diimplementasikan.

Sejak Java 9, kita juga dapat menggunakan metode private , default , dan static di interfaces . Sekarang mari beralih ke logika antarmuka sederhana yang digunakan untuk mencapai abstraksi.

Apa itu abstraksi?

Mari kita ambil contoh kehidupan nyata. Kita semua menggunakan aplikasi di ponsel kita. Kapan pun kita ingin menggunakan aplikasi apa pun, kita harus membuat akun di dalamnya. Ketika kami mendaftar melalui nomor telepon kami, kata sandi satu kali dikirimkan ke ponsel kami. Kita tahu bahwa kata sandi diterima setelah mengklik tombol “Dapatkan Kata Sandi” di aplikasi, tetapi kita tidak tahu bagaimana sistem ini bekerja di backend dan apa yang sebenarnya terjadi setelah mengklik tombol tersebut. Sekarang, proses penyelesaian tugas yang berhasil tanpa menunjukkan kepada pengguna apa yang sebenarnya terjadi di backend dikenal sebagai abstraksi. Di Java, kita dapat mencapai abstraksi menggunakan antarmuka dan kelas abstrak.

Mengapa menggunakan antarmuka?

Ada tiga alasan untuk menggunakan antarmuka:

• Untuk mencapai abstraksi.
• Untuk mendukung fungsionalitas pewarisan ganda.
• Untuk mencapai kopling longgar.

Bagaimana cara menggunakan antarmuka?

Sebuah antarmuka dideklarasikan menggunakan kata kunci antarmuka . Ini memberikan abstraksi, yaitu mendeklarasikan struktur kelas. Semua metode dalam antarmuka bersifat abstrak dan disetel ke public, static, dan final secara default ( public , static , final ). Kelas apa pun yang mengimplementasikan antarmuka harus mengimplementasikan semua metode yang dideklarasikan dalam antarmuka.

interface <interface_name>{

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

Mirip dengan abstraksi antarmuka, abstraksi juga dapat dicapai dengan menggunakan kelas abstrak.

Apa itu kelas abstrak?

Kelas abstrak adalah kelas dengan kata kunci abstrak di depannya. Mereka berisi metode abstrak dan konkrit (dengan isi). Kelas abstrak tidak dapat dipakai, mereka harus diperluas dan metodenya harus diimplementasikan. Kelas abstrak mendeskripsikan beberapa objek abstrak (mobil, orang, dll.), bukan hanya perilaku. Ingat:

• Kelas abstrak harus dideklarasikan dengan kata kunci abstract .
• Ada metode abstrak dan non-abstrak.
• Sebuah instance dari kelas abstrak tidak dapat dibuat.
• Itu dapat memiliki konstruktor dan metode statis.
• Ia dapat memiliki metode final yang akan memaksa subkelas untuk tidak mengubah isi metode.

Contoh kelas abstrak dengan metode abstrak: Dalam contoh ini , Bike adalah kelas abstrak yang hanya berisi satu metode abstrak yang dijalankan. Implementasinya 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 memiliki konstruktor, anggota data, dan metode: Kelas abstrak dapat memiliki anggota data, metode abstrak, badan metode (metode non-abstrak), konstruktor, dan bahkan metode 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 pertanyaan utamanya muncul. Jika antarmuka dan kelas abstrak membantu abstraksi, mana yang lebih baik untuk digunakan? Jawabannya adalah Java tidak mendukung pewarisan berganda seperti C++. Artinya, jika kita perlu mencapai pewarisan berganda, maka kita harus menggunakan antarmuka. Dengan kata lain, kelas abstrak membantu 1 hingga 100% kasus, dan antarmuka membantu 100% kasus. Jika kita membutuhkan perilaku, kita perlu menggunakan antarmuka. Jika kita berbicara tentang objek konseptual, kita harus menggunakan kelas abstrak.

Contoh Antarmuka Java

Dalam contoh ini, antarmuka Drawable hanya memiliki satu metode. Implementasinya disediakan oleh kelas Rectangle dan Circle . Dalam skenario nyata, antarmuka ditentukan oleh orang lain dan implementasinya disediakan oleh penyedia implementasi yang berbeda. Apalagi sedang digunakan oleh orang lain. Bagian dari implementasi disembunyikan oleh pengguna menggunakan antarmuka.

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

Warisan Berganda di Java Menggunakan Antarmuka

Jika suatu kelas mengimplementasikan banyak antarmuka atau suatu antarmuka memperluas beberapa antarmuka, hal itu disebut pewarisan berganda.

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

Pertanyaan: Warisan berganda tidak didukung melalui kelas di Java, tetapi dimungkinkan melalui antarmuka, mengapa? Seperti yang sudah dijelaskan di bagian pewarisan, pewarisan berganda tidak didukung dalam contoh kelas karena ambiguitas. Namun didukung dengan contoh antarmuka karena tidak ada ambiguitas di dalamnya. Alasannya adalah implementasinya disediakan oleh kelas implementasi.