第一部分：理論知識學習部分

第八章??泛型程序設計

1、泛型程序設計概念

1）JDK 5.0 中增加的泛型類型，是Java 語言中類型安全的一次重要改進。

2）泛型：也稱參數化類型(parameterized type)，就是在定義類、接口和方法時，通過類型參數指示將要處理的對象類型。（如ArrayList類）　

3）泛型程序設計（Generic programming）：編寫代碼可以被很多不同類型的對象所重用。

2、泛型類的聲明及實例化的方法

1）一個泛型類（generic class）就是具有一個或多個類型變量的類，即創建用類型作為參數的類。

2）如一個泛型類定義格式如下：class Generics＜K,V＞其中的K和V是類中的可變類型參數。

3）Pair類引入了一個類型變量T，用尖括號（<>）括起來，并放在類名的后面。

4）泛型類可以有多個類型變量。例如:public class Pair<T, U> { … }

5）類定義中的類型變量用于指定方法的返回類型以及域、局部變量的類型。

6）泛型類的約束與局限性:

a）不能用基本類型實例化類型參數

b）運行時類型查詢只適用于原始類型

c）不能拋出也不能捕獲泛型類實例

d）參數化類型的數組不合法

e）不能實例化類型變量

f ）泛型類的靜態上下文中類型變量無效

g）注意擦除后的沖突

3、泛型方法的定義

1）泛型方法：除了泛型類外，還可以只單獨定義一個方法作為泛型方法，用于指定方法參數或者返回值為泛型類型，留待方法調用時確定。

2）泛型方法可以聲明在泛型類中，也可以聲明在普通類中。

1 public class ArrayTool { 2 public static<E> void insert(E[] e, int i) 3 { 4 //請自己添加代碼 5 } 6 public static<E> E valueAt(E[] e , int i) 7 { 8 //請自己添加代碼 9 } 10 }

4、泛型接口的定義

1 public interface IPool <T> 2 { 3 T get(); 4 int add(T t); 5 }

1）泛型變量的限定

a）定義泛型變量的上界

public class NumberGeneric< T extends Number>

b）定義泛型變量的下界?

List<? superCashCard> cards = new ArrayList<T>();

5、泛型類型的繼承規則

1）Java中的數組是協變的（covariant），但這一原理不適用于泛型類型

2）Java中泛型類不具協變性。

3）泛型類可擴展或實現其它的泛型類。

6、通配符類型及使用方法

1）“？”符號表明參數的類型可以是任何一種類型，它和參數T的含義是有區別的。T表示一種 未知類型，而“？”表示任何一種類型。這種通配符一般有以下三種用法：

a）單獨的？，用于表示任何類型

b）? extends type，表示帶有上界。?

c ）? super type，表示帶有下界。

2）通配符的類型限定?

a）Pair<? extends Employee>

b)? Pair<? super Manager>

c)??無限定通配符:Pair<?>。 Pair<?>與Pair的不同在于：可以用任意Object 對象調用原始的Pair類的setObject方法。

?

第二部分：實驗部分?——泛型程序設計技術

1、實驗目的與要求

(1)?理解泛型概念；

(2)?掌握泛型類的定義與使用；

(3)?掌握泛型方法的聲明與使用；

(4)?掌握泛型接口的定義與實現；

(5)了解泛型程序設計，理解其用途。

2、實驗內容和步驟

實驗1：?導入第8章示例程序，測試程序并進行代碼注釋。

測試程序1：

1.編輯、調試、運行教材311、312頁?代碼，結合程序運行結果理解程序；

2.在泛型類定義及使用代碼處添加注釋；

3.掌握泛型類的定義及使用。?

PairTest1

1 package pair1; 2 3 /** 4 * @version 1.01 2012-01-26 5 * @author Cay Horstmann 6 */ 7 public class PairTest1 8 { 9 public static void main(String[] args) 10 { 11 String[] words = { "Mary", "had", "a", "little", "lamb" }; 12 Pair<String> mm = ArrayAlg.minmax(words); 13 System.out.println("min = " + mm.getFirst()); 14 System.out.println("max = " + mm.getSecond()); 15 } 16 } 17 18 class ArrayAlg 19 { 20 /** 21 * 獲取字符串數組的最小值和最大值。. 22 * @param a an array of strings 23 * @return 一個具有最小值和最大值的對，如果A為空或空，則為null 24 */ 25 public static Pair<String> minmax(String[] a)//用具體的類型替換類型變量可以實例化泛型類型 26 { 27 if (a == null || a.length == 0) return null; 28 String min = a[0]; 29 String max = a[0]; 30 for (int i = 1; i < a.length; i++) 31 { 32 if (min.compareTo(a[i]) > 0) min = a[i]; 33 if (max.compareTo(a[i]) < 0) max = a[i]; 34 } 35 return new Pair<>(min, max); 36 } 37 }

Pair

1 package pair1; 2 3 /** 4 * @version 1.00 2004-05-10 5 * @author Cay Horstmann 6 */ 7 public class Pair<T> //定義了一個泛型類，該類引入了一個類型變量T 8 { 9 private T first; 10 private T second; 11 //使用類型變量，類型變量指定方法的返回類型 12 public Pair() { first = null; second = null; } 13 public Pair(T first, T second) 14 { this.first = first; 15 this.second = second; } 16 17 public T getFirst() { return first; } 18 public T getSecond() { return second; } 19 20 public void setFirst(T newValue) { first = newValue; } 21 public void setSecond(T newValue) { second = newValue; } 22 }

實驗結果如下：

測試程序2：

1.編輯、調試運行教材315頁?PairTest2，結合程序運行結果理解程序；

2.在泛型程序設計代碼處添加相關注釋；

3.掌握泛型方法、泛型變量限定的定義及用途。

PairTest2

1 package pair2; 2 3 import java.time.LocalDate; 4 5 //import java.time.*; 6 7 /** 8 * @version 1.02 2015-06-21 9 * @author Cay Horstmann 10 */ 11 public class PairTest2 12 { 13 public static void main(String[] args) 14 { 15 LocalDate[] birthdays = 16 { 17 LocalDate.of(1906, 12, 9), // G. Hopper 18 LocalDate.of(1815, 12, 10), // A. Lovelace 19 LocalDate.of(1903, 12, 3), // J. von Neumann 20 LocalDate.of(1910, 6, 22), // K. Zuse 21 }; 22 Pair<LocalDate> mm = ArrayAlg.minmax(birthdays);//實例化對象mm 23 System.out.println("min = " + mm.getFirst()); 24 System.out.println("max = " + mm.getSecond()); 25 } 26 } 27 28 class ArrayAlg 29 { 30 /** 31 獲取T類型對象數組的最小值和最大值。 32 @param T類型的對象數組 33 @return 一個具有最小值和最大值的對，如果A為空或空，則為null 34 */ 35 public static <T extends Comparable> Pair<T> minmax(T[] a) 36 { 37 if (a == null || a.length == 0) return null; 38 T min = a[0]; 39 T max = a[0]; 40 for (int i = 1; i < a.length; i++) 41 { 42 if (min.compareTo(a[i]) > 0) min = a[i]; 43 if (max.compareTo(a[i]) < 0) max = a[i]; 44 } 45 return new Pair<>(min, max); 46 } 47 }

pair類與上面程序相同，此處不做重復定義。

測試程序3：

1.用調試運行教材335頁?PairTest3，結合程序運行結果理解程序；

2.了解通配符類型的定義及用途。

Employee類

1 package pair3; 2 3 import java.time.*; 4 5 public class Employee 6 { 7 private String name; 8 private double salary; 9 private LocalDate hireDay; 10 11 public Employee(String name, double salary, int year, int month, int day) 12 { 13 this.name = name; 14 this.salary = salary; 15 hireDay = LocalDate.of(year, month, day); 16 } 17 18 public String getName() 19 { 20 return name; 21 } 22 23 public double getSalary() 24 { 25 return salary; 26 } 27 28 public LocalDate getHireDay() 29 { 30 return hireDay; 31 } 32 33 public void raiseSalary(double byPercent) 34 { 35 double raise = salary * byPercent / 100; 36 salary += raise; 37 } 38 } employee

Manager類

1 package pair3; 2 3 public class Manager extends Employee 4 { 5 private double bonus; 6 7 /** 8 @param name the employee's name 9 @param salary the salary 10 @param year the hire year 11 @param month the hire month 12 @param day the hire day 13 */ 14 public Manager(String name, double salary, int year, int month, int day) 15 { 16 super(name, salary, year, month, day); 17 bonus = 0; 18 } 19 20 public double getSalary() 21 { 22 double baseSalary = super.getSalary(); 23 return baseSalary + bonus; 24 } 25 26 public void setBonus(double b) 27 { 28 bonus = b; 29 } 30 31 public double getBonus() 32 { 33 return bonus; 34 } 35 } Manager

PairTest3

1 package pair3; 2 3 /** 4 * @version 1.01 2012-01-26 5 * @author Cay Horstmann 6 */ 7 public class PairTest3 8 { 9 public static void main(String[] args) 10 { 11 Manager ceo = new Manager("Gus Greedy", 800000, 2003, 12, 15); 12 Manager cfo = new Manager("Sid Sneaky", 600000, 2003, 12, 15); 13 Pair<Manager> buddies = new Pair<>(ceo, cfo); 14 printBuddies(buddies); 15 16 ceo.setBonus(1000000); 17 cfo.setBonus(500000); 18 Manager[] managers = { ceo, cfo }; 19 20 Pair<Employee> result = new Pair<>(); 21 minmaxBonus(managers, result); 22 System.out.println("first: " + result.getFirst().getName() 23 + ", second: " + result.getSecond().getName()); 24 maxminBonus(managers, result); 25 System.out.println("first: " + result.getFirst().getName() 26 + ", second: " + result.getSecond().getName()); 27 } 28 29 public static void printBuddies(Pair<? extends Employee> p)//通配符類型解決了不能將子類傳遞給父類 30 { 31 Employee first = p.getFirst(); 32 Employee second = p.getSecond(); 33 System.out.println(first.getName() + " and " + second.getName() + " are buddies."); 34 } 35 36 public static void minmaxBonus(Manager[] a, Pair<? super Manager> result) 37 { 38 if (a.length == 0) return; 39 Manager min = a[0]; 40 Manager max = a[0]; 41 for (int i = 1; i < a.length; i++) 42 { 43 if (min.getBonus() > a[i].getBonus()) min = a[i]; 44 if (max.getBonus() < a[i].getBonus()) max = a[i]; 45 } 46 result.setFirst(min); 47 result.setSecond(max); 48 } 49 50 public static void maxminBonus(Manager[] a, Pair<? super Manager> result) 51 { 52 minmaxBonus(a, result); 53 PairAlg.swapHelper(result); // SavaHelp捕獲通配符類型 54 } 55 // 無法寫入公共靜態<T超級管理器> ... 56 } 57 58 class PairAlg 59 { 60 public static boolean hasNulls(Pair<?> p) 61 { 62 return p.getFirst() == null || p.getSecond() == null; 63 } 64 65 public static void swap(Pair<?> p) { swapHelper(p); } 66 67 public static <T> void swapHelper(Pair<T> p) 68 { 69 T t = p.getFirst(); 70 p.setFirst(p.getSecond()); 71 p.setSecond(t); 72 } 73 }

pair類與上面程序相同，此處不做重復定義。

運行結果如下：

?

實驗2：編程練習：

編程練習1：實驗九編程題總結

1.實驗九編程練習1總結（從程序總體結構說明、模塊說明，目前程序設計存在的困難與問題三個方面闡述）。

總結：

?這個程序定義了一個people類，用people類實現people接口，以name屬性進行排序。然后在主類中實現方法的調用，文件的讀取和異常判斷。

現狀：對于接口與繼承的關系理解還不是太過透徹；

困難：對Java所學知識需要時間從細梳理

2.實驗九編程練習2總結（從程序總體結構說明、模塊說明，目前程序設計存在的困難與問題三個方面闡述）。

總結：

這個程序實現起來沒有太大的難度，定義一個sf類將方法封裝，在主函數中用round() 方法實現隨機題目的產生和將題目數字限制在100以內，添加了異常處理，實現文件的輸出

?困難：對于除法的實現不夠細致

編程練習2：采用泛型程序設計技術改進實驗九編程練習2，使之可處理實數四則運算，其他要求不變。

程序如下：

?

1 import java.io.File; 2 import java.io.FileOutputStream; 3 import java.io.PrintWriter; 4 import java.math.BigDecimal; 5 import java.util.Scanner; 6 7 8 public class ss { 9 public static void main(String[] args) { 10 11 12 Scanner in = new Scanner(System.in); 13 Calculator<Integer> sf = new Calculator<Integer>(); 14 File file = new File("wzt.txt"); 15 if(file.exists()) { 16 System.out.println("文件已存在"); 17 } 18 PrintWriter output = null; 19 try { 20 output = new PrintWriter(new FileOutputStream(file)); 21 } catch (Exception e) { 22 //e.printStackTrace(); 23 } 24 int sum = 0; 25 26 System.out.println("計算結果保留兩位小數"); 27 for (int i = 1; i < 11; i++) { 28 int a = (int) Math.round(Math.random() * 100); 29 int b = (int) Math.round(Math.random() * 100); 30 int s = (int) Math.round(Math.random() * 3); 31 32 33 switch(s) 34 { 35 case 1: 36 System.out.println(i+": "+a+"/"+b+"="); 37 Number c = in.nextDouble(); 38 output.println(a+"/"+b+"="+c); 39 Number g = sf.division(a, b); 40 BigDecimal division = new BigDecimal(g.doubleValue()); 41 g = division.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); 42 if (c.equals(g)) { 43 sum += 10; 44 System.out.println("恭喜答案正確"); 45 } 46 else { 47 System.out.println("抱歉，答案錯誤"); 48 } 49 50 break; 51 52 case 2: 53 System.out.println(i+": "+a+"*"+b+"="); 54 Number c1 = in.nextDouble(); 55 output.println(a+"*"+b+"="+c1); 56 Number g1 = sf.mulitiplication(a, b); 57 BigDecimal mul = new BigDecimal(g1.doubleValue()); 58 g1 = mul.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); 59 if (c1.equals(g1) ){ 60 sum += 10; 61 System.out.println("恭喜答案正確"); 62 } 63 else { 64 System.out.println("抱歉，答案錯誤"); 65 } 66 break; 67 case 3: 68 System.out.println(i+": "+a+"+"+b+"="); 69 Number c2 = in.nextDouble(); 70 output.println(a+"+"+b+"="+c2); 71 Number g2 =sf.addition(a, b); 72 BigDecimal add = new BigDecimal(g2.doubleValue()); 73 g2 = add.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); 74 if (c2.equals(g2)) { 75 sum += 10; 76 System.out.println("恭喜答案正確"); 77 } 78 else { 79 System.out.println("抱歉，答案錯誤"); 80 } 81 82 break ; 83 case 4: 84 System.out.println(i+": "+a+"-"+b+"="); 85 Number c3 = in.nextDouble(); 86 output.println(a+"-"+b+"="+c3); 87 Number g3 = sf.subtraction(a, b); 88 BigDecimal sub = new BigDecimal(g3.doubleValue()); 89 g3 = sub.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); 90 if (c3.equals(g3)) { 91 sum += 10; 92 System.out.println("恭喜答案正確"); 93 } 94 else { 95 System.out.println("抱歉，答案錯誤"); 96 } 97 break ; 98 99 } 100 101 } 102 System.out.println("成績"+sum); 103 output.println("成績:"+sum); 104 output.close(); 105 in.close(); 106 107 } 108 }

?

1 public class Calculator<T> { 2 3 public Calculator() { 4 // TODO Auto-generated constructor stub 5 } 6 7 8 public Number addition(T m,T n) { 9 return Double.parseDouble(m.toString())+Double.parseDouble(n.toString()); 10 } 11 12 public Number subtraction(T m,T n) { 13 return Double.parseDouble(m.toString())-Double.parseDouble(n.toString()); 14 } 15 public Number mulitiplication(T m,T n) { 16 return Double.parseDouble(m.toString())*Double.parseDouble(n.toString()); 17 } 18 public Number division(T m,T n) { 19 if(Double.parseDouble(n.toString()) != 0) 20 return Double.parseDouble(m.toString())/Double.parseDouble(n.toString()); 21 else 22 return 0; 23 } 24 }

?

?

程序結果如下：

?

?

?

第三部分：總結

　　通過本周的學習，我理解了泛型概念，了解了泛型程序設計，我覺得泛型程序設計的優點是編寫代碼可以被很多不同類型的對象所重用。減少了代碼量，而且增加了程序的可讀性。通過這半學期對Java語言的學習，在老師和助教學長的幫助指導鼓勵下，我的編程能力有了很大的提升，結合上學期C語言的學習，更深層次的理解了Java語言的優點和特性，也加深了我對C的理解。

轉載于:https://www.cnblogs.com/hackerZT-7/p/9891013.html

總結

以上是生活随笔為你收集整理的王之泰201771010131《面向对象程序设计（java）》第十周学习总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。