201771010135 杨蓉庆《面对对象程序设计（java）》第十周学习总结

1、实验目的与要求

(1) 理解泛型概念；

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

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

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

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

一、理论知识

泛型类的定义：

（1）泛型：也称参数化类型(parameterized type)，就是在定义类、接口和方法时，通过类型参数指示将要处理的对象型。

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

（3）Pair类引入了一个类型变量T，用尖括号（<>）括起来，并放在类名的后面。

泛型变量的限定：

（1）extends关键字所声明的上界既可以是一个类，也可以是一个接口；

(2)<T extends Bounding Type>表示T应该是绑定类型的子类型。

泛型变量下界的说明:
– 通过使用super关键字可以固定泛型参数的类型为某种
类型或者其超类
– 当程序希望为一个方法的参数限定类型时，通常可以使
用下限通配符

泛型类的约束与局限性:

不能用基本类型实例化类型参数
运行时类型查询只适用于原始类型
不能抛出也不能捕获泛型类实例
参数化类型的数组不合法不能实例化类型变量
泛型类的静态上下文中类型变量无效
注意擦除后的冲突

通配符类型:

“？”符号表明参数的类型可以是任何一种类型，它和参数T的含义是有区别的。T表示一种未知类型，而“？”表示任何一种类型.

这种通配符一般有以下三种用法：
单独的？，用于表示任何类型。
? extends type，表示带有上界。
? super type，表示带有下界。

二、实验内容和步骤

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

测试程序1：

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

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

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

package pair1;

/**

 * @version 1.00 2004-05-10

 * @author Cay Horstmann

 */

public class Pair<T>//Pair类引入了一个类型变量T

{

   private T first;//use the type variable

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

{

   /**

    * 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];//compareTo比较方法

         if (max.compareTo(a[i]) < 0) max = a[i];

      }

      return new Pair<>(min, max);//实例化后的调用对象

   }

}

结果如下：

测试程序2：

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

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

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

package pair1;

/**

 * @version 1.00 2004-05-10

 * @author Cay Horstmann

 */

public class Pair<T>//Pair类引入了一个类型变量T

{

   private T first;//use the type variable

   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);//实例化一个LocalDat类

      System.out.println("min = " + mm.getFirst());

      System.out.println("max = " + mm.getSecond());//得到min、max

   }

}

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) //将T限制为实现Comparable接口的类

   {

      if (a == null || a.length == 0) return null;

      T min = a[0];

      T max = a[0];

      for (int i = 1; i < a.length; i++)//compareTo方法

      {

         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：

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

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

package pair3;

/**

 * @version 1.01 2012-01-26

 * @author Cay Horstmann

 */

public class PairTest3

{

   public static void main(String[] args)

   {

       //定义Manager类

      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)

   //任何泛型Pair类型，它的类型参数是Manager的子类

   {

      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)//统配符限制为Manager的所有超类型

   {

      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)//泛型类；类型变量的通配符“？”

   {

      return p.getFirst() == null || p.getSecond() == null;

   }

   public static void swap(Pair<?> p) { swapHelper(p); }

   //swap调用swapHelper

   public static <T> void swapHelper(Pair<T> p)

   {

      T t = p.getFirst();

      p.setFirst(p.getSecond());

      p.setSecond(t);

   }

}

Employee:

package pair3;

import java.time.*;

public class Employee

//构造一个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直接引用

      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;

   }

}

Manager：

package pair3;

public class Manager extends Employee//Manager类的父类是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;

   }

}l

结果如下：

实验2：编程练习：

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

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

package ID;

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;

@SuppressWarnings("unused")

public class Main{

    private static ArrayList<Person> Personlist;

    @SuppressWarnings("resource")

    public static void main(String[] args) {

        Personlist = new ArrayList<>();

        Scanner scanner = new Scanner(System.in);

        File file = new File("E:\\新建文件夹\\身份证号.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 ID = linescanner.next();

                String sex = linescanner.next();

                String age = linescanner.next();

                String place =linescanner.nextLine();

                Person Person = new Person();

                Person.setname(name);

                Person.setID(ID);

                Person.setsex(sex);

                int a = Integer.parseInt(age);

                Person.setage(a);

                Person.setbirthplace(place);

                Personlist.add(Person);

            }

        } 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:查询人员中是否有你的同乡");

            int nextInt = scanner.nextInt();

            switch (nextInt) {

            case 1:

                Collections.sort(Personlist);

                System.out.println(Personlist.toString());

                break;

            case 2:

                int max=0,min=100;int j,k1 = 0,k2=0;

                for(int i=1;i<Personlist.size();i++)

                {

                    j=Personlist.get(i).getage();

                   if(j>max)

                   {

                       max=j;

                       k1=i;

                   }

                   if(j<min)

                   {

                       min=j;

                       k2=i;

                   }

                }

                System.out.println("年龄最大："+Personlist.get(k1));

                System.out.println("年龄最小："+Personlist.get(k2));

                break;

            case 3:

                System.out.println("place?");

                String find = scanner.next();

                String place=find.substring(0,3);

                String place2=find.substring(0,3);

                for (int i = 0; i <Personlist.size(); i++)

                {

                    if(Personlist.get(i).getbirthplace().substring(1,4).equals(place))

                        System.out.println(""+Personlist.get(i));

                } 

                break;

            case 4:

                System.out.println("年龄：");

                int yourage = scanner.nextInt();

                int near=agenear(yourage);

                int d_value=yourage-Personlist.get(near).getage();

                System.out.println(""+Personlist.get(near));

           /*     for (int i = 0; i < Personlist.size(); i++)

                {

                    int p=Personlist.get(i).getage()-yourage;

                    if(p<0) p=-p;

                    if(p==d_value) System.out.println(Personlist.get(i));

                }   */

                break;

            case 5:

           isTrue = false;

           System.out.println("退出程序!");

                break;

            default:

                System.out.println("输入有误");            }

        }

    }

    public static int agenear(int age) {

       int j=0,min=53,d_value=0,k=0;

        for (int i = 0; i < Personlist.size(); i++)

        {

            d_value=Personlist.get(i).getage()-age;

            if(d_value<0) d_value=-d_value;

            if (d_value<min)

            {

               min=d_value;

               k=i;

            }

         }    return k;

        }

}

Main

程序总体结构：总体分为Main类和Person类

Main类：

1、将人员身份信息导入代码中

2、编辑了查找人员信息的方法

3、分5个case来分别说年龄大小、同乡等消息

Person类：

package ID;

public class Person implements Comparable<Person> {

private String name;

private String ID;

private int age;

private String sex;

private String birthplace;

public String getname() {

return name;

}

public void setname(String name) {

this.name = name;

}

public String getID() {

return ID;

}

public void setID(String ID) {

this.ID= ID;

}

public int getage() {

return age;

}

public void setage(int age) {

    // int a = Integer.parseInt(age);

this.age= age;

}

public String getsex() {

return sex;

}

public void setsex(String sex) {

this.sex= sex;

}

public String getbirthplace() {

return birthplace;

}

public void setbirthplace(String birthplace) {

this.birthplace= birthplace;

}

public int compareTo(Person o) {

   return this.name.compareTo(o.getname());

}

public String toString() {

    return  name+"\t"+sex+"\t"+age+"\t"+ID+"\t"+birthplace+"\n";

}

}

Person

对各个小模块进行具体的分析

程序设计存在的困难与问题：

1、编写时基础错误还是很多

2、Main类和Person类的变量名有时不能统一

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

程序总体结构：Demo主类和Counter类

模块说明:Demo主类

import java.io.FileNotFoundException;

import java.io.PrintWriter;

import java.util.Scanner;

public class Demo {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        jf counter=new jf();

        PrintWriter out = null;

        try {

            out = new PrintWriter("text.txt");

        } catch (FileNotFoundException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        int sum = 0;

        for (int i = 1; i <=10; i++) {

            int a = (int) Math.round(Math.random() * 100);

            int b = (int) Math.round(Math.random() * 100);

            int m= (int) Math.round(Math.random() * 3);

           switch(m)

           {

           case 0:

               System.out.println(i+": "+a+"/"+b+"=");

               while(b==0){  b = (int) Math.round(Math.random() * 100); }

            int c0 = in.nextInt();

            out.println(a+"/"+b+"="+c0);

            if (c0 == jf.division(a, b)) {

                sum += 10;

                System.out.println("恭喜答案正确");

            }

            else {

                System.out.println("抱歉，答案错误");

            }

            break;

           case 1:

               System.out.println(i+": "+a+"*"+b+"=");

               int c = in.nextInt();

               out.println(a+"*"+b+"="+c);

               if (c == counter.multiplication(a, b)) {

                   sum += 10;

                   System.out.println("恭喜答案正确");

               }

               else {

                   System.out.println("抱歉，答案错误");

               }

               break;

           case 2:

               System.out.println(i+": "+a+"+"+b+"=");

               int c1 = in.nextInt();

               out.println(a+"+"+b+"="+c1);

               if (c1 == counter.add(a, b)) {

                   sum += 10;

                   System.out.println("恭喜答案正确");

               }

               else {

                   System.out.println("抱歉，答案错误");

               }

               break ;

           case 3:

               System.out.println(i+": "+a+"-"+b+"=");

               int c2 = in.nextInt();

               out.println(a+"-"+b+"="+c2);

               if (c2 == counter.reduce(a, b)) {

                   sum += 10;

                   System.out.println("恭喜答案正确");

               }

               else {

                   System.out.println("抱歉，答案错误");

               }

               break ;

               } 

          }

        System.out.println("成绩"+sum);

        out.println("成绩:"+sum);

         out.close();

    }

    }

Demo

1、判断答案的正确性代码

2、文件的读取

3、四则运算代码的具体呈现

Counter类

public class Counter {

   private int a;

   private int b;

    public int  add(int a,int b)

    {

        return a+b;

    }

    public int   reduce(int a,int b)

    {

        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;

    }

}

Counter

四则运算的计算过程及返回值

程序设计存在的困难与问题：

1、数值过大，无法口算

2、运算复杂，不符合基础运算难度

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

package C;

import java.io.FileNotFoundException;

import java.io.PrintWriter;

import java.util.Random;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        Suanfa counter = new Suanfa();

        PrintWriter out = null;

        try {

            out = new PrintWriter("test.txt");

        } catch (FileNotFoundException e) {

            System.out.println("文件夹输出失败");

            e.printStackTrace();

        }

        int sum = 0;

        for (int i = 1; i <= 10; i++) {

            int a = (int) Math.round(Math.random() * 100);

            int b = (int) Math.round(Math.random() * 100);

            int m;

            Random rand = new Random();

            m = (int) rand.nextInt(4) + 1;

            System.out.println("随机生成的四则运算类型：" + m);

            switch (m) {

            case 1:

                a = b + (int) Math.round(Math.random() * 100);

                while(b == 0){

                    b = (int) Math.round(Math.random() * 100);

                }

                while(a % b != 0){

                    a = (int) Math.round(Math.random() * 100);

                    }

              //若生成的除法式子必须能整除，且满足分母为0的条件，则a一定要大于b，且a模b的结果要为0。

                System.out.println(i + ": " + a + "/" + b + "=");

                int c0 = in.nextInt();

                out.println(a + "/" + b + "=" + c0);

                if (c0 == counter.d(a, b)) {

                    sum += 10;

                    System.out.println("正确!");

                } else {

                    System.out.println("错误!");

                }

 break;

            case 2:

                System.out.println(i + ": " + a + "*" + b + "=");

                int c = in.nextInt();

                out.println(a + "*" + b + "=" + c);

                if (c == counter.m(a, b)) {

                    sum+= 10;

                    System.out.println("正确!");

                } else {

                    System.out.println("错误!");

                }

                break;

            case 3:

                System.out.println(i + ": " + a + "+" + b + "=");

                int c1 = in.nextInt();

                out.println(a + "+" + b + "=" + c1);

                if (c1 == counter.add(a, b)) {

                    sum += 10;

                    System.out.println("正确!");

                } else {

                    System.out.println("错误!");

                }

                break;

            case 4:

                while (a < b) {

                    b = (int) Math.round(Math.random() * 100);

                }

              //因为不能产生运算结果为负数的减法式子，所以a一定要大于b。若a<b,则重新生成b。

                System.out.println(i + ": " + a + "-" + b + "=");

                int c2 = in.nextInt();

                out.println(a + "-" + b + "=" + c2);

                if (c2 == counter.r(a, b)) {

                    sum += 10;

                    System.out.println("正确!");

                } else {

                    System.out.println("错误!");

                }

                break;

            }

        }

        System.out.println("成绩" + sum);

        out.println("成绩:" + sum);

        out.close();

    }

}

Main

package C;

public class Suanfa<T> {

    private T a;

    private T b;

   public int add(int a,int b) {

        return a + b;

    }

    public int r(int a, int b) {

        return a - b;

    }

    public int m(int a, int b) {

        return a * b;

    }

    public int d(int a, int b) {

        if (b != 0 && a%b==0)

            return a / b;

        else

            return 0;

    }

}

Suanfa

结果如下：

三、总结如下：

本章我们学习了泛型程序设计技术，首先理解了泛型概念，掌握泛型类的定义与使用，泛型方法的声明与使用，最后感觉了解泛型程序设计及其用途，在验证实验中，通过对代码的解读，更深的学习了泛型程序<T>的使用，还复习了实验九的两个编程题目，感觉依旧存在些小问题，在接下来的实验中要更好的解决，编程实验中，在实验九的四则运算基础上，加入了本章泛型程序的概念，虽然不是很熟练，但还是勉强做出来了。

巴特西

201771010135 杨蓉庆《面对对象程序设计（java）》第十周学习总结

最新文章

热门文章