泛型

什么是泛型泛型泛型仿制藥？它與類型參數化有何不同？

什么是仿制藥？

泛型是編程語言的一項功能，允許在定義類、面試目助接口和方法時使用類型參數。題庫提升實際使用時指定具體類型，道經典題的原所有使用泛型參數的理解理地方都會統一，保證類型一致。泛型泛型泛型類型參數化是面試目助將類型參數應用于現有代碼的過程，例如參數化類或接口的題庫提升特定類型。泛型和類型參數化之間的道經典題的原區別在于，泛型是理解理一種特殊類型，它將澄清類型的泛型泛型泛型工作推遲到創建對象或調用方法時，而類型參數化將類型參數應用于已經存在的面試目助類型。有一個編碼過程。題庫提升

//通用public class Box { private T t;公共無效集（T t）{ this.t=t; } 公共T get() { 返回t; } }//類型參數化，道經典題的原使用具體的理解理String類型應用代碼過程中，import java.util.ArrayList; public class Main { public static void main(String[] args) { //使用類型參數化創建ArrayList 對象ArrayList stringList=new ArrayList(); //添加元素到ArrayList stringList.add('Hello'); stringList.add('世界'); //遍歷ArrayList并輸出元素for (String str : stringList) { System.out.println(str); } } }泛型的主要用途是什么呢？

通用用途

提高類型安全性：泛型提供編譯時類型檢查，可以在早期發現并避免類型錯誤，提高程序的健壯性和可維護性。提高代碼的可重用性：通過參數化類型，泛型可以使類、接口或方法適用于多種數據類型，提高代碼的可重用性。提高程序靈活性：泛型使程序能夠適應不同數據類型的操作，提高程序的靈活性和可擴展性。什么是通用通配符？它有什么用途？

通用通配符

泛型通配符是一種表示未知類型的語法，可以用來解決泛型不協變的問題。使用泛型時通配符可以提供更大的靈活性。可以是問號（ ）表示任意類型，也可以是問號后跟上限（extends upper limit）或下限（super lower limit）表示某種類型的范圍。通用通配符的用途包括：

通用容器類：通配符允許使用同一個容器類來存儲不同類型的對象。例如，List可以存儲任何類型的對象。動態類型操作：某些情況下，運行時需要根據實際情況對不同類型的對象進行處理，而通配符可以幫助實現這種動態類型操作。例如，您可以使用通配符來調用接受不同類型參數的方法，并在運行時確定具體類型。類型轉換：通配符可以幫助進行類型轉換，特別是當您需要將一種類型的對象轉換為另一種類型的對象時。例如，您可以使用通配符將父類對象轉換為子類對象。導入java.util.ArrayList；導入java.util.List； public class Main { public static void main(String[] args) { //使用泛型通配符創建容器class List list=new ArrayList(); //動態類型操作：根據實際需要添加不同類型的對象list.add('Hello'); //添加字符串類型list.add(123); //添加整數類型list.add(new Object()); //添加Object類型//動態類型操作：根據實際需要調用方法processElements(list)； } //使用泛型通配符的方法接受任意類型的參數，并在運行時判斷具體類型public static void processElements(List elements) { for (Object obj : elements) { if (obj instanceof String) { System.out. println('String: ' + obj);} else if (obj instanceof Integer) { System.out.println('Integer: ' + obj );} else if (obj instanceof Object) { System.out.println('Object : ' + obj);} } } }什么是通用限定？它能解決什么問題？

通用資格

泛型限定是對泛型類型參數的約束。它通過在泛型類型參數之前添加限定符來限制泛型的使用范圍。泛型限定可以解決以下問題： 類型安全問題：使用泛型時，需要對泛型的類型進行一定的限制，以保證類型安全。例如，當需要將字符串賦值給對象類型的變量時，需要確保該變量只能存儲特定類型的對象，以避免運行時錯誤。代碼可讀性問題：需要限制泛型的類型參數，使代碼更具可讀性和易理解性。例如，當我們需要定義一個只能存儲整數的泛型容器時，我們可以使用泛型限定來限制泛型的類型參數為Integer或其子類。代碼復用性問題：不同的泛型類型參數需要進行不同的處理，以實現代碼復用。例如，當需要定義一個可以接受不同類型的參數并在運行時確定具體類型的方法時，可以使用泛型限定來限制泛型類型參數的范圍。

導入java.util.ArrayList；導入java.util.List； public class Main { public static void main(String[] args) { //創建一個只能存儲整數的通用容器List intList=new ArrayList(); intList .add(1); intList.add(2); intList.add(3); //輸出整數列表中的元素for (Integer num : intList) { System.out.println(num); } } }什么是原始類型和參數化類型？他們之間有什么區別？原始類型和參數化類型是Java 泛型中的兩種類型。原始類型是使用泛型參數之前的類型，例如List、Set 等。參數化類型是使用泛型參數的類型，例如List、Set 等。原始類型和參數化類型之間的主要區別在于編譯時類型安全性檢查和運行時類型信息。原始類型在編譯時不會進行類型安全檢查，因此無法保證類型正確性。在運行時，如果發生類型不匹配，則會拋出ClassCastException。參數化類型在編譯時進行類型安全檢查，這有助于在編譯時捕獲許多與類型相關的錯誤。在運行時，由于類型已經參數化，因此不會出現類型不匹配的情況。

//基本類型List list1=new ArrayList(); list1.add('你好');列表1.add(123); //允許將不同類型的元素添加到同一個集合中//參數化類型List list2=new ArrayList(); list2.add('你好'); //允許添加String 類型的元素list2.add(123); //編譯時錯誤，不允許添加Integer類型的元素。泛型有哪些限制？它們的作用是什么？

約束情況

泛型的主要約束如下： 引用類型約束：T必須是引用類型，即T必須是類或接口。它是泛型約束中最基本的約束，保證了泛型參數的類型安全。值類型約束：T必須是值類型，即T必須是結構體（struct）或者基本數據類型（如int、char等）。該約束主要用于限制泛型參數的類型范圍，以保證泛型代碼的安全性和正確性。構造函數類型約束：T 必須具有公共無參構造函數。該約束主要用于保證在創建泛型實例時能夠正確初始化泛型對象。轉換類型約束：T必須是指定的類型，比如T必須是實現某個接口的類型，或者T必須是某個類的子類。該約束主要用于限制泛型參數的類型轉換范圍，以保證泛型代碼的安全性和正確性。約束的主要作用是限制泛型參數的類型范圍，保證泛型代碼的安全性和正確性。通過限制泛型參數的類型范圍，可以避免類型不匹配問題，減少運行時錯誤的發生，提高代碼的可維護性和可讀性。同時，這些約束也可以幫助開發人員更好地理解和使用泛型，提高開發效率和代碼質量。泛型類型參數的默認值是什么？我可以為其指定默認值嗎？在Java中，泛型類型參數沒有默認值。泛型參數是類型參數化的基礎。實例化類或方法時需要顯式指定具體類型參數，而不是默認值。例如，對于泛型類List，您不能期望T 有默認值，因為T 可以是任何類型，包括自定義類型。同樣，對于通用方法，例如public void printList(List list)，不能期望T 具有默認值。不能為泛型類型參數指定默認值。實例化泛型類或調用泛型方法時，必須顯式指定泛型參數的類型。什么是泛型方法？它能解決什么問題？泛型方法是一種在方法中使用泛型的技術。泛型方法允許我們在方法中使用一個或多個類型參數，從而使該方法適用于許多不同類型的數據。泛型方法可以解決以下問題： 類型安全問題：泛型方法可以避免運行時的類型轉換異常，提高代碼的安全性和穩定性。代碼復用問題：通過使用泛型，我們可以編寫一次代碼，然后在不同類型的數據上復用，避免為不同類型的數據編寫相似但不同的代碼，提高代碼的復用性。類型參數化：泛型方法允許我們使用類型參數，使代碼更加靈活和可維護。我們可以使用通配符來處理多種不同的類型，使代碼更加簡潔明了。

導入java.util.*; public class GenericMethodExample { //泛型方法，接受兩個泛型參數T和U，返回一個Map類型集合public static Set items(Map map) { return map.entrySet(); } } public static void main(String[] args) { //創建一個Map類型的集合Map map=new HashMap(); map.put('一', 1); map.put('二', 2);地圖.put('三', 3); //使用泛型方法獲取Map Set中鍵值對的集合entrySet=entries(map); for (Map.Entry 條目： EntrySet) { System.out.println('Key:' + entry.getKey() + ', Value:' + entry.getValue()); } } } 泛型和繼承之間有什么關系？泛型和繼承都是提高代碼可重用性和靈活性的重要手段。雖然它們在某些方面相似，但它們的目標和機制不同。泛型更注重類型處理，允許在編譯時指定類型；而繼承更注重類之間的關系，允許子類繼承父類的屬性和方法。在實際編程中，可以根據具體情況選擇使用泛型或繼承，或者組合使用，以實現更好的代碼組織和設計。泛型是一種編程技術，它在編譯時執行類型檢查，并允許程序員在定義類、接口或方法時使用類型參數。當實例化對象或調用方法時，這些類型參數將被具體類型替換。泛型的主要目的是提高代碼的可重用性和靈活性，同時減少類型轉換錯誤。繼承是面向對象編程中的一個概念，它允許一個類繼承另一個類的屬性和方法。通過繼承，子類可以重用父類的代碼，擴展或重寫父類的行為。繼承是實現代碼重用和多態性的一種手段。探索泛型和繼承之間的關系。

代碼可重用性：繼承和泛型都可以提高代碼的可重用性。通過繼承，子類可以復用父類的代碼；通過泛型，類或方法可以在不同類型上重用。

靈活性：泛型和繼承都增加了代碼的靈活性。使用泛型，一個類或方法可以處理許多不同的類型；通過繼承，子類可以根據需要擴展或修改父類的行為。

多態性：多態性是面向對象編程中的一個重要概念，它允許不同的對象對同一消息做出不同的響應。對于泛型和繼承，它們都可以支持多態性。泛型提供編譯時多態性，而繼承則提供運行時多態性。類型處理：對于泛型，類型參數在使用前必須顯式指定；在繼承的情況下，子類會自動繼承父類的類型。什么是泛型類型擦除？為什么Java 中需要泛型？

類型擦除

類型擦除是一種在編譯期間顯式刪除程序的類型系統的計算機編程方法。操作語義不要求程序附帶類型。這稱為“類型擦除語義”。在Java中，泛型是在JDK 5之后引入的，而Java本身并沒有參數化類型系統。為了解決這個問題，Java在編譯后使用類型擦除從字節碼中刪除通用信息，從而保持與舊版本Java的兼容性。擦除還確保編譯和運行時的相同行為。這意味著每當定義泛型類型時，都會自動提供相應的基元類型（即泛型類型的名稱減去類型參數）。類型變量將被刪除并替換為其限定類型（或用于非限定變量的Object）。 Java泛型中類型擦除的必要性主要是出于以下原因： 1、與舊版本Java編譯器和虛擬機的兼容性。由于泛型的實現需要改變Java類文件格式，類型擦除可以將所有類型轉換為Object類型，允許Java編譯器在編譯時檢查類型安全，而不會在運行時造成類型錯誤。 2. 確保編譯和運行時的行為相同。什么是泛型中的類型推斷？它是如何工作的？泛型中的類型推斷是在調用方法時根據參數類型和返回類型自動確定泛型類型參數的過程。類型推斷在編譯時自動發生，不需要在代碼中顯式指定類型參數。類型推斷基于以下規則進行：

方法調用參數類型：編譯器首先查看方法調用的參數類型。這些參數類型用于推斷泛型類型參數的可能范圍。例如，如果使用String 類型的參數調用方法，則編譯器會將String 視為泛型類型參數的可能選項。

方法返回類型：除了參數類型之外，編譯器還會考慮方法的返回類型。返回類型可以進一步限制泛型類型參數的可能范圍。例如，如果方法的返回類型是List，編譯器會將泛型類型參數限制為String或其子類。

上下文信息：除了方法調用的參數和返回類型之外，編譯器還會考慮其他上下文信息，例如方法的簽名、變量聲明等。這些信息有助于編譯器更準確地推斷泛型類型參數。

推理過程：編譯器根據上述規則推斷出可能的泛型類型參數，并選擇最具體的類型作為實際使用的泛型類型參數。這個過程基于Java的類型系統，保證類型安全。什么是通用邊界？它能解決什么問題？泛型邊界是泛型的一個重要概念，它可以限制泛型變量的類型范圍。它可以解決以下問題： 類型安全：泛型邊界可以保證編譯時的類型檢查，避免類型轉換錯誤。通過限制泛型變量的類型范圍，可以確保在編譯時檢查類型的合規性，從而避免運行時類型錯誤。代碼復用：泛型邊界可以限制泛型變量的類型范圍，使代碼更加通用和可復用。通過定義通用邊界，您可以編寫適用于多種類型的代碼并提高代碼的可重用性。容器類型的約束：容器是編程中重要的數據結構之一。通用邊界可以約束容器中元素的類型，使得容器只能存儲特定類型的元素。這樣可以保證容器內元素類型的正確性和一致性，減少錯誤，降低維護成本。泛型和反射之間有什么關系？他們如何互動？反射是Java中的一種動態技術，可以在運行時檢查類、接口、字段、方法等信息。反射允許程序在運行時根據指定的類名創建對象、調用方法或訪問字段，而無需在編譯時知道這些信息。泛型是Java 中的一種靜態類型技術，允許在編譯時定義類型參數化的類、接口或方法。泛型的主要目的是提高代碼的可重用性和類型安全性，避免運行時的類型轉換。泛型和反射的關系主要體現在以下幾個方面： 反射可以用來操作泛型類型：由于反射可以在運行時獲取類信息，所以可以用來操作泛型類型。例如，您可以使用反射來獲取泛型類的類型參數，或者創建泛型類型的實例。泛型可以提供更好的類型安全性：泛型在編譯時執行類型檢查，這可以減少運行時類型錯誤。這減少了反射的使用，因為可以在編譯時捕獲更多類型錯誤。反射和泛型可以一起使用：在某些情況下，可能需要一起使用反射和泛型。您可以使用反射來動態創建泛型類型的實例，或操作泛型類型的字段和方法。

類clazz=. //獲取泛型類的Class對象Type type=clazz.getGenericSuperclass(); //獲取泛型類的實際類型參數if (type instanceof ParameterizedType) { ParameterizedType pType=(ParameterizedType) type; Type[]實際類型參數=pType.getActualTypeArguments(); //獲取泛型參數的實際類型//這里可以對實際類型參數進行操作} Class clazz=. //獲取泛型類的Class對象Type type=clazz.getGenericSuperclass(); //獲取泛型類的實際類型參數if (type instanceof ParameterizedType) { ParameterizedType pType=(ParameterizedType) type; Type[]實際類型參數=pType.getActualTypeArguments(); //獲取泛型參數實際類型//這里可以創建泛型實例并指定實際類型參數} 什么是泛型嵌套類型？它能解決什么問題？泛型嵌套類型是指嵌套在另一個泛型類型中的泛型類型。這種嵌套關系可以是一層或多層。 Java 中的泛型嵌套類型可以通過內部類、匿名內部類等方式實現。泛型嵌套類型可以解決以下問題： 提高代碼的可重用性：通過將一個泛型類型嵌套在另一個泛型類型中，可以創建更通用、可重用的代碼。外部泛型類型可以提供額外的類型參數，內部泛型類型可以使用這些參數來定義自己的類型參數，使內部類型更加具體和具體。這種模式避免了代碼的重復并提高了代碼的可維護性。提高類型安全性：通用嵌套類型可以提供額外的類型檢查，以提高代碼的類型安全性。內部泛型類型的類型參數可以繼承外部類型參數，從而限制內部類型的具體類型，避免錯誤的類型使用。此約束可以在編譯時捕獲潛在的類型錯誤并提高代碼的可靠性。簡化代碼結構：通過將相關的泛型邏輯組織在嵌套的泛型類型中，可以使代碼結構更加清晰，更易于維護。外部類型可以專注于外部邏輯，而內部類型可以專注于內部邏輯，降低代碼復雜度。這種結構還有助于提高代碼的可讀性和可維護性。需要注意的是，泛型嵌套類型要謹慎使用，避免過度使用可能導致代碼過于復雜、難以理解。使用時應根據實際需要進行設計和選型，保證代碼的清晰性、可讀性和可維護性。泛型和多態之間有什么關系？他們如何互動？多態性是面向對象編程的一個基本特性，它允許一個接口由多個不同的類實現或者一個類繼承多個接口。多態性是指一個對象可以有多種形態，在特定情況下可以表現出不同的狀態和行為。泛型是一種在編譯時進行類型參數化的機制，它允許將類、接口或方法應用于多種數據類型。通過使用泛型，您可以編寫更通用和可重用的代碼，并避免大量的類型轉換操作。泛型與多態性的關系主要體現在以下幾個方面：

泛型可以提供更好的類型安全性：泛型在編譯時執行類型檢查，這可以減少運行時類型錯誤。這減少了多態性的使用，因為可以在編譯時捕獲更多類型錯誤。

多態性可以擴展泛型的范圍：通過實現多態性，泛型可以用來實現多種不同的數據類型，而不僅僅是基本類型或自定義類。多態性使得泛型類或泛型方法能夠對不同類型的對象實現相同的操作邏輯，從而實現更加靈活和可重用的代碼。

泛型和多態性可以相輔相成：在某些情況下，泛型和多態性可以相輔相成，以實現更復雜的功能。例如，您可以使用泛型來定義通用算法，然后使用多態性來使用不同的實現。這提高了代碼靈活性和可擴展性，同時保持了代碼的多功能性。泛型在集合框架中有哪些應用場景？泛型在集合框架中有廣泛的應用場景，可以幫助你編寫更安全、更清晰、可重用的代碼。

創建自定義數據結構：通過泛型，您可以創建自己的數據結構，例如ArrayList、LinkedList等，并指定它們可以存儲的數據類型。例如，您可以創建僅存儲整數的ArrayList，或僅存儲字符串的HashMap。

集合類：Java集合框架中的很多類，如ArrayList、LinkedList、HashMap等，都使用了泛型。通過泛型，可以更方便的使用這些集合類，而且類型更安全，可以避免運行時的ClassCastException。

算法操作：泛型允許您編寫適用于不同數據類型的算法。例如，您可以編寫一個交換兩個數字而不僅僅是整數的算法。

接口定義：您可以使用泛型來定義接口并在實現這些接口的類中指定特定的數據類型。例如，您可以定義一個接口，該接口具有用于獲取列表中的元素的方法，然后在使用該接口的類中指定列表元素的類型。

方法參數和返回值：在方法中，可以使用泛型來指定參數和返回值的類型。這使得代碼更加清晰易懂，同時也提高了代碼的可重用性。在設計模式中，泛型有哪些應用場景？工廠模式：泛型可用于創建可重用的工廠類，以創建不同類型對象的實例。通過泛型，工廠類可以在編譯時獲取參數類型并相應地創建正確的對象實例。

公共接口形狀{ 無效繪制(); } public class Circle 實現Shape { @Override public void draw() { System.out.println('繪制圓.'); } } 公共類矩形實現形狀{ @Override public void draw() { System.out.println('繪制矩形.'); } } public class ShapeFactory { public T createShape(String shapeType) { if ('C'.equalsIgnoreCase(shapeType)) { return new Circle( ); } } } else if ('R'.equalsIgnoreCase(shapeType)) { return new Rectangle(); } else { throw new IllegalArgumentException('無效的形狀類型'); } } } 模板方法模式：模板方法模式是一種行為類型設計模式，它定義了一個操作中的算法骨架，并將某些步驟推遲到子類中。在模板方法模式中，泛型可以用來定義抽象類和方法來接受或返回不同類型的

參數，從而增加代碼的復用性。public abstract class AbstractClass { protected abstract void operation(T t); public void templateMethod() { System.out.println("Template method called"); operation(getTypedObject()); // pass type object to template method } protected abstract T getTypedObject(); } public class ConcreteClass extends AbstractClass { @Override protected void operation(Integer t) { System.out.println("Operation on Integer: " + t); } @Override protected Integer getTypedObject() { return 10; // return Integer object to template method call in AbstractClass.templateMethod() } }觀察者模式：觀察者模式是一種行為型設計模式，它定義了一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴于它的對象都會得到通知并自動更新。在觀察者模式中，可以使用泛型來定義觀察者和被觀察者的類型，以增加代碼的靈活性和復用性。import java.util.*; // 抽象主題類 public abstract class Subject { private List> observers = new ArrayList<>(); // 添加觀察者 public void addObserver(Observer observer) { observers.add(observer); } // 刪除觀察者 public void deleteObserver(Observer observer) { observers.remove(observer); } // 通知所有觀察者更新 public void notifyObservers(T data) { for (Observer observer : observers) { observer.update(data); } } } // 具體主題類（天氣預報） public class WeatherSubject extends Subject { private String weather; public WeatherSubject(String weather) { this.weather = weather; } public String getWeather() { return weather; } public void setWeather(String weather) { this.weather = weather; notifyObservers(weather); // 天氣變化，通知觀察者更新數據 } } // 抽象觀察者接口 public interface Observer { void update(T data); } // 具體觀察者類（天氣預報員） public class WeatherObserver implements Observer { private String name; public WeatherObserver(String name) { this.name = name; } @Override public void update(String data) { System.out.println(name + " received update: " + data); } }適配器模式：適配器模式是一種結構型設計模式，它通過將一個類的接口轉換成客戶端所期望的另一個接口形式，來解決不兼容的問題。在適配器模式中，可以使用泛型來定義適配器和被適配者的類型，以增加代碼的復用性和靈活性。import java.util.*; // 目標接口 public interface Target { void request(T param); } // 源類 public class Adaptee { public void specificRequest(String param) { System.out.println("Adaptee: " + param); } } // 適配器類 public class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } @Override public void request(T param) { adaptee.specificRequest((String) param); // 適配器將泛型參數轉換為字符串類型，傳遞給源類的方法 } }public class Client { public static void main(String[] args) { Adaptee adaptee = new Adaptee(); Target target = new Adapter<>(adaptee); // 創建適配器對象，將源對象傳入適配器構造函數中 target.request("Hello, Adapter!"); // 調用目標接口方法，適配器將參數轉換為字符串類型，并調用源類的方法 } }策略模式：策略模式是一種行為型設計模式，它定義了一系列的算法，并將每一個算法封裝起來，使它們可以互相替換。在策略模式中，可以使用泛型來定義不同的策略類型，以增加代碼的復用性和靈活性。import java.util.*; // 策略接口 public interface Strategy { void execute(T param); } // 具體策略類1 public class ConcreteStrategyA implements Strategy { @Override public void execute(String param) { System.out.println("ConcreteStrategyA: " + param); } } // 具體策略類2 public class ConcreteStrategyB implements Strategy { @Override public void execute(Integer param) { System.out.println("ConcreteStrategyB: " + param); } } // 上下文類，使用泛型參數 public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public void setStrategy(Strategy strategy) { this.strategy = strategy; } public void executeStrategy(T param) { strategy.execute(param); } }public class Client { public static void main(String[] args) { Context context = new Context<>(new ConcreteStrategyA()); // 創建上下文對象，傳入具體策略對象A context.executeStrategy("Hello, Strategy!"); // 執行策略方法，輸出"ConcreteStrategyA: Hello, Strategy!" context.setStrategy(new ConcreteStrategyB()); // 更換為具體策略對象B context.executeStrategy(10); // 執行策略方法，輸出"ConcreteStrategyB: 10" } }