Hướng dẫn sử dụng Java Generics - GP Coder (Lập trình Java)

Generics là một tính năng của Java giúp cho lập trình viên hoàn toàn có thể chỉ định rõ kiểu tài liệu mà họ muốn thao tác với một class, một interface hay một phương pháp nào đó. Trong bài viết này, tất cả chúng ta sẽ cùng tìm hiểu và khám phá về Generics trong Java .

Tóm Tắt

Tại sao lại cần có Generics ?

Generics là một khái niệm được đưa vào Java từ phiên bản 5. Trước khi đưa ra khái niệm Generics là gì, tất cả chúng ta hãy xem một đoạn code của Java trước phiên bản 5 .Như bạn đã biết ArrayList là một list, bạn hoàn toàn có thể thêm, xóa, sửa và truy vấn vào những thành phần của list .


List list = new ArrayList();

Với khai báo trên, giả định rằng chúng ta mong muốn chỉ làm việc với đối tượng kiểu Integer. Nhưng bởi vì list là một collection của đối tượng Object nên chúng ta có thể sử dụng nó với bất kỳ kiểu dữ liệu nào. Tại nơi nào đó trong chương trình bạn thêm vào danh sách này một phần tử không phải Integer. Khai báo sau sẽ hợp lệ:

Bạn đang đọc: Hướng dẫn sử dụng Java Generics – GP Coder (Lập trình Java)


list.add(10);
list.add("gpcoder.com");
list.add(true);

Như bạn thấy, tôi hoàn toàn có thể thêm những thành phần kiểu Integer, String, Boolean. Tuy nhiên, khi bạn lấy ra những thành phần và ép kiểu về Integer, một ngoại lệ sẽ bị ném ra .Đó là nguyên do của sự thiết yếu phải có của generics trong Java. Với Generics, tất cả chúng ta hoàn toàn có thể chỉ định kiểu tài liệu mà tất cả chúng ta sẽ thao tác ngay thời gian biên dịch ( compile time ) .Ví dụ trên hoàn toàn có thể viết lại như sau :


List list = new ArrayList();

Khi thêm một thành phần không phải kiểu Integer trình biên dịch sẽ báo lỗi ngay :

Một số quy ước đặt tên kiểu tham số Generic

Đặt tên kiểu tham số là rất quan trọng để học Genericics. Nó không bắt buộc, tuy nhiên tất cả chúng ta nên đặt theo quy ước chung để dễ đọc, dễ bảo dưỡng. Các kiểu tham số thường thì như sau :

E- Element (phần tử – được sử dụng phổ biến trong Collection Framework)
K – Key (khóa)
V – Value (giá trị)
N – Number (kiểu số: Integer, Double, Float, …)
T – Type (Kiểu dữ liệu bất kỳ thuộc Wrapper class: String, Integer, Long, Float, …)
S, U, V … – được sử dụng để đại diện cho các kiểu dữ liệu (Type) thứ 2, 3, 4, …

Ký tự Diamond < >

Trong Java 7 và các phiên bản sau, bạn có thể thay thế các đối số kiểu dữ liệu cần thiết để gọi hàm khởi tạo (constructor) của một lớp Generic bằng cặp dấu <>. Trình biên dịch sẽ xác định hoặc suy ra các kiểu dữ liệu từ ngữ cảnh sử dụng.

Ví dụ, bạn có thể tạo một list với câu lệnh sau:

// Trước Java 7
List integerBox = new ArrayList();

// Khai báo sử dụng cặp dấu <> từ phiên bản Java 7 
List integerBox = new ArrayList<>();

Để biết thêm thông tin về ký hiệu <>, bạn xem thêm trên trang document của Oracle.

Kiểu Generic cho Class và Interface

Kiểu Generic cho Class

Ví dụ dưới đây định nghĩa ra một class Generics. KeyValuePair là một class Generics nó chứa một cặp khóa và giá trị ( key / value ) .


package com.gpcoder.generic;

public class KeyValuePair {
	private K key;
	private V value;

	public KeyValuePair(K key, V value) {
		this.key = key;
		this.value = value;
	}

	public K getKey() {
		return key;
	}

	public void setKey(K key) {
		this.key = key;
	}

	public V getValue() {
		return value;
	}

	public void setValue(V value) {
		this.value = value;
	}
}

K, V trong class KeyValuePair được gọi là tham số Generics nó là một kiểu tham chiếu nào đó. Khi sử dụng class này bạn phải xác định kiểu tham số cụ thể.


package com.gpcoder.generic;

public class KeyValuePairExample {
	public static void main(String[] args) {
		KeyValuePair entry = new KeyValuePair("gpcoder", 123456789);
		String name = entry.getKey();
		Integer id = entry.getValue();
		System.out.println("Name = " + name + ", Id = " + id); // Name = gpcoder, Id = 123456789
	}
}

Thừa kế lớp Generics

Một class lan rộng ra từ một class Generics, nó hoàn toàn có thể chỉ định rõ kiểu cho tham số Generics, giữ nguyên những tham số Generics hoặc thêm những tham số Generics .


package com.gpcoder.generic;

public class ContactEntry extends KeyValuePair {

	public ContactEntry(String key, Integer value) {
		super(key, value);
	}

}

Ví dụ sử dụng ContactEntry :


package com.gpcoder.generic;

public class ContactEntryExample {
	public static void main(String[] args) {
		ContactEntry entry = new ContactEntry("gpcoder", 123456789);
		String name = entry.getKey();
		Integer id = entry.getValue();
		System.out.println("Name = " + name + ", Id = " + id); // Name = gpcoder, Id = 123456789
	}
}

Một vài cách sử dụng thừa kế khác :ContactEntry2. java


package com.gpcoder.generic;

public class ContactEntry2 extends KeyValuePair {

	public ContactEntry2(String key, V value) {
		super(key, value);
	}

}

ContactEntry3. java


package com.gpcoder.generic;

public class ContactEntry3 extends KeyValuePair {

	public ContactEntry3(K key, V value) {
		super(key, value);
	}

}

ContactEntry4. java


package com.gpcoder.generic;

public class ContactEntry4 extends KeyValuePair {

	private T obj;

	public ContactEntry4(K key, V value, T obj) {
		super(key, value);
		this.obj = obj;
	}

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}

}

Kiểu Generic cho Interface

Một Interface có tham số Generics :


package com.gpcoder.generic;

public interface GenericDao {

	void insert(T obj);

	void update(T obj);

}

Ví dụ một class setup Interface trên :


package com.gpcoder.generic;

public class GenericDaoImpl implements GenericDao {

	@Override
	public void insert(T obj) {
		// do something
	}

	@Override
	public void update(T obj) {
		// do something
	}

}

Ví dụ 2 class Student và Teacher sử dụng GenericDao trên :

package com.gpcoder.generic;

public class StudentDao extends GenericDaoImpl {
	
}

package com.gpcoder.generic;

public class TeacherDao extends GenericDaoImpl {
	
}

Ví dụ sử dụng những lớp trên :

package com.gpcoder.generic;

public class GenericDaoExample {

	public static void main(String[] args) {
		Student student = new Student(1, "gpcoder", 28);
		StudentDao dao = new StudentDao();
		dao.insert(student);
	}
}

Phương thức generics

Một phương pháp trong class hoặc Interface hoàn toàn có thể sử dụng generic .


package com.gpcoder.generic;

import java.util.Collection;

public class MyUtils {
	public static  int count(Collection collection, T itemToCount) {
		int count = 0;
		for (T item : collection) {
			if (itemToCount.equals(item)) {
				count++;
			}
		}
		return count;
	}
}

Ví dụ sử dụng phương pháp Generics :

package com.gpcoder.generic;

import java.util.ArrayList;
import java.util.List;

public class MyUtilsExample {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("A");
		list.add("B");
		list.add("C");
		list.add("A");
		list.add("C");
		System.out.println(MyUtils.count(list, "A")); // 2
	}
}

Khởi tạo đối tượng người tiêu dùng Generic

Đôi khi bạn muốn khởi tạo một đối tượng Generic:


T obj = new T(); // Error

Việc khởi tạo một đối tượng generic như trên là không được phép, vì không hề tồn tại ở thời điểm chạy của Java. Nó chỉ có ý nghĩa với trình biên dịch kiểm soát code của người lập trình. Mọi kiểu đều như nhau nó được hiểu là Object tại thời điểm chạy của Java.
Muốn khởi tạo đối tượng generic bạn cần cung cấp cho Java đối tượng Class, Java sẽ tạo đối tượng tại thời điểm runtime bằng Java Reflection.


package com.gpcoder.generic;

public class GenericInstance {
	private T obj;

	public GenericInstance(Class aClazz) 
			throws InstantiationException, IllegalAccessException {
		this.obj = (T) aClazz.newInstance();
	}

	public T getObj() {
		return obj;
	}
}

Ví dụ sử dụng phương pháp khởi tạo trên :



package com.gpcoder.generic;

public class GenericInstanceExample {
	public static void main(String[] args) 
			throws InstantiationException, IllegalAccessException {

		GenericInstance generic = new GenericInstance(Student.class);
		Student student = generic.getObj();
		System.out.println(student);
		
	}
}

Mảng Generic

Có thể khai báo một mảng Generic, nhưng không thể khởi tạo một mảng Generic. Vì kiểu generic không hề tồn tại tại thời điểm chạy, List hoặc List đều là List. Generic chỉ có tác dụng với trình biên dịch để kiểm soát code của người lập trình. Điều đó có nghĩa là trình biên dịch của Java cần biết rõ là cái gì mới có thể biên dịch (compile) new T[10];. Nếu không biết rõ nó mặc định coi T là Object.


T[] arr; // Ok

T[] arr2 = new T[5]; // Error

Ví dụ :


package com.gpcoder.generic;

public class GenericArray {
	private T[] array;

	// Contructor.
	public GenericArray(T[] array) {
		this.array = array;
	}

	public T[] getArray() {
		return array;
	}

	// Trả về phần tử cuối cùng của mảng.
	public T getLastElement() {
		if (this.array == null || this.array.length == 0) {
			return null;
		}
		return this.array[this.array.length - 1];
	}
}

Chương trình sử dụng GenericArray:

Xem thêm: Hướng dẫn và ví dụ Java Reflection


package com.gpcoder.generic;

public class GenericArrayExample {
	public static void main(String[] args) {
		// Một mảng các String.
		String[] names = new String[] { "Tom", "Jerry" };

		GenericArray gArray = new GenericArray(names);

		String last = gArray.getLastElement();

		System.out.println("Last Element = " + last);
	}
}

Quay trở lại với vấn đề tại sao Java không hỗ trợ khởi tạo một mảng Generic?

Lý do là kiểu generic không hề tồn tại tại thời điểm chạy, List hoặc List đều là List. Generic chỉ có tác dụng với trình biên dịch để kiểm soát code của người lập trình. Điều đó có nghĩa là trình biên dịch của Java cần biết rõ là cái gì mới có thể biên dịch (compile) new T[10];. Nếu không biết rõ nó mặc định coi T là Object.

Nếu muốn khởi tạo mảng Generic bạn cần phải truyền cho Java đối tượng Class, giúp Java có thể khởi tạo mảng generic tại thời điểm runtime bằng cách sử dụng Java Reflection. Hãy xem ví dụ minh họa:


package com.gpcoder.generic;

import java.lang.reflect.Array;

public class GenericArrayContructor {
	private final int size = 10;
	private Class aClazz;

	private T[] myArray;

	public GenericArrayContructor(Class aClazz) {
		this.aClazz = aClazz;
		myArray = (T[]) Array.newInstance(aClazz, size);
	}

	public T[] getMyArray() {
		return this.myArray;
	}
}

Chương trình sử dụng GenericArrayContructor trên :


package com.gpcoder.generic;

public class GenericArrayContructorExample {
	public static void main(String[] args) {
		GenericArrayContructor generic = new GenericArrayContructor(Integer.class);
		Integer[] myArray = generic.getMyArray();
		myArray[0] = 1;
		myArray[2] = 0;
	}
}

Generics với ký tự đại diện thay mặt

Trong mã Generic, dấu chấm hỏi (?), được gọi là một đại diện (wildcard), nó đại diện cho một loại không rõ ràng. Một kiểu tham số đại diện (wildcard parameterized type) là một trường hợp của kiểu Generic, nơi mà ít nhất một kiểu tham số là wildcard.

Ví dụ của tham số đại diện thay mặt ( wildcard parameterized ) là :

Collection
List
Comparator
Pair.

Các ký tự đại diện thay mặt hoàn toàn có thể được sử dụng trong một loạt những trường hợp : như kiểu của một tham số, trường ( field ), hoặc biến địa phương ; nhiều lúc như một kiểu trả về ( Sẽ được nói rõ hơn trong những ví dụ thực hành thực tế ). Các đại diện thay mặt là không khi nào được sử dụng như thể một đối số cho lời gọi một phương pháp Generic, khởi tạo đối tượng người tiêu dùng class generic, hoặc kiểu cha ( supertype ) .Các ký hiệu đại diện thay mặt nằm ở những vị trí khác nhau có ý nghĩa khác nhau :

Ký tự đại diện : chấp nhận tất cả các loại đối số (chứa mọi kiểu đối tượng). Ví dụ: Collection mô tả một tập hợp chấp nhận tất cả các loại đối số kiểu String, Integer, Boolean, …
Ký tự đại diện : chấp nhận bất ký đối tượng nào miễn là đối tượng này kế thừa từ type hoặc đối tượng của type. Ví dụ: List mô tả một danh sách, nơi mà các phần tử là kiểu Number hoặc kiểu con của Number.
Ký tự đại diện : chấp nhận bất ký đối tượng nào miễn là đối tượng này là cha của type hoặc đối tượng của type. Ví dụ: Comparator Mô tả một bộ so sánh (Comparator) mà thông số phải là String hoặc cha của String.

Một kiểu tham số ký tự đại diện không phải là một loại cụ thể để có thể xuất hiện trong một toán tử new. Nó chỉ là gợi ý các quy tắc thực thi bởi Generics java rằng những loại có giá trị trong bất kỳ tình huống cụ thể mà các kí hiệu đại diện đã được sử dụng.

Ví dụ :


Collection coll = new ArrayList();

// Một tập hợp chỉ chứa kiểu Number hoặc kiểu con của Number
List list = new ArrayList();

// Một đối tượng có kiểu tham số đại diện.
// (A wildcard parameterized type)
Pair pair = new Pair();

Một số khai báo không hợp lệ :


// String không phải là kiểu con của Number, vì vậy lỗi.
List list = new ArrayList();

// String không phải là kiểu cha của Integer vì vậy lỗi
ArrayList cmp = new ArrayList();

Ví dụ với kiểu đại diện thay mặt ( wildcard )

WildCardExample1. java

package com.gpcoder.generic;

import java.util.ArrayList;

public class WildCardExample1 {

	public static void main(String[] args) {

		// Một danh sách chứa các phần tử kiểu String.
		ArrayList listString = new ArrayList();

		listString.add("Tom");
		listString.add("Jerry");

		// Một danh sách chứa các phần tử kiểu Integer
		ArrayList listInteger = new ArrayList();

		listInteger.add(100);

		// Bạn không thể khai báo:
		// ArrayList

WildCardExample2. java

package com.gpcoder.generic;

import java.util.ArrayList;
import java.util.List;

public class WildCardExample2 {

	public static void main(String[] args) {

		List names = new ArrayList();
		names.add("Tom");
		names.add("Jerry");
		names.add("Donald");

		List values = new ArrayList();
		values.add(100);
		values.add(120);

		System.out.println("--- Names --");
		printElement(names);

		System.out.println("-- Values --");
		printElement(values);

	}

	public static void printElement(List list) {
		for (Object e : list) {
			System.out.println(e);
		}
	}

}

Đối tượng đại diện thay mặt không hề sử dụng phương pháp generic

Wildcard không hề tham gia trong toán tử new

Một kiểu tham số ký tự đại diện (wildcard parameterized type) không phải là một loại cụ thể, và nó không thể xuất hiện trong một toán tử new.


// Tham số Wildcard không thể tham gia trong toán tử new.
List list= new ArrayList();

Ưu điểm của Generics

Trên đây là những kiên thức cơ bản về Generic, tôi xin tổng hợp lại những ưu điểm của Generic như sau :

Kiểu dữ liệu an toàn: Chúng ta chỉ có thể giữ được một loại đối tượng trong Generics. Nó không cho phép lưu trữ các loại đối tượng khác.
Kiểm tra dữ liệu chặt chẽ ở Compile-time mà không phải là Runtime-error. Nên chúng ta sẽ dễ dàng kiểm soát lỗi hơn.
Hạn chế việc ép kiểu (cast) thủ công mà không an toàn.
Giúp chúng ta viết các thuật toán được sử dụng nhiều (reusable), dễ dàng thay đổi, an toàn dữ liệu và dễ đọc hơn. Nó rất hữu ích cho những người viết software libraries (thư viện phần mềm) làm sao để generic programming (lập trình có tính tổng quát) vì nó cho phép người dùng sử dụng ở nhiều tình huống khác nhau.

Một số hạn chế khi sử dụng Generics

Không thể gọi Generics bằng kiểu dữ liệu nguyên thủy (Primitive type: int, long, double, …), thay vào đó sử dụng các kiểu dữ liệu Object (wrapper class thay thế: Integer, Long, Double, …).
Không thể tạo instances của kiểu dữ liệu Generics, thay vào đó sử dụng reflection từ class (xem ví dụ ở trên).
Không thể sử dụng static cho Generics.


private static T obj; // compile-time error

Không thể ép kiểu hoặc sử dụng instanceof.


public static  void rtti(List list) {
     if (list instanceof ArrayList) {  // compile-time error
     // ...
     }
}

List li = new ArrayList();
List  ln = (List) li;  // compile-time error

Không thể tạo mảng với parameterized types (như đã nói ở phần trên).
Không thể tạo, catch, throw đối tượng của parameterized types (Generic Throwable). Vì thông tin Generic chỉ sử dụng cho trình biên dịch kiểm soát code của người lập trình. Trong thời điểm chạy Java thông tin Generic không hề tồn tại.


// Extends Throwable indirectly
class MathException extends Exception { /* ... */ } // compile-time error

// Extends Throwable directly
class QueueFullException extends Throwable { /* ... */ // compile-time error

Không thể overload các hàm trong một lớp giống như:


public class Example {
    public void print(Set strSet) { }
    public void print(Set intSet) { }
}

Tài liệu tham khảo:

5.0

Xem thêm: [Tự học Java] Ghi đè(Overriding) phương thức trong Java » https://final-blade.com – Chickgolden

Nếu bạn thấy hay thì hãy chia sẻ bài viết cho mọi người nhé!

Bình luận

phản hồi

Source: https://final-blade.com
Category: Kiến thức Internet

admin

final-blade.com