201871010133-赵永军《面向对象程序设计（java）》第十一周学习总结

201871010133-赵永军《面向对象程序设计（java）》第十一周学习总结

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11815810.html
作业学习目标	理解泛型概念； 掌握泛型类的定义与使用； 掌握泛型方法的声明与使用； 掌握泛型接口的定义与实现； 了解泛型程序设计，理解其用途

 

 

 

 

 

 

 

 

 

 

 

 

 

第一部分：理论部分。

1.泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。

1）泛型（参数化类型）：在定义类、接口和方法时，通过类型参数指示将要处理的对象类型。如ArrayList类是一个泛型程序设计的实例，可以聚集任何类型的对象。

2）泛型类：就是具有一个或多个类型变量的类，即创建用类型作为参数的类。在<>内定义形式类型参数，该形参表示类型而不表示值。

泛型类可以有多个类型变量，例如:public class Pair<T, U>

类定义中的类型变量用于指定方法的返回类型以及域、局部变量的类型。

3）泛型方法：除了泛型类外，还可以只单独定义一个方法作为泛型方法，用于指定方法参数或者返回值为泛型类型，在方法调用时确定具体需要。（泛型方法可以声明在泛型类中，也可以声明在普通类中）

4）泛型变量的限定：a.泛型变量的上界：如<T extends Number>（extends关键字所声明的上界既可以是一个类，也可以是一个接口，extends并不代表继承，它是类型范围限制。）

                                  b.泛型变量的上界：如<? super CashCard>(通过使用super关键字可以固定泛型参数的类型为某种类型或者其超类当程序希望为一个方法的参数限定类型时，通常可以使用下限通配符)

2.泛型类的约束与局限性。

1）不能用基本类型（如int型，float型等）实例化类型参数
2）运行时类型查询只适用于原始类型
3）不能抛出也不能捕获泛型类实例
4）参数化类型的数组不合法
5）不能实例化类型变量
6）泛型类的静态上下文中类型变量无效
7）注意擦除后的冲突

3.泛型类型的继承规则：Java中的数组是协变的，但这一原理不适用于泛型类型。

泛型类可扩展或实现其它的泛型类。

4.通配符：“？”符号表明参数的类型可以是任何一种类型，而T表示一种未知类型。

通配符的一般用法：a.?：用于表示任何类型；

                                b.? extends type，表示带有上界；

                                c.? super type，表示带有下界。

第二部分：实验部分

1、实验目的与要求

(1) 理解泛型概念；

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

(3) 了解泛型方法的声明与使用；

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

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

2、实验内容和步骤

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

测试程序1：

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

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

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

实验测试程序如下：

/**
 * @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" };//初始化一个String对象数组
      Pair<String> mm = ArrayAlg.minmax(words);//一对字符串：min,max
      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)//普通方法，定义minmax为字符串类型
   {
      if (a == null || a.length == 0) return null;
      String min = a[0];
      String max = a[0];
      //将元素的泛型具体声明
      
      for (int i = 1; i < a.length; i++)//length:数组属性值
      {
         if (min.compareTo(a[i]) > 0) min = a[i];
         if (max.compareTo(a[i]) < 0) max = a[i];
      }//实现字符串比较大小
      return new Pair<>(min, max);
   }
}

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

实验运行结果如下：

 

 

 

 

测试程序2：

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

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

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

实验测试程序如下：

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) //泛型方法（comparable是T的上界约束）
   {
      if (a == null || a.length == 0) return null;
      T min = a[0];
      T max = a[0];//min和max与T的类型一致
      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);
   }
}

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

实验运行结果如下：

 

 

 

测试程序3：

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

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

实验程序如下：

/**
 * @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)//通配符类型（带有上界）extends关键字所声明的上界既可以是一个类，也可以是一个接口。
   {
      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)//通配符类型（带有下界）必须是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)//通配符类型（带有下界）
   {
      minmaxBonus(a, result);
      PairAlg.swapHelper(result); //swapHelper捕获通配符类型
   }
   //无法编写公共静态< T超级管理器>
}

class PairAlg
{
   public static boolean hasNulls(Pair<?> p)//通过将hasNulls转换成泛型方法,避免使用通配符类型
   {
      return p.getFirst() == null || p.getSecond() == null;
   }

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

   public static <T> void swapHelper(Pair<T> p)//使用辅助方法swapHelper（泛型方法）,以在交换时临时保存第一个元素
   {
      T t = p.getFirst();
      p.setFirst(p.getSecond());
      p.setSecond(t);
   }
}

/**
 * @version 1.00 2004-05-10
 * @author Cay Horstmann
 */
public class Pair<T> 
{
   private T first;
   private T second;
//T是未知类型，不代表值
   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; }
}

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

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

程序运行结果如下：

 

 三、实验总结

       这周主要学习了泛型程序，泛型类和泛型方法同时具备可重用性、类型安全和效率，泛型类不会强行对值类型进行装箱和拆箱，或对引用类型进行向下强制类型转换，所以是编程性能得到提高。在学习理论课时，听老师讲泛型类不算特别难，但在实验课上运行程序时，并不是太理解程序，经过学长的讲解，对程序有了一定程度的理解，但是也只是基本能读懂程序，在自己编程时，还是有很大问题。在之后的学习中，我会多练习程序去了解这些知识，争取能够独立完整的编写程序。