Rate this post

Một Interfaces trong ngôn ngữ lập trình Java được định nghĩa là một loại trừu tượng(abstract) được sử dụng để chỉ định hành vi của một Class. Interfaces trong Java là bản thiết kế của một hành vi. Một Interfaces Java chứa các hằng số tĩnh và các methods trừu tượng.

Các bài viết liên quan:

Interfaces trong Java là một cơ chế để đạt được sự trừu tượng hóa. Chỉ có thể có các phương thức trừu tượng trong Interfaces Java, không phải phần thân phương thức. Nó được sử dụng để đạt được sự trừu tượng hóa và đa kế thừa trong Java. Nói cách khác, bạn có thể nói rằng các Interfaces có thể có các phương thức và biến trừu tượng. Nó không thể có phần thực thi phương thức. Interfaces Java cũng đại diện cho mối quan hệ IS-A.

  • Khi chúng ta quyết định một loại thực thể theo hành vi của nó chứ không phải thông qua thuộc tính, chúng ta nên xác định nó như một Interfaces.
  • Giống như một Class, một Interfaces có thể có các phương thức và biến, nhưng các phương thức được khai báo trong một Interfaces theo mặc định là trừu tượng (chỉ có khai báo phương thức, không có phần thực thi).
  • Các Interfaces xác định những gì một Class phải làm và không làm như thế nào. Đó là kế hoạch chi tiết của hành vi.
  • Interfaces không có hàm constructor.
  • Thể hiện hành vi dưới dạng Interfaces trừ khi mọi loại con của Class được đảm bảo có hành vi đó.
  • Interfaces là như các Player có thể là một Interfaces và bất kỳ Class nào implement interface phải có khả năng (hoặc phải triển khai) move(). Vì vậy, nó chỉ định một tập hợp các phương thức mà Class phải thực hiện.
  • Nếu một Class cài đặt một Interfaces và không cung cấp các phần thân phương thức cho tất cả các method được chỉ định trong Interfaces, thì Class đó phải được khai báo trừu tượng.

Cú pháp:

Interfaces {

     // khai báo trường hằng
     // khai báo các phương thức trừu tượng
     // theo mặc định.
}

Để khai báo một Interfaces, hãy sử dụng từ khóa Interfaces. Nó được sử dụng để cung cấp sự trừu tượng hóa tổng thể. Điều đó có nghĩa là tất cả các phương thức trong một Interfaces được khai báo với một phần thân trống và được công khai và tất cả các trường là công khai, tĩnh và cuối cùng theo mặc định. Một Class thực hiện Interfaces phải thực hiện tất cả các phương thức được khai báo trong Interfaces. Để triển khai Interfaces, hãy sử dụng từ khóa implements.

Tại sao chúng ta sử dụng Interfaces?

  • Nó được sử dụng để đạt được sự trừu tượng hóa hoàn toàn.
  • Vì java không hỗ trợ nhiều kế thừa trong trường hợp của Class, nên bằng cách sử dụng một Interfaces, nó có thể đạt được nhiều kế thừa.
  • Bất kỳ Class nào cũng chỉ có thể kế thừa 1 Class nhưng bất kỳ Class nào cũng có thể implement vô số Interfaces.
  • Các Interfaces được sử dụng để thực hiện trừu tượng hóa. Vì vậy, câu hỏi đặt ra là tại sao lại sử dụng Interfaces khi chúng ta có các abstract classes? Lý do là, các Class trừu tượng có thể chứa các biến non-final, trong khi các biến trong Interfaces là final, public và static.
// interface đơn giản

interface Player
{
    final int id = 10;
    int move();
}

Sự khác biệt giữa Class và Interfaces

Sự khác biệt chính giữa một Class và một Interfaces là:

  • Trong Class, bạn có thể khởi tạo các biến và tạo một đối tượng. Trong một Interfaces, bạn không thể khởi tạo các biến và tạo một đối tượng.
  • Class có thể chứa các phương thức cụ thể (có triển khai) Interfaces không được chứa các phương thức (có triển khai) cụ thể
  • Các chỉ định truy cập được sử dụng với các Class là riêng tư, được bảo vệ và công khai. Trong Interfaces, chỉ có một bộ xác định được sử dụng- Công khai.

Thực hiện: Để thực hiện một Interfaces, chúng tôi sử dụng từ khóa thực hiện

// Chương trình Java để chứng minh hoạt động của
// giao diện

import java.io.*;

//  interface đơn giản
interface In1 {

	// khai báo public, static và final
	final int a = 10;

	//phương thức trừu tượng
	void display();
}

// Một lớp cài đặt giao diện.
class TestClass implements In1 {

	// Triển khai các phương thức của interface
	public void display(){
	System.out.println("display");
	}

	// hàm main
	public static void main(String[] args)
	{
		TestClass t = new TestClass();
		t.display();
		System.out.println(a);
	}
}

Ví dụ trong thế giới thực: Hãy xem xét ví dụ về các phương tiện như xe đạp, ô tô, xe đạp………, chúng có các chức năng chung. Vì vậy, chúng tôi tạo một Interfaces và đặt tất cả các chức năng phổ biến này. Và hãy để Xe đạp, Xe đạp, xe hơi ….vv triển khai tất cả các chức năng này trong Class của riêng chúng theo cách riêng của chúng.

// Chương trình Java để chứng minh
// ví dụ thực tế về interface

import java.io.*;

interface Vehicle {
	
	// tất cả đều là phương thức trừu tượng.
	void changeGear(int a);
	void speedUp(int a);
	void applyBrakes(int a);
}

class Bicycle implements Vehicle{
	
	int speed;
	int gear;
	
	// to change gear
	@Override
	public void changeGear(int newGear){
		
		gear = newGear;
	}
	
	// sang số
	@Override
	public void speedUp(int increment){
		
		speed = speed + increment;
	}
	
	// tăng speed
	@Override
	public void applyBrakes(int decrement){
		
		speed = speed - decrement;
	}
	
	public void printStates() {
		System.out.println("speed: " + speed
			+ " gear: " + gear);
	}
}

class Bike implements Vehicle {
	
	int speed;
	int gear;
	
	// sang số
	@Override
	public void changeGear(int newGear){
		
		gear = newGear;
	}
	
	// tăng speed
	@Override
	public void speedUp(int increment){
		
		speed = speed + increment;
	}
	
	// giảm tốc độ
	@Override
	public void applyBrakes(int decrement){
		
		speed = speed - decrement;
	}
	
	public void printStates() {
		System.out.println("speed: " + speed
			+ " gear: " + gear);
	}
	
}
class GFG {
	
	public static void main (String[] args) {
	
		// tạo một thể hiện của Xe đạp // thực hiện một số thao tác
		Bicycle bicycle = new Bicycle();
		bicycle.changeGear(2);
		bicycle.speedUp(3);
		bicycle.applyBrakes(1);
		
		System.out.println("Bicycle present state :");
		bicycle.printStates();
		
		// tạo thể hiện của chiếc xe đạp.
		Bike bike = new Bike();
		bike.changeGear(1);
		bike.speedUp(4);
		bike.applyBrakes(3);
		
		System.out.println("Bike present state :");
		bike.printStates();
	}
}

Ưu điểm của Interfaces trong Java

Ưu điểm của việc sử dụng các Interfaces trong Java như sau:

Không bận tâm về phần triển khai, chúng ta có thể đạt được sự an toàn khi triển khai.

Trong Java, nhiều kế thừa không được phép, tuy nhiên, bạn có thể sử dụng một Interfaces để tận dụng nó vì bạn có thể triển khai nhiều hơn một Interfaces.

Các tính năng mới được thêm vào Interfaces trong JDK 8

Trước JDK 8, Interfaces không thể xác định việc triển khai. Bây giờ chúng ta có thể thêm cài đặt mặc định cho các phương thức Interfaces. Việc triển khai mặc định này có một cách sử dụng đặc biệt và không ảnh hưởng đến ý định đằng sau các Interfaces.

Giả sử chúng ta cần thêm một chức năng mới trong Interfaces hiện có. Rõ ràng, mã cũ sẽ không hoạt động vì các Class chưa triển khai các chức năng mới đó. Vì vậy, với sự trợ giúp của việc triển khai mặc định, chúng tôi sẽ cung cấp phần thân mặc định cho các chức năng mới được thêm vào. Sau đó, các mã cũ sẽ vẫn hoạt động.

// Chương trình Java để chỉ ra rằng các interface có thể
// có các phương thức từ JDK 1.8 trở đi
interface In1
{
	final int a = 10;
	default void display()
	{
		System.out.println("hello");
	}
}

// Một lớp cài đặt interface.
class TestClass implements In1
{
	code hàm main
	public static void main (String[] args)
	{
		TestClass t = new TestClass();
		t.display();
	}
}

2. Một tính năng khác đã được thêm vào trong JDK 8 là giờ đây chúng ta có thể định nghĩa các phương thức tĩnh trong các Interfaces có thể được gọi độc lập mà không cần đối tượng. Lưu ý: các phương thức này không được kế thừa.

// Chương trình Java để chỉ ra rằng các giao diện có thể
// có các phương thức từ JDK 1.8 trở đi

interface In1
{
	final int a = 10;
	static void display()
	{
		System.out.println("hello");
	}
}

// Một lớp cài đặt giao diện.
class TestClass implements In1
{
	//hàm main
	public static void main (String[] args)
	{
		In1.display();
	}
}

Extending Interfaces

Một Interfaces có thể kế thừa một Interfaces khác bằng cách sử dụng từ khóa extend. Khi một Class cài đặt một Interfaces kế thừa một Interfaces khác, nó phải cung cấp cách triển khai cho tất cả các phương thức mà chuỗi kế thừa Interfaces yêu cầu.

interface A{
	void method1();
	void method2();
}
// B hiện bao gồm phương thức 1 và phương thức 2
interface B extends A{
	void method3();
}
// lớp phải thực hiện tất cả các phương thức của A và B.
class gfg implements B{
	public void method1(){
	system.out.println("Method 1");
	}
	public void method2(){
	system.out.println("Method 2");
	}
	public void method3(){
	system.out.println("Method 3");
	}
}

Những điểm quan trọng về Interfaces:

Chúng ta không thể tạo một thể hiện (không thể khởi tạo Interfaces) của Interfaces nhưng chúng ta có thể tạo tham chiếu của nó tham chiếu đến Đối tượng của Class triển khai của nó.

  • Một Class có thể thực hiện nhiều hơn một Interfaces.
  • Một Interfaces có thể extend sang Interfaces hoặc Interfaces khác (nhiều hơn một Interfaces).
  • Một Class thực hiện Interfaces phải thực hiện tất cả các phương thức trong Interfaces.
  • Tất cả các phương thức là public và abstract. Và tất cả các trường là public, static, và final.
  • Nó được sử dụng để đạt được nhiều kế thừa.

Từ Java 9 trở đi, các Interfaces cũng có thể chứa những thứ sau:

  1. Static methods
  2. Private methods
  3. Private Static methods

Trả lời

Email của bạn sẽ không được hiển thị công khai. Các trường bắt buộc được đánh dấu *

Contact Me on Zalo
Call now