Nghỉ giải lao #133. Cách chỉ lấy một phần của mảng trong Java. Giao diện và lớp trừu tượng trong Java

Cách chỉ lấy một phần của mảng trong Java

Nguồn: Asyncq Sao chép một phần của mảng là thao tác rất phổ biến mà mọi nhà phát triển đều gặp phải. Trong bài viết này, chúng ta sẽ thấy kiểu mệnh lệnh truyền thống và mã kiểu khai báo hiện đại với biểu thức lambda và API phát trực tuyến.

Cách tiếp cận cấp bách

Phong cách lập trình mệnh lệnh từ lâu đã phổ biến trong Java. Do đó, việc các nhà phát triển Java viết đoạn mã dưới đây để sao chép một phần cụ thể của mảng ban đầu là điều đương nhiên. Để làm điều này, chỉ cần lặp qua các phần tử, chỉ lọc ra những phần tử cần thiết và ghi chúng vào mảng cuối cùng.

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

Nhiều người trong chúng ta thường quên rằng thư viện Java Arrays có phương thức copyOfRange rất tiện lợi . Phương thức này có thể được sử dụng để sao chép một phần của mảng bằng cách chuyển đến và đi từ chỉ mục.

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

Cách tiếp cận khai báo

Kể từ Java 8, chúng tôi có thể sử dụng API Streams để sao chép một phần của mảng. Trong đoạn mã bên dưới, chúng ta có thể truyền int[] và chỉ lọc ra các giá trị lớn hơn 3 và cuối cùng sao chép chúng vào một mảng.

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

Đoạn mã trên là bản sao dựa trên giá trị của một phần của mảng, nhưng chúng ta cũng có thể sao chép dựa trên chỉ mục. Bên dưới mã chúng tôi phát Intstream từ i=0; i=len(mảng) . Thông thường trong mã mệnh lệnh, chúng ta viết một vòng lặp for từ chỉ mục bắt đầu đến chỉ mục kết thúc và lặp lại từng phần tử. Chúng ta có thể làm điều tương tự bằng cách sử dụng Intstream và truy cập phần tử chỉ mục .

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

Trong khi phương pháp trên hoạt động, chúng ta có một cách khác để có thể sử dụng AtomicInteger để sao chép một phần của mảng. Nó có một phương thức getAndIncrement về cơ bản cung cấp một chỉ mục và tăng nó lên 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));

Phần kết luận

Trong bài viết này, chúng ta đã thảo luận về cách bạn có thể sao chép một phần của mảng Java bằng cách sử dụng các kiểu mệnh lệnh và khai báo. Tôi thích làm việc theo phong cách khai báo hơn vì nó làm cho mã của tôi dễ đọc hơn và ít dài dòng hơn.

Giao diện và lớp trừu tượng trong Java

Nguồn: Devgenius Khi học ngôn ngữ Java, chúng ta chắc chắn sẽ gặp một khái niệm gọi là Giao diện. Giao diện là một trong những tính năng chính của Java, vì vậy mọi nhà phát triển nên biết cách sử dụng chúng. Điều quan trọng cần nhớ là giao diện đều có cả ưu điểm và nhược điểm. Hãy đi sâu hơn vào việc tìm hiểu các giao diện. Khi triển khai các giao diện, chúng ta gặp phải các lớp trừu tượng. Các lớp trừu tượng là gì? Họ cần chúng để làm gì? Giao diện là gì? Chúng được sử dụng như thế nào? Tại sao giao diện sử dụng các lớp trừu tượng? Bạn sẽ nhận được câu trả lời cho tất cả những câu hỏi này trong bài viết này.

Giao diện là gì?

Giao diện là một cơ chế đặc biệt trong Java mô tả hành vi và giúp đạt được tính trừu tượng. Nó giống với một lớp theo nhiều cách vì nó có các hằng tĩnh và các phương thức trừu tượng. Các giao diện chỉ có thể có các phương thức trừu tượng (các phương thức không có phần thân). Sự khác biệt ngắn gọn giữa giao diện và lớp trừu tượng:

• Giao diện không có bất kỳ phương thức nào được triển khai; chúng đều công khai và không có biến lớp.
• Lớp trừu tượng là lớp không có một hoặc nhiều phương thức được triển khai.

Kể từ Java 9, chúng ta cũng có thể sử dụng các phương thức riêng tư , mặc định và tĩnh trong giao diện . Bây giờ chúng ta hãy chuyển sang logic giao diện đơn giản được sử dụng để đạt được sự trừu tượng hóa.

trừu tượng là gì?

Hãy lấy một ví dụ thực tế. Tất cả chúng ta đều sử dụng ứng dụng trên điện thoại di động của mình. Bất cứ khi nào chúng ta muốn sử dụng bất kỳ ứng dụng nào, chúng ta phải tạo một tài khoản trong đó. Khi chúng tôi đăng ký qua số điện thoại của mình, mật khẩu một lần sẽ được gửi đến điện thoại di động của chúng tôi. Chúng tôi biết rằng mật khẩu được nhận sau khi nhấp vào nút “Lấy mật khẩu” trong ứng dụng, nhưng chúng tôi không biết hệ thống này hoạt động như thế nào trong phần phụ trợ và điều gì thực sự xảy ra sau khi nhấp vào nút. Bây giờ, quá trình hoàn thành thành công các nhiệm vụ mà không hiển thị cho người dùng những gì đang thực sự xảy ra trong phần phụ trợ được gọi là trừu tượng hóa. Trong Java, chúng ta có thể đạt được sự trừu tượng hóa bằng cách sử dụng các giao diện và các lớp trừu tượng.

Tại sao nên sử dụng giao diện?

Có ba lý do để sử dụng giao diện:

• Để đạt được sự trừu tượng.
• Để hỗ trợ nhiều chức năng kế thừa.
• Để đạt được khớp nối lỏng lẻo.

Làm thế nào để sử dụng giao diện?

Một giao diện được khai báo bằng từ khóa giao diện . Nó cung cấp sự trừu tượng, nghĩa là nó khai báo cấu trúc của lớp. Tất cả các phương thức trong một giao diện đều trừu tượng và được đặt thành công khai, tĩnh và cuối cùng theo mặc định ( public , static , Final ). Bất cứ lớp nào triển khai giao diện đều phải triển khai tất cả các phương thức được khai báo trong giao diện.

interface <interface_name>{

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

Tương tự như trừu tượng hóa giao diện, sự trừu tượng hóa cũng có thể đạt được bằng cách sử dụng các lớp trừu tượng.

Các lớp trừu tượng là gì?

Các lớp trừu tượng là các lớp có từ khóa trừu tượng ở phía trước chúng. Chúng chứa cả phương pháp trừu tượng và cụ thể (có phần thân). Các lớp trừu tượng không thể được khởi tạo, chúng phải được mở rộng và các phương thức của chúng phải được triển khai. Một lớp trừu tượng mô tả một số đối tượng trừu tượng (ô tô, con người, v.v.), không chỉ hành vi. Nhớ:

• Một lớp trừu tượng phải được khai báo bằng từ khóa abstract .
• Có thể có các phương pháp trừu tượng và không trừu tượng.
• Không thể tạo một thể hiện của lớp trừu tượng.
• Nó có thể có các hàm tạo và các phương thức tĩnh.
• Nó có thể có các phương thức cuối cùng sẽ buộc lớp con không thay đổi nội dung phương thức.

Ví dụ về lớp trừu tượng có phương thức trừu tượng: Trong ví dụ này , Bike là lớp trừu tượng chỉ chứa một phương thức trừu tượng chạy. Việc thực hiện nó được cung cấp bởi lớp 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();
}
}

Lớp trừu tượng có hàm tạo, thành viên dữ liệu và phương thức: Lớp trừu tượng có thể có thành viên dữ liệu, phương thức trừu tượng, nội dung phương thức (phương thức không trừu tượng), hàm tạo và thậm chí cả phương thức 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();
}
}

Bây giờ câu hỏi chính được đặt ra. Nếu các giao diện và các lớp trừu tượng giúp ích cho việc trừu tượng hóa thì nên sử dụng cái nào tốt hơn? Câu trả lời là Java không hỗ trợ đa kế thừa như C++. Nghĩa là, nếu chúng ta cần đạt được tính đa kế thừa thì chúng ta nên sử dụng giao diện. Nói cách khác, các lớp trừu tượng trợ giúp từ 1 đến 100% trường hợp và giao diện trợ giúp trong 100% trường hợp. Nếu chúng ta cần hành vi, chúng ta cần sử dụng giao diện. Nếu chúng ta đang nói về một đối tượng khái niệm, chúng ta phải sử dụng một lớp trừu tượng.

Ví dụ về giao diện Java

Trong ví dụ này, giao diện Drawable chỉ có một phương thức. Việc triển khai nó được cung cấp bởi các lớp Hình chữ nhật và Hình tròn . Trong kịch bản thực, giao diện được xác định bởi người khác và việc triển khai nó được cung cấp bởi các nhà cung cấp triển khai khác nhau. Hơn nữa, nó đang được người khác sử dụng. Một phần của quá trình triển khai được người dùng ẩn bằng giao diện.

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

Đa kế thừa trong Java bằng giao diện

Nếu một lớp triển khai nhiều giao diện hoặc một giao diện mở rộng nhiều giao diện thì nó được gọi là đa kế thừa.

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

Câu hỏi: Tính đa kế thừa không được hỗ trợ thông qua một lớp trong Java, nhưng có thể thực hiện được thông qua một giao diện, tại sao? Như đã giải thích trong phần về kế thừa, đa kế thừa không được hỗ trợ trong ví dụ về lớp do tính mơ hồ. Tuy nhiên, nó được hỗ trợ bởi ví dụ về giao diện vì không có sự mơ hồ trong đó. Lý do là việc triển khai nó được cung cấp bởi lớp triển khai.