คอฟฟี่เบรค #133. วิธีรับเพียงส่วนหนึ่งของอาร์เรย์ใน Java อินเทอร์เฟซและคลาสนามธรรมใน Java

วิธีรับเพียงส่วนหนึ่งของอาร์เรย์ใน Java

แหล่งที่มา: Asyncq การคัดลอกส่วนหนึ่งของอาร์เรย์เป็นการดำเนินการทั่วไปที่นักพัฒนาทุกคนต้องเผชิญ ในบทความนี้ เราจะเห็นรูปแบบความจำเป็นแบบดั้งเดิมและโค้ดสไตล์การประกาศสมัยใหม่พร้อมนิพจน์แลมบ์ดาและ API การสตรีม

แนวทางที่จำเป็น

รูปแบบการเขียนโปรแกรมที่จำเป็นนั้นพบเห็นได้ทั่วไปใน Java มานานแล้ว ดังนั้นจึงเป็นเรื่องปกติที่นักพัฒนา Java จะเขียนโค้ดด้านล่างเพื่อคัดลอกส่วนเฉพาะของอาร์เรย์ดั้งเดิม ในการดำเนินการนี้ เพียงวนซ้ำองค์ประกอบต่างๆ กรองเฉพาะองค์ประกอบที่จำเป็นออก แล้วเขียนลงในอาร์เรย์สุดท้าย

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

พวกเราหลายคนมักลืมไปว่าไลบรารี Java Arraysมี เมธอด copyOfRange ที่สะดวก สบาย วิธีนี้สามารถใช้ในการคัดลอกส่วนหนึ่งของอาร์เรย์โดยส่งผ่านเข้าและออกจากดัชนี

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

วิธีการประกาศ

ตั้งแต่ Java 8 เราสามารถใช้ Streams API เพื่อคัดลอกส่วนหนึ่งของอาร์เรย์ได้ ในโค้ดด้านล่าง เราสามารถส่งint[]และกรองเฉพาะค่าที่มากกว่า 3 และสุดท้ายก็คัดลอกค่าเหล่านั้นลงในอาร์เรย์

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

โค้ดด้านบนเป็นการคัดลอกส่วนหนึ่งของอาร์เรย์ตามค่า แต่เราสามารถคัดลอกตามดัชนีได้เช่นกัน ด้านล่างโค้ดที่เราออกอากาศIntstream จาก i=0; i=len(อาร์เรย์) . โดยทั่วไปแล้วในโค้ดที่จำเป็น เราจะเขียนfor loop จากดัชนีเริ่มต้นไปยังดัชนีสิ้นสุด และวนซ้ำแต่ละองค์ประกอบ เราสามารถทำสิ่งเดียวกันได้โดยใช้ Intstream และเข้าถึงองค์ประกอบ ดัชนี

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

แม้ว่าวิธีการข้างต้นจะได้ผล แต่เรามีวิธีอื่นที่เราสามารถใช้AtomicIntegerเพื่อคัดลอกส่วนหนึ่งของอาร์เรย์ได้ มันมี เมธอด getAndIncreaseซึ่งจัดเตรียมดัชนีและเพิ่มค่าทีละ 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));

บทสรุป

ในบทความนี้ เราได้พูดคุยถึงวิธีที่คุณสามารถคัดลอกส่วนหนึ่งของอาร์เรย์ Java โดยใช้สไตล์ที่จำเป็นและการประกาศ ฉันอยากจะทำงานในรูปแบบที่เปิดเผยมากกว่าเพราะจะทำให้โค้ดของฉันอ่านง่ายขึ้นและมีรายละเอียดน้อยลง

อินเทอร์เฟซและคลาสนามธรรมใน Java

ที่มา: Devgenius เมื่อเรียนรู้ภาษา Java เราเจอแนวคิดที่เรียกว่าอินเทอร์เฟซอย่างแน่นอน อินเทอร์เฟซเป็นหนึ่งในคุณสมบัติหลักของ Java ดังนั้นนักพัฒนาทุกคนควรรู้วิธีใช้งาน สิ่งสำคัญคือต้องจำไว้ว่าอินเทอร์เฟซมีทั้งข้อดีและข้อเสีย มาเจาะลึกการทำความเข้าใจอินเทอร์เฟซกันดีกว่า เมื่อนำอินเทอร์เฟซไปใช้ เราจะพบคลาสนามธรรม คลาสนามธรรมคืออะไร? พวกเขาต้องการอะไร? อินเทอร์เฟซคืออะไร? พวกเขาใช้อย่างไร? เหตุใดอินเทอร์เฟซจึงใช้คลาสนามธรรม คุณจะได้รับคำตอบสำหรับคำถามเหล่านี้ทั้งหมดในบทความนี้

อินเทอร์เฟซคืออะไร?

อินเทอร์เฟซเป็นกลไกพิเศษใน Java ที่อธิบายพฤติกรรมและช่วยให้เกิดนามธรรม มันคล้ายกับคลาสในหลายๆ ด้านเพราะมันมีค่าคงที่คงที่และวิธีการเชิงนามธรรม อินเทอร์เฟซสามารถมีเมธอดนามธรรมได้เท่านั้น (เมธอดที่ไม่มีเนื้อหา) ความแตกต่างโดยย่อระหว่างอินเทอร์เฟซและคลาสนามธรรม:

• อินเทอร์เฟซ ไม่มีวิธีการ ใด ๆที่ใช้ มันเป็นแบบสาธารณะทั้งหมดและไม่มีตัวแปรคลาส
• คลาสนามธรรมคือคลาสที่ไม่มีการใช้งานตั้งแต่หนึ่งวิธีขึ้นไป

ตั้งแต่ Java 9 เรายังสามารถใช้ วิธี private , defaultและstatic ใน interfaces ได้ ตอนนี้เรามาดูตรรกะอินเทอร์เฟซแบบธรรมดาที่ใช้เพื่อให้บรรลุสิ่งที่เป็นนามธรรมกัน

สิ่งที่เป็นนามธรรมคืออะไร?

มาดูตัวอย่างชีวิตจริงกัน เราทุกคนใช้แอปบนโทรศัพท์มือถือของเรา เมื่อใดก็ตามที่เราต้องการใช้แอปพลิเคชันใด ๆ เราจะต้องสร้างบัญชีในนั้น เมื่อเราลงทะเบียนผ่านหมายเลขโทรศัพท์ของเรา รหัสผ่านแบบครั้งเดียวจะถูกส่งไปยังโทรศัพท์มือถือของเรา เรารู้ว่าได้รับรหัสผ่านหลังจากคลิกปุ่ม "รับรหัสผ่าน" ในแอปพลิเคชัน แต่เราไม่รู้ว่าระบบนี้ทำงานอย่างไรในแบ็กเอนด์และจะเกิดอะไรขึ้นจริงหลังจากคลิกปุ่ม ตอนนี้ กระบวนการทำงานให้สำเร็จโดยไม่แสดงให้ผู้ใช้เห็นสิ่งที่เกิดขึ้นจริงในแบ็กเอนด์นั้นเรียกว่านามธรรม ใน Java เราสามารถบรรลุสิ่งที่เป็นนามธรรมได้โดยใช้อินเทอร์เฟซและคลาสนามธรรม

ทำไมต้องใช้อินเทอร์เฟซ?

มีเหตุผลสามประการในการใช้อินเทอร์เฟซ:

• เพื่อบรรลุความเป็นนามธรรม
• เพื่อรองรับฟังก์ชันการสืบทอดหลายรายการ
• เพื่อให้เกิดการมีเพศสัมพันธ์ที่หลวม

วิธีใช้อินเทอร์เฟซ?

อินเทอร์เฟซถูกประกาศโดยใช้ คีย์เวิร์ด อินเทอร์ เฟ ซ มันจัดเตรียมสิ่งที่เป็นนามธรรม กล่าวคือ ประกาศโครงสร้างของคลาส วิธีการทั้งหมดในอินเทอร์เฟซเป็นแบบนามธรรมและตั้งค่าเป็นสาธารณะ คงที่ และสุดท้ายตามค่าเริ่มต้น ( public , static , Final ) ไม่ว่าคลาสใดก็ตามจะใช้อินเทอร์เฟซจะต้องใช้วิธีการทั้งหมดที่ประกาศไว้ในอินเทอร์เฟซ

interface <interface_name>{

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

เช่นเดียวกับอินเทอร์เฟซนามธรรม นามธรรมสามารถทำได้โดยใช้คลาสนามธรรม

คลาสนามธรรมคืออะไร?

คลาสนามธรรมคือคลาสที่มี คีย์เวิร์ด abstractอยู่ข้างหน้า มีทั้งวิธีการเชิงนามธรรมและเป็นรูปธรรม (พร้อมเนื้อหา) คลาสนามธรรมไม่สามารถสร้างอินสแตนซ์ได้ แต่จะต้องขยายออกไปและต้องนำวิธีการไปใช้ คลาสนามธรรมอธิบายวัตถุนามธรรมบางอย่าง (รถยนต์ บุคคล ฯลฯ) ไม่ใช่แค่พฤติกรรม จดจำ:

• คลาส นามธรรม จะต้องประกาศด้วย คีย์เวิร์ดabstract
• อาจมีวิธีการเชิงนามธรรมและไม่ใช่นามธรรมก็ได้
• ไม่สามารถสร้างอินสแตนซ์ของคลาสนามธรรมได้
• สามารถมีตัวสร้างและวิธีการคงที่ได้
• อาจมีเมธอดสุดท้ายที่จะบังคับให้คลาสย่อยไม่เปลี่ยนเนื้อหาของเมธอด

ตัวอย่างของคลาสนามธรรมที่มีวิธีนามธรรม: ในตัวอย่างนี้Bikeเป็นคลาสนามธรรมที่มีการรันวิธีนามธรรมเพียงวิธีเดียว การนำไปปฏิบัติ นั้น จัดทำโดย คลาส ฮอนด้า

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

คลาสนามธรรมมีตัวสร้าง สมาชิกข้อมูล และวิธีการ: คลาสนามธรรมสามารถมีสมาชิกข้อมูล วิธีนามธรรม เนื้อความของวิธีการ (วิธีที่ไม่ใช่นามธรรม) ตัวสร้าง และแม้แต่วิธี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();
}
}

ตอนนี้คำถามหลักเกิดขึ้น ถ้าอินเทอร์เฟซและคลาสนามธรรมช่วยในเรื่องนามธรรม จะใช้อันไหนดีกว่ากัน? คำตอบก็คือ Java ไม่รองรับการสืบทอดหลายรายการเหมือนกับ C++ นั่นคือหากเราต้องการได้รับมรดกหลายรายการ เราก็ควรใช้อินเทอร์เฟซ กล่าวอีกนัยหนึ่งคลาสนามธรรมช่วยได้ตั้งแต่ 1 ถึง 100% ของเคส และอินเทอร์เฟซช่วยได้ 100% ของเคส หากเราต้องการพฤติกรรม เราจำเป็นต้องใช้อินเทอร์เฟซ ถ้าเรากำลังพูดถึงวัตถุแนวความคิด เราต้องใช้คลาสนามธรรม

ตัวอย่างอินเทอร์เฟซ Java

ในตัวอย่างนี้ อินเทอร์เฟซ Drawableมีเพียงวิธีเดียวเท่านั้น การ ใช้งานมีให้โดย คลาส สี่เหลี่ยมผืนผ้าและวงกลม ในสถานการณ์จริง อินเทอร์เฟซถูกกำหนดโดยบุคคลอื่นและการนำไปใช้งานจะได้รับจากผู้ให้บริการการใช้งานที่แตกต่างกัน แถมยังมีคนอื่นใช้อีกด้วย ส่วนหนึ่งของการใช้งานถูกซ่อนโดยผู้ใช้โดยใช้อินเทอร์เฟซ

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

การสืบทอดหลายรายการใน Java โดยใช้อินเทอร์เฟซ

หากคลาสใช้หลายอินเทอร์เฟซหรืออินเทอร์เฟซขยายหลายอินเทอร์เฟซ จะเรียกว่าการสืบทอดหลายรายการ

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

คำถาม: ไม่รองรับการสืบทอดหลายรายการผ่านคลาสใน Java แต่สามารถทำได้ผ่านอินเทอร์เฟซ เพราะเหตุใด ดังที่อธิบายไว้แล้วในส่วนการสืบทอด การสืบทอดหลายรายการไม่ได้รับการสนับสนุนในตัวอย่างคลาสเนื่องจากความคลุมเครือ อย่างไรก็ตาม ตัวอย่างอินเทอร์เฟซรองรับเนื่องจากไม่มีความคลุมเครือ เหตุผลก็คือการนำไปปฏิบัตินั้นจัดทำโดยคลาสการนำไปใช้งาน