|
项目 |
内容 |
|
《面向对象程序设计（java）》 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11815810.html |
|
作业学习目标 |
|
第一部分：总结第八章关于泛型程序设计理论知识
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）泛型方法可以声明在泛型类中，也可以声明在普通类中。
public class ArrayTool { public static<E> void insert(E[] e, int i) { //请自己添加代码 } public static<E> E valueAt(E[] e , int i) { //请自己添加代码 } }
4、泛型接口的定义
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： 导入第8章示例程序，测试程序并进行代码注释。
测试程序1：
编辑、调试、运行教材311、312页代码，结合程序运行结果理解程序；
在泛型类定义及使用代码处添加注释；
掌握泛型类的定义及使用。
程序代码如下：
PairTets1:
package pair1; /** * @version 1.01 2012-01-26 * @author Cay Horstmann */ public class PairTest1 { public static void main(String[] args) { String[] words = { "Mary", "had", "a", "little", "lamb" }; Pair<String> mm = ArrayAlg.minmax(words); System.out.println("min = " + mm.getFirst()); System.out.println("max = " + mm.getSecond()); } } class ArrayAlg { /** * 获取字符串数组的最小值和最大值。. * @param a an array of strings * @return 一个具有最小值和最大值的对，如果A为空或空，则为null */ public static Pair<String> minmax(String[] a)//用具体的类型替换类型变量可以实例化泛型类型 { if (a == null || a.length == 0) return null; String min = a[0]; String max = a[0]; for (int i = 1; i < a.length; i++) { if (min.compareTo(a[i]) > 0) min = a[i]; if (max.compareTo(a[i]) < 0) max = a[i]; } return new Pair<>(min, max); } }
Pair
package pair1; /** * @version 1.00 2004-05-10 * @author Cay Horstmann */ public class Pair<T> //定义了一个泛型类，该类引入了一个类型变量T { private T first; private T second; //使用类型变量，类型变量指定方法的返回类型 public Pair() { first = null; second = null; } public Pair(T first, T second) { this.first = first; this.second = second; } public T getFirst() { return first; } public T getSecond() { return second; } public void setFirst(T newValue) { first = newValue; } public void setSecond(T newValue) { second = newValue; } }
实验结果如下：
测试程序2：
1.编辑、调试运行教材315页 PairTest2，结合程序运行结果理解程序；
2.在泛型程序设计代码处添加相关注释；
3.掌握泛型方法、泛型变量限定的定义及用途。
PairTest2
package pair2; import java.time.LocalDate; //import java.time.*; /** * @version 1.02 2015-06-21 * @author Cay Horstmann */ public class PairTest2 { public static void main(String[] args) { LocalDate[] birthdays = { LocalDate.of(1906, 12, 9), // G. Hopper LocalDate.of(1815, 12, 10), // A. Lovelace LocalDate.of(1903, 12, 3), // J. von Neumann LocalDate.of(1910, 6, 22), // K. Zuse }; Pair<LocalDate> mm = ArrayAlg.minmax(birthdays);//实例化对象mm System.out.println("min = " + mm.getFirst()); System.out.println("max = " + mm.getSecond()); } } class ArrayAlg { /** 获取T类型对象数组的最小值和最大值。 @param T类型的对象数组 @return 一个具有最小值和最大值的对，如果A为空或空，则为null */ public static <T extends Comparable> Pair<T> minmax(T[] a) { if (a == null || a.length == 0) return null; T min = a[0]; T max = a[0]; for (int i = 1; i < a.length; i++) { if (min.compareTo(a[i]) > 0) min = a[i]; if (max.compareTo(a[i]) < 0) max = a[i]; } return new Pair<>(min, max); } }
pair类与上面程序相同，此处不做重复定义。
测试程序3：
1.用调试运行教材335页 PairTest3，结合程序运行结果理解程序；
2.了解通配符类型的定义及用途。
PairTest3:
package pair3; /** * @version 1.01 2012-01-26 * @author Cay Horstmann */ public class PairTest3 { public static void main(String[] args) { Manager ceo = new Manager("Gus Greedy", 800000, 2003, 12, 15); Manager cfo = new Manager("Sid Sneaky", 600000, 2003, 12, 15); Pair<Manager> buddies = new Pair<>(ceo, cfo); printBuddies(buddies); ceo.setBonus(1000000); cfo.setBonus(500000); Manager[] managers = { ceo, cfo }; Pair<Employee> result = new Pair<>(); minmaxBonus(managers, result); System.out.println("first: " + result.getFirst().getName() + ", second: " + result.getSecond().getName()); maxminBonus(managers, result); System.out.println("first: " + result.getFirst().getName() + ", second: " + result.getSecond().getName()); } public static void printBuddies(Pair<? extends Employee> p)//通配符类型解决了不能将子类传递给父类 { Employee first = p.getFirst(); Employee second = p.getSecond(); System.out.println(first.getName() + " and " + second.getName() + " are buddies."); } public static void minmaxBonus(Manager[] a, Pair<? super Manager> result) { if (a.length == 0) return; Manager min = a[0]; Manager max = a[0]; for (int i = 1; i < a.length; i++) { if (min.getBonus() > a[i].getBonus()) min = a[i]; if (max.getBonus() < a[i].getBonus()) max = a[i]; } result.setFirst(min); result.setSecond(max); } public static void maxminBonus(Manager[] a, Pair<? super Manager> result) { minmaxBonus(a, result); PairAlg.swapHelper(result); // SavaHelp捕获通配符类型 } // 无法写入公共静态<T超级管理器> ... } class PairAlg { public static boolean hasNulls(Pair<?> p) { return p.getFirst() == null || p.getSecond() == null; } public static void swap(Pair<?> p) { swapHelper(p); } public static <T> void swapHelper(Pair<T> p) { T t = p.getFirst(); p.setFirst(p.getSecond()); p.setSecond(t); } }
pair类与上面程序相同，此处不做重复定义。
运行结果如下：
实验2：结对编程练习
import java.util.ArrayList; import java.util.Scanner; interface GeneralStack<T>{ public T push(T item); //如item为null，则不入栈直接返回null。 public T pop(); //出栈，如为栈为空，则返回null。 public T peek(); //获得栈顶元素，如为空，则返回null. public boolean empty();//如为空返回true public int size(); //返回栈中元素数量 } class ArrayListGeneralStack implements GeneralStack{ ArrayList list=new ArrayList(); @Override public String toString() { return list.toString(); } @Override public Object push(Object item) { if (list.add(item)){ return item; }else { return false; } } @Override public Object pop() { if (list.size()==0){ return null; } return list.remove(list.size()-1); } @Override public Object peek() { return list.get(list.size()-1); } @Override public boolean empty() { if (list.size()==0){ return true; }else { return false; } } @Override public int size() { return list.size(); } } class Car{ private int id; private String name; @Override public String toString() { return "Car [" + "id=" + id + ", name=" + name + ']'; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Car(int id, String name) { this.id = id; this.name = name; } } public class Main { public static void main(String[] args) { Scanner sc=new Scanner(System.in); while (true){ String s=sc.nextLine(); if (s.equals("Double")){ System.out.println("Double Test"); int count=sc.nextInt(); int pop_time=sc.nextInt(); ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack(); for (int i=0;i<count;i++){ System.out.println("push:"+arrayListGeneralStack.push(sc.nextDouble())); } for (int i=0;i<pop_time;i++){ System.out.println("pop:"+arrayListGeneralStack.pop()); } System.out.println(arrayListGeneralStack.toString()); double sum=0; int size=arrayListGeneralStack.size(); for (int i=0;i<size;i++){ sum+=(double)arrayListGeneralStack.pop(); } System.out.println("sum="+sum); System.out.println("interface GeneralStack"); }else if (s.equals("Integer")){ System.out.println("Integer Test"); int count=sc.nextInt(); int pop_time=sc.nextInt(); ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack(); for (int i=0;i<count;i++){ System.out.println("push:"+arrayListGeneralStack.push(sc.nextInt())); } for (int i=0;i<pop_time;i++){ System.out.println("pop:"+arrayListGeneralStack.pop()); } System.out.println(arrayListGeneralStack.toString()); int sum=0; int size=arrayListGeneralStack.size(); for (int i=0;i<size;i++){ sum+=(int)arrayListGeneralStack.pop(); } System.out.println("sum="+sum); System.out.println("interface GeneralStack"); }else if (s.equals("Car")){ System.out.println("Car Test"); int count=sc.nextInt(); int pop_time=sc.nextInt(); ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack(); for (int i=0;i<count;i++){ int id=sc.nextInt(); String name=sc.next(); Car car = new Car(id,name); System.out.println("push:"+arrayListGeneralStack.push(car)); } for (int i=0;i<pop_time;i++){ System.out.println("pop:"+arrayListGeneralStack.pop()); } System.out.println(arrayListGeneralStack.toString()); if (arrayListGeneralStack.size()>0){ int size=arrayListGeneralStack.size(); for (int i=0;i<size;i++){ Car car=(Car) arrayListGeneralStack.pop(); System.out.println(car.getName()); } } System.out.println("interface GeneralStack"); }else if (s.equals("quit")){ break; } } } }
实验总结：
通过本周的学习，掌握了泛型基本概念，使得在编写面向程序对象增加了极大的效力和灵活性。不会强行对值类型进行装箱和拆箱，或对引用类型进行向下强制类型转换，所以性能得到提高。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设，所以泛型提高了程序的类型安全。泛型类和泛型方法同时具备可重用性、类型安全和效率，这是非泛型类和非泛型方法无法具备的。泛型通常用与集合以及作用于集合的方法一起使用。在写代码这方面，学会了自己去调试书上的代码，虽然在编译过程中还是会存在错误和问题，但是通过对比一点一点发现自己的问题，也是一种进步。最后一题是结对编程题，因为不认识班里的同学不知道该找谁结对，所以也没有去沟通联系。只能求助自己班里的同学，帮忙写出了代码，但是我基本只有看、问的份。虽然会有挫败感，但是一点一点进步吧。刚开始会慢，后面一定会追赶上来的！