Ngopi #133. Carane njaluk mung bagean saka array ing Jawa. Antarmuka lan Kelas Abstrak ing Jawa

Carane njaluk mung bagean saka array ing Jawa

Sumber: Asyncq Nyalin bagean saka array minangka operasi sing umum banget sing ditemoni saben pangembang. Ing artikel iki, kita bakal weruh gaya imperatif tradisional lan kode gaya deklaratif modern kanthi ekspresi lambda lan streaming API.

Pendekatan imperatif

Gaya pemrograman imperatif wis suwe umum ing Jawa. Mulane, iku lumrah kanggo pangembang Jawa nulis kode ing ngisor iki kanggo nyalin bagean tartamtu saka Uploaded asli. Kanggo nindakake iki, mung mbaleni liwat unsur, nyaring metu mung sing perlu, lan nulis menyang Uploaded pungkasan.

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

Akeh kita asring lali yen perpustakaan Java Arrays nduweni metode copyOfRange sing trep . Cara iki bisa digunakake kanggo nyalin bagean saka array kanthi ngliwati lan saka 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

Wiwit Java 8, kita bisa nggunakake Streams API kanggo nyalin bagean saka array. Ing kode ing ngisor iki, kita bisa ngliwati int [] lan nyaring mung nilai sing luwih gedhe tinimbang 3 lan pungkasane nyalin menyang 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 ing ndhuwur minangka salinan adhedhasar nilai bagean saka array, nanging kita uga bisa nyalin adhedhasar indeks. Ing ngisor kode sing kita siarake Intstream saka i=0; i=len(larik) . Biasane ing kode imperatif kita nulis kanggo daur ulang saka indeks wiwitan nganti indeks pungkasan lan ngulang saben unsur. Kita bisa nindakake perkara sing padha nggunakake Intstream lan ngakses unsur 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));

Nalika cara ing ndhuwur bisa digunakake, kita duwe cara liya kanggo nggunakake AtomicInteger kanggo nyalin bagean saka array. Nduwe metode getAndIncrement sing ateges nyedhiyakake indeks lan nambah kanthi 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

Ing artikel iki, kita wis ngrembug babagan carane sampeyan bisa nyalin bagean saka array Jawa nggunakake gaya imperatif lan deklaratif. Aku luwih seneng bisa nganggo gaya deklaratif amarga kodeku luwih bisa diwaca lan kurang verbose.

Antarmuka lan Kelas Abstrak ing Jawa

Sumber: Devgenius Nalika nyinau basa Jawa, mesthi nemoni konsep sing diarani Antarmuka. Antarmuka minangka salah sawijining fitur utama ing Jawa, mula saben pangembang kudu ngerti carane nggunakake. Penting kanggo elinga yen antarmuka duwe kaluwihan lan kekurangane. Ayo nyilem luwih jero kanggo ngerteni antarmuka. Nalika ngleksanakake antarmuka, kita nemoni kelas abstrak. Apa kelas abstrak? Apa sing dibutuhake? Apa antarmuka? Carane padha digunakake? Napa antarmuka nggunakake kelas abstrak? Sampeyan bakal entuk jawaban kanggo kabeh pitakonan kasebut ing artikel iki.

Apa antarmuka?

Antarmuka minangka mekanisme khusus ing Jawa sing nggambarake prilaku lan mbantu entuk abstraksi. Iki meh padha karo kelas kanthi pirang-pirang cara amarga nduweni konstanta statis lan metode abstrak. Antarmuka mung bisa duwe metode abstrak (metode tanpa awak). Bentenipun ringkes antarane antarmuka lan kelas abstrak:

• Antarmuka ora duwe cara sing diimplementasikake; kabeh iku umum lan ora ana variabel kelas.
• Kelas abstrak yaiku kelas sing ora duwe siji utawa luwih metode sing ditindakake.

Wiwit Java 9, kita uga bisa nggunakake metode pribadi , standar , lan statis ing antarmuka . Saiki ayo pindhah menyang logika antarmuka sing prasaja sing digunakake kanggo entuk abstraksi.

Apa abstraksi?

Ayo padha njupuk conto urip nyata. Kita kabeh nggunakake aplikasi ing ponsel kita. Saben kita pengin nggunakake aplikasi apa wae, kita kudu nggawe akun ing. Nalika kita ndhaptar liwat nomer telpon kita, sandi siji-wektu dikirim menyang ponsel kita. Kita ngerti manawa sandhi ditampa sawise ngeklik tombol "Entuk Sandi" ing aplikasi kasebut, nanging kita ora ngerti kepiye sistem iki bisa digunakake ing mburi lan apa sing kedadeyan sawise ngeklik tombol kasebut. Saiki, proses kasil ngrampungake tugas tanpa nuduhake pangguna apa sing kedadeyan ing backend diarani abstraksi. Ing Jawa, kita bisa entuk abstraksi nggunakake antarmuka lan kelas abstrak.

Apa nggunakake antarmuka?

Ana telung alasan kanggo nggunakake antarmuka:

• Kanggo entuk abstraksi.
• Kanggo ndhukung macem-macem fungsi warisan.
• Kanggo entuk kopling longgar.

Kepiye cara nggunakake antarmuka?

Antarmuka diumumake nggunakake tembung kunci antarmuka . Iki nyedhiyakake abstraksi, yaiku, nyatakake struktur kelas. Kabeh cara ing antarmuka iku abstrak lan disetel menyang umum, statis, lan final minangka standar ( umum , statis , final ). Kelas apa wae sing ngleksanakake antarmuka kudu ngetrapake kabeh cara sing diumumake ing antarmuka kasebut.

interface <interface_name>{

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

Kaya abstraksi antarmuka, abstraksi uga bisa digayuh nggunakake kelas abstrak.

Apa kelas abstrak?

Kelas abstrak yaiku kelas kanthi tembung kunci abstrak ing ngarepe. Dheweke ngemot metode abstrak lan konkrit (kanthi awak). Kelas abstrak ora bisa instantiated, kudu ditambahi lan cara kudu dileksanakake. Kelas abstrak nggambarake sawetara obyek abstrak (mobil, wong, lan liya-liyane), ora mung prilaku. Elingi:

• Kelas abstrak kudu diumumake nganggo tembung kunci abstrak .
• Ana cara abstrak lan non-abstrak.
• Kayata saka kelas abstrak ora bisa digawe.
• Bisa duwe konstruktor lan cara statis.
• Bisa duwe metode pungkasan sing bakal meksa subkelas supaya ora ngganti awak metode.

Conto kelas abstrak kanthi cara abstrak: Ing conto iki , Bike minangka kelas abstrak sing mung ngemot siji metode abstrak. Implementasine diwenehake dening 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 nduweni konstruktor, anggota data lan metode: Kelas abstrak bisa duwe anggota data, metode abstrak, awak metode (metode non-abstrak), konstruktor lan malah metode utama () .

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

Saiki pitakonan utama muncul. Yen antarmuka lan kelas abstrak mbantu abstraksi, sing luwih apik digunakake? Jawabane yaiku Jawa ora ndhukung warisan pirang-pirang kaya C++. Yaiku, yen kita kudu entuk pirang-pirang warisan, mula kita kudu nggunakake antarmuka. Ing tembung liyane, kelas abstrak mbantu saka 1 nganti 100% kasus, lan antarmuka mbantu ing 100% kasus. Yen kita butuh prilaku, kita kudu nggunakake antarmuka. Yen kita ngomong babagan obyek konsep, kita kudu nggunakake kelas abstrak.

Tuladha Java Interface

Ing conto iki, antarmuka Drawable mung duwe siji cara. Implementasine diwenehake dening kelas Rectangle lan Circle . Ing skenario nyata, antarmuka ditetepake dening wong liya lan implementasine diwenehake dening panyedhiya implementasi sing beda. Kajaba iku, digunakake dening wong liya. Bagéyan saka implementasine didhelikake dening pangguna nggunakake 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();
}}

Multiple Inheritance in Java Using Interface

Yen kelas ngleksanakake macem-macem antarmuka utawa antarmuka ngluwihi macem-macem antarmuka, diarani sawetara warisan.

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

Pitakonan: Multiple warisan ora didhukung liwat kelas ing Jawa, nanging bisa liwat antarmuka, kok? Kaya sing wis diterangake ing bagean babagan warisan, sawetara warisan ora didhukung ing conto kelas amarga ambiguitas. Nanging, didhukung dening conto antarmuka amarga ora ana ambiguitas. Alesane yaiku implementasine diwenehake dening kelas implementasi.