201771010126 王燕《面向对象程序设计（Java）》第十周学习总结

实验十  泛型程序设计技术

实验时间 2018-11-1

1、实验目的与要求

(1) 理解泛型概念；

泛型：也称参数化类型(parameterized type)，就是在定义类、接口和方法时，通过类型参数指示将要处理的对象类型。（如ArrayList类）. 泛型程序设计（Generic programming）：编写代码可以被很多不同类型的对象所重用。

(2) 掌握泛型类的定义与使用；

一个泛型类（generic class）就是具有一个或多个类型变量的类，即创建用类型作为参数的类。如一个泛型类定义格式如下：
class Generics＜K,V＞其中的K和V是类中的可变类型参数。

(3) 掌握泛型方法的声明与使用；

泛型方法
– 除了泛型类外，还可以只单独定义一个方法作
为泛型方法，用于指定方法参数或者返回值为
泛型类型，留待方法调用时确定。
– 泛型方法可以声明在泛型类中，也可以声明在
普通类中。

(4) 掌握泛型接口的定义与实现；

定义：
public interface IPool <T>
{
T get();
int add(T t);
}

实现：

public class GenericPool<T> implements IPool<T>
{
…
}
>
}
public class GenericPool implements IPool<Account>
{
…
}

(5)了解泛型程序设计，理解其用途。

泛型程序设计小结
. 定义一个泛型类时，在“＜＞”内定义形式类型参数，例如：“class TestGeneric＜K, V＞”，其中“K” , “V”不代表值，而是表示类型。. 实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：
TestGeneric＜String, String＞ t
=new TestGeneric＜String, String＞()；
. 泛型中＜T extends Object＞, extends并不代表继承，它是类型范围限制。
. 泛型类不是协变的。

2、实验内容和步骤

实验1： 导入第8章示例程序，测试程序并进行代码注释。

测试程序1：

l 编辑、调试、运行教材311、312页 代码，结合程序运行结果理解程序；

l 在泛型类定义及使用代码处添加注释；

l 掌握泛型类的定义及使用。

 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;
     }
 }

 package Pari1;

 /**
  * @version 1.00 2004-05-10
  * @author Cay Horstmann
  */
 public class Pair<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; }
 }

 package Pari1;

 /**
  * @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
 {
    /**
     * Gets the minimum and maximum of an array of strings.
     * @param a an array of strings
     * @return a pair with the min and max value, or null if a is null or empty
     */
    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);
    }
 }

测试程序2：

l 编辑、调试运行教材315页 PairTest2，结合程序运行结果理解程序；

l 在泛型程序设计代码处添加相关注释；

l 掌握泛型方法、泛型变量限定的定义及用途。

 package Pair2;

 /**
  * @version 1.00 2004-05-10
  * @author Cay Horstmann
  */
 public class Pair<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; }
 }

 package Pair2;

 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);
       System.out.println("min = " + mm.getFirst());
       System.out.println("max = " + mm.getSecond());
    }
 }

 class ArrayAlg
 {
    /**
       Gets the minimum and maximum of an array of objects of type T.
       @param a an array of objects of type T
       @return a pair with the min and max value, or null if a is
       null or empty
    */
    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);
    }
 }

测试程序3：

l 用调试运行教材335页 PairTest3，结合程序运行结果理解程序；

l 了解通配符类型的定义及用途。

 package pair3;

 import java.time.*;

 public class Employee
 {
    private String name;
    private double salary;
    private LocalDate hireDay;

    public Employee(String name, double salary, int year, int month, int day)
    {
       this.name = name;
       this.salary = salary;
       hireDay = LocalDate.of(year, month, day);
    }

    public String getName()
    {
       return name;
    }

    public double getSalary()
    {
       return salary;
    }

    public LocalDate getHireDay()
    {
       return hireDay;
    }

    public void raiseSalary(double byPercent)
    {
       double raise = salary * byPercent / 100;
       salary += raise;
    }
 }

 package pair3;

 public class Manager extends Employee
 {
    private double bonus;

    /**
       @param name the employee's name
       @param salary the salary
       @param year the hire year
       @param month the hire month
       @param day the hire day
    */
    public Manager(String name, double salary, int year, int month, int day)
    {
       super(name, salary, year, month, day);
       bonus = 0;
    }

    public double getSalary()
    {
       double baseSalary = super.getSalary();
       return baseSalary + bonus;
    }

    public void setBonus(double b)
    {
       bonus = b;
    }

    public double getBonus()
    {
       return bonus;
    }
 }

 package pair3;

 /**
  * @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; }
 }

 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); // OK--swapHelper captures wildcard type
    }
    // Can't write public static <T super manager> ...
 }

 class PairAlg
 {
    public static boolean hasNulls(Pair<?> p)/*(?)类型变量的通配符，“？”符号表明参数的类型可以是任何一种类
   型，它和参数T的含义是有区别的。T表示一种 未知类型，而“？”表示任何一种类型。这种通配符一般有以下三种用法：
   – 单独的？，用于表示任何类型。
   – ? extends type，表示带有上界。
   – ? super type，表示带有下界。*/
    {
       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);
    }
 }

实验2：编程练习：

编程练习1：实验九编程题总结

l 实验九编程练习1总结（从程序总体结构说明、模块说明，目前程序设计存在的困难与问题三个方面阐述）。

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Scanner;

 public class Check{
     private static ArrayList<Student> studentlist;
     public static void main(String[] args) {
         studentlist = new ArrayList<>();
         Scanner scanner = new Scanner(System.in);
         File file = new File("G:\\JAVA\\实验\\身份证号.txt");//导入文本文件
         try {
             FileInputStream fis = new FileInputStream(file);
             BufferedReader in = new BufferedReader(new InputStreamReader(fis));
             String temp = null;
             while ((temp = in.readLine()) != null) {

                 Scanner linescanner = new Scanner(temp);//创建输入流，与文本文件中的信息进行匹配

                 linescanner.useDelimiter(" ");
                 String name = linescanner.next();
                 String number = linescanner.next();
                 String sex = linescanner.next();
                 String age = linescanner.next();
                 String province =linescanner.nextLine();
                 Student student = new Student();
                 student.setName(name);
                 student.setnumber(number);
                 student.setsex(sex);
                 int a = Integer.parseInt(age);
                 student.setage(a);
                 student.setprovince(province);
                 studentlist.add(student);

             }
         } catch (FileNotFoundException e) {
             System.out.println("学生信息文件找不到");
             e.printStackTrace();
         } catch (IOException e) {
             System.out.println("学生信息文件读取错误");
             e.printStackTrace();
         }
         boolean isTrue = true;
         while (isTrue) {
             System.out.println("选择你的操作，输入正确格式的选项");//控制台输出用户的选择
             System.out.println("1.按姓名字典序输出人员信息");
             System.out.println("2.输出年龄最大和年龄最小的人");
             System.out.println("3.查找老乡");
             System.out.println("4.查找年龄相近的人");
             System.out.println("5.退出");
             String m = scanner.next();
             switch (m) {//使用catch语句对用户的选择作不同的操作
             case "1":
                 Collections.sort(studentlist);
                 System.out.println(studentlist.toString());
                 break;
             case "2":
                  int max=0,min=100;
                  int j,k1 = 0,k2=0;
                  for(int i=1;i<studentlist.size();i++)
                  {
                      j=studentlist.get(i).getage();
                  if(j>max)
                  {
                      max=j;
                      k1=i;
                  }
                  if(j<min)
                  {
                    min=j;
                    k2=i;
                  }

                  }
                  System.out.println("年龄最大："+studentlist.get(k1));
                  System.out.println("年龄最小："+studentlist.get(k2));
                 break;
             case "3":
                  System.out.println("输入省份");
                  String find = scanner.next();
                  String place=find.substring(0,3);
                  for (int i = 0; i <studentlist.size(); i++)
                  {
                      if(studentlist.get(i).getprovince().substring(1,4).equals(place))
                          System.out.println("老乡"+studentlist.get(i));
                  }
                  break;

             case "4":
                 System.out.println("年龄：");
                 int yourage = scanner.nextInt();
                 int near=agenear(yourage);
                 int value=yourage-studentlist.get(near).getage();
                 System.out.println(""+studentlist.get(near));
                 break;
             case "5":
                 isTrue = false;
                 System.out.println("退出程序!");
                 break;
                 default:
                 System.out.println("输入有误");

             }
         }
     }
         public static int agenear(int age) {
         int j=0,min=53,value=0,k=0;
          for (int i = 0; i < studentlist.size(); i++)
          {
              value=studentlist.get(i).getage()-age;
              if(value<0) value=-value;
              if (value<min)
              {
                 min=value;
                 k=i;
              }
           }
          return k;
       }

 }

 public class Student implements Comparable<Student> {

     private String name;
     private String number ;
     private String sex ;
     private int age;
     private String province;

     public String getName() {//创建主类所需的变量所使用的一系列方法
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getnumber() {
         return number;
     }
     public void setnumber(String number) {
         this.number = number;
     }
     public String getsex() {
         return sex ;
     }
     public void setsex(String sex ) {
         this.sex =sex ;
     }
     public int getage() {

         return age;
         }
         public void setage(int age) {
             // int a = Integer.parseInt(age);
         this.age= age;
         }

     public String getprovince() {
         return province;
     }
     public void setprovince(String province) {
         this.province=province ;
     }

     public int compareTo(Student o) {
        return this.name.compareTo(o.getName());
     }

     public String toString() {
         return  name+"\t"+sex+"\t"+age+"\t"+number+"\t"+province+"\n";
     }
 }

程序总体结结构：

Check类作为主类

Student类实现Comparable<Student>接口

模块说明：

主类Check类模块说明：1.导入文本文件;2.创建输入流，与文本文件中的信息进行匹配；3.控制台输出用户的选择，并使用catch语句对用户的选择作不同的操作

Student类模块说明：创建主类所需的变量所使用的一系列方法

目前设计程序存在的困难与问题：导入文本文件失败时的处理方式；由于C语言中没有Boolean类型，程序中对Boolean类型在整个程序中的使用不够熟练，常常使用较长的判断语句而忽略了布尔类型的运用

l 实验九编程练习2总结（从程序总体结构说明、模块说明，目前程序设计存在的困难与问题三个方面阐述）。

 import java.io.FileNotFoundException;
 import java.io.PrintWriter;
 import java.util.Scanner;
 public class Caculator {
     public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         Caculator1 computing=new Caculator1();
         PrintWriter output = null;
         try {
             output = new PrintWriter("Caculator.txt");//将程序所出的十道题目以及用户的作答以文本形式保存在Caculator.txt中
         } catch (Exception e) {
         }
         int sum = 0;

         for (int i = 1; i < 11; i++) {
             int a = (int) Math.round(Math.random() * 100);//在0到100以内随机生成两个数作为用算数据
             int b = (int) Math.round(Math.random() * 100);//在0到3内随机生成一个数作为运算符号的选择符号
             int s = (int) Math.round(Math.random() * 3);
         switch(s)//在0到3内随机生成一个数作为运算符号的选择符号进行匹配相应的运算
         {
            case 1:
                System.out.println(i+": "+a+"/"+b+"=");
                while(b==0){
                    b = (int) Math.round(Math.random() * 100);
                    }
                double c = in.nextDouble();
                output.println(a+"/"+b+"="+c);
                if (c == (double)computing.division(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }

                break;

            case 2:
                System.out.println(i+": "+a+"*"+b+"=");
                int c1 = in.nextInt();
                output.println(a+"*"+b+"="+c1);
                if (c1 == computing.multiplication(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }
                break;
            case 3:
                System.out.println(i+": "+a+"+"+b+"=");
                int c2 = in.nextInt();
                output.println(a+"+"+b+"="+c2);
                if (c2 == computing.addition(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }

                break ;
            case 4:
                System.out.println(i+": "+a+"-"+b+"=");
                int c3 = in.nextInt();
                output.println(a+"-"+b+"="+c3);
                if (c3 == computing.subtraction(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }
                break ;

                } 

           }
         System.out.println("scores："+sum);//每答对一道题相应的得到10分，最后将所有分数进行累加并且答应输出
         output.println("scores："+sum);
         output.close();

     }
 }
 class Caculator1
 {
        private int a;//创建变量，
        private int b;
         public int  addition(int a,int b)//定义四种运算方法
         {
             return a+b;
         }
         public int  subtraction(int a,int b)
         {
             if((a-b)<0)
                 return 0;
             else
             return a-b;
         }
         public int   multiplication(int a,int b)
         {
             return a*b;
         }
         public int   division(int a,int b)
         {
             if(b!=0)
             return a/b;
             else
         return 0;
         }

 }

程序总体结结构：

主类Caculator和Caculator1组成

模块说明：

主类Caculator：1.将程序所出的十道题目以及用户的作答以文本形式保存在Caculator.txt中；2.在0到100以内随机生成两个数作为用算数据，在0到3内随机生成一个数作为运算符号的选择符号；3.使用catch语句对0到3内随机生成一个数作为运算符号的选择符号进行匹配相应的运算；4.每答对一道题相应的得到10分，最后将所有分数进行累加并且答应输出

Caculator1类：创建变量，并且定义四种运算方法

目前设计程序存在的困难与问题：将用户输入以及控制台输入保存为文本形式的操作不熟练，没有很好的掌握；以及用算中一些小学生涉及不到的运算知识，例如相减后结果为负号，以及除法运算后出现小数，甚至无线小数的情况没有做具体的改进方法

编程练习2：采用泛型程序设计技术改进实验九编程练习2，使之可处理实数四则运算，其他要求不变。

 import java.io.FileNotFoundException;
 import java.io.PrintWriter;
 import java.util.Scanner;
 public class Caculator {
     public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         Caculator1 computing=new Caculator1();
         PrintWriter output = null;
         try {
             output = new PrintWriter("Caculator.txt");//将程序所出的十道题目以及用户的作答以文本形式保存在Caculator.txt中
         } catch (Exception e) {
         }
         int sum = 0;

         for (int i = 1; i < 11; i++) {
             int a = (int) Math.round(Math.random() * 100);//在0到100以内随机生成两个数作为用算数据
             int b = (int) Math.round(Math.random() * 100);//在0到3内随机生成一个数作为运算符号的选择符号
             int s = (int) Math.round(Math.random() * 3);
         switch(s)//在0到3内随机生成一个数作为运算符号的选择符号进行匹配相应的运算
         {
            case 1:
                System.out.println(i+": "+a+"/"+b+"=");
                while(b==0){
                    b = (int) Math.round(Math.random() * 100);
                    }
                double c = in.nextDouble();
                output.println(a+"/"+b+"="+c);
                if (c == (double)computing.division(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }

                break;

            case 2:
                System.out.println(i+": "+a+"*"+b+"=");
                int c1 = in.nextInt();
                output.println(a+"*"+b+"="+c1);
                if (c1 == computing.multiplication(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }
                break;
            case 3:
                System.out.println(i+": "+a+"+"+b+"=");
                int c2 = in.nextInt();
                output.println(a+"+"+b+"="+c2);
                if (c2 == computing.addition(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }

                break ;
            case 4:
                System.out.println(i+": "+a+"-"+b+"=");
                int c3 = in.nextInt();
                output.println(a+"-"+b+"="+c3);
                if (c3 == computing.subtraction(a, b)) {
                    sum += 10;
                    System.out.println("T");
                }
                else {
                    System.out.println("F");
                }
                break ;

                } 

           }
         System.out.println("scores："+sum);//每答对一道题相应的得到10分，最后将所有分数进行累加并且答应输出
         output.println("scores："+sum);
         output.close();

     }
 }
 class Caculator1
 {
        private int a;//创建变量，
        private int b;
         public int  addition(int a,int b)//定义四种运算方法
         {
             return a+b;
         }
         public int  subtraction(int a,int b)
         {
             if((a-b)<0)
                 return 0;
             else
             return a-b;
         }
         public int   multiplication(int a,int b)
         {
             return a*b;
         }
         public int   division(int a,int b)
         {
             if(b!=0)
             return a/b;
             else
         return 0;
         }

 }

实验总结：泛型程序主要应用于相似场景下不同的类以及对象，定义泛型类时用尖括号将引入的类型变量括起来跟在类名之后；泛型变量的上界的定义：public class NumberGeneric< T extends Number>：泛型变量的下界的定义：List<? super CashCard> cards = new ArrayList<T>();Java中的数组是协变的，但泛型类型不满足这一原理；“？”符号表明参数的类型可以是任何一种类
型，它和参数T的含义是有区别的。T表示一种
未知类型，而“？”表示任何一种类型。这种
通配符一般有以下三种用法：
– 单独的？，用于表示任何类型。
– ? extends type，表示带有上界。
– ? super type，表示带有下界。

实例化泛型对象的时候，一定要在类名后面指定类
型参数的值（类型），一共要有两次书写。例如：
TestGeneric＜String, String＞ t
=new TestGeneric＜String, String＞()；
 泛型中＜T extends Object＞, extends并不代表继
承，它是类型范围限制。