作者：手机用户彡2570437895 | 来源：互联网 | 2023-09-25 19:31
第十周总结
一、知识总结
1.定义简单泛型类
1.1一个泛型类Generic class就是具有一个或多个类型变量的类
1.2Java中，使用E表示集合的元素类型，K和V表示Map的关键字和值的类型。T（需要时还可以使用临近的U和S）表示“任意类型”。
1.3泛型类可以看作普通类的工厂
2.泛型方法
2.1类型变量放在修饰符的后面，返回类型的前面。泛型方法可以定义在普通类中，也可以定义在泛型类中。
2.2当调用一个方法时，在方法名前的尖括号中放入具体的类型。
3.类型变量的限定
3.1表示T应该是绑定类型的子类型subtype，T和绑定类型可以是类，也可以是接口。一个类型变量或通配符可以有多个限定（用&）
3.2如果用一个类作为限定，它必须是限定列表中的第一个。
4.泛型代码和虚拟机
4.1无论何时定义一个泛型类型，都自动提供了一个相应的原始类型raw type。原始类型的名字就是删去类型参数后的泛型类型名。擦除erased类型变量，并替换为限定类型（无限定的变量用Object）
4.2为了提高效率，应该将标签tagging接口（即没有方法的接口）放在边界列表的末尾。
4.3桥方法bridge method
4.4具有协变的返回类型covariant return types
4.5记住有关泛型转换的事实：1.虚拟机中没有泛型，只有普通的类和方法；2.所有的类型参数都用它们的限定类型替换；3.桥方法被合成来保持多态；4.为保持类型安全性，必要时插入强制类型转换。
5.约束与局限性
5.1不能用基本类型实例化类型参数
5.2运行时类型查询只适用于原始类型
5.3不能创建参数化类型的数组
5.4Varargs警告：使用@SafeVarargs
5.5不能实例化类型变量
5.6不能构造泛型数组
5.7泛型类的静态上下文中类型变量无效
5.8不能抛出或捕获泛型类的实例
5.9可以消除对受查异常的检查
5.10注意擦除后的冲突
6.泛型类型的继承规则
6.1泛型类不是斜变的
7.通配符类型
7.1通配符类型中，允许类型参数变化。如Class表示任何泛型Class类型，它的类型参数是SuperClass的子类，如Class
7.2超类型限定supertype bound：？ super subClass 这个通配符限制为subClass的所有超类型。可以为方法提供参数，但不能使用返回值。
7.3无限定通配符 ：Class 和Class本质的不同在于：可以用任意的Object对象调用原始class的setObject方法
二、实验：泛型程序设计技术
1、实验目的与要求
(1) 理解泛型概念；
(2) 掌握泛型类的定义与使用；
(3) 掌握泛型方法的声明与使用；
(4) 掌握泛型接口的定义与实现；
(5)了解泛型程序设计，理解其用途。
2、实验内容和步骤
实验1： 导入第8章示例程序，测试程序并进行代码注释。
测试程序1：
l 编辑、调试、运行教材311、312页 代码，结合程序运行结果理解程序；
l 在泛型类定义及使用代码处添加注释；
l 掌握泛型类的定义及使用。
代码：
package pair1;
/**
* @version 1.00 2004-05-10
* @author Cay Horstmann
*/
public class Pair //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 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" };
//ArrayAlg调用静态方法minmax()；
Pair 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 minmax(String[] a)//定义静态泛型方法，将类型变量实例化为String；
{
if (a == null || a.length == 0) return null;//a.length是数组的属性值；
String min = a[0];
String max = a[0];
for (int i = 1; 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
{
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 PairTest1.Pair;
import java.time.*;
/**
* @version 1.02 2015-06-21
* @author Cay Horstmann
*/
public class PairTest2
{
public static void main(String[] args)
{
LocalDate[] birthdays =
{ //按ASCII码比较，大写字母比小写字母的ASCII码小;
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
};
//ArrayAlg调用静态方法minmax();
Pair 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 extends Comparable> Pair minmax(T[] a) //泛型变量加了泛型约束的方法;
{
if (a == null || a.length == 0) return null;
T min = a[0];
T max = a[0];
for (int i = 1; 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：
l 用调试运行教材335页 PairTest3，结合程序运行结果理解程序；
l 了解通配符类型的定义及用途。
代码：
package pair3;
/**
* @version 1.00 2004-05-10
* @author Cay Horstmann
*/
public class Pair
{
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 buddies = new Pair<>(ceo, cfo);
printBuddies(buddies);
ceo.setBonus(1000000);
cfo.setBonus(500000);
Manager[] managers = { ceo, cfo };
Pair 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(Pairextends Employee> p)
//表示带有上界
{
Employee first = p.getFirst();
Employee second = p.getSecond();
System.out.println(first.getName() + " and " + second.getName() + " are buddies.");
}
//"?"在这儿是通配符，符号表明参数的类型可以是任何一种类型，它和参数T的含义是有区别的
public static void minmaxBonus(Manager[] a, Pairsuper Manager> result)//表示带有下界
{
if (a.length == 0) return;
Manager min = a[0];
Manager max = a[0];
for (int i = 1; i )
{
if (min.getBonus() > a[i].getBonus()) min = a[i];
if (max.getBonus() a[i];
}
result.setFirst(min);
result.setSecond(max);
}
//T表示一种未知类型，而“？”表示任何一种类型
public static void maxminBonus(Manager[] a, Pairsuper Manager> result)
{
minmaxBonus(a, result);
PairAlg.swapHelper(result); // swapHelper捕获通配符类型
}
}
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 void swapHelper(Pair p)
{
T t = p.getFirst();
p.setFirst(p.getSecond());
p.setSecond(t);
}
}
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;
}
}
结果：
实验2：编程练习：
编程练习1：实验九编程题总结
l 实验九编程练习1总结（从程序总体结构说明、模块说明，目前程序设计存在的困难与问题三个方面阐述）。
程序总体结构：主类Main和子类test
模块说明：主类当中进行文件的读取以及操作，test类实现了comparable接口，控制其输出形式
困难与问题：对捕获知识掌握的不好
l 实验九编程练习2总结（从程序总体结构说明、模块说明，目前程序设计存在的困难与问题三个方面阐述）。
程序总体结构：主类和yunsuan类
模块说明：主类调用以及实现yunsuan类的功能，yunsuan类主要模块化实现各种操作
困难与问题：在yunsuan类的编写中，很多操作不知怎样具体化；对于switch语句掌握不好
编程练习2：采用泛型程序设计技术改进实验九编程练习2，使之可处理实数四则运算，其他要求不变。
代码：
package fghjg;
import java.util.Random;
import java.util.Scanner;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
public class Main{
public static void main(String[] args)
{
yunsuan counter=new yunsuan();//与其它类建立联系
PrintWriter out=null;
try {
out=new PrintWriter("D:/text.txt");//将文件里的内容读入到D盘名叫text的文件中
}catch(FileNotFoundException e) {
System.out.println("文件找不到");
e.printStackTrace();
}
int sum=0;
for(int i=0;i<10;i++)
{
int a=new Random().nextInt(100);
int b=new Random().nextInt(100);
Scanner in=new Scanner(System.in);
//in.close();
switch((int)(Math.random()*4))
{
case 0:
System.out.println( ""+a+"+"+b+"=");
int c1 = in.nextInt();
out.println(a+"+"+b+"="+c1);
if (c1 == counter.plus(a, b)) {
sum += 10;
System.out.println("答案正确");
}
else {
System.out.println("答案错误");
}
break ;
case 1:
if(a<b)
{
int temp=a;
a=b;
b=temp;
}//为避免减数比被减数大的情况
System.out.println(""+a+"-"+b+"=");
/*while((a-b)<0)
{
b = (int) Math.round(Math.random() * 100);
}*/
int c2 = in.nextInt();
out.println(a+"-"+b+"="+c2);
if (c2 == counter.minus(a, b)) {
sum += 10;
System.out.println("答案正确");
}
else {
System.out.println("答案错误");
}
break ;
case 2:
System.out.println(""+a+"*"+b+"=");
int c = in.nextInt();
out.println(a+"*"+b+"="+c);
if (c == counter.multiply(a, b)) {
sum += 10;
System.out.println("答案正确");
}
else {
System.out.println("答案错误");
}
break;
case 3:
while(b==0)
{ b = (int) Math.round(Math.random() * 100);//满足分母不为0
}
while(a%b!=0)
{
a = (int) Math.round(Math.random() * 100);
b = (int) Math.round(Math.random() * 100);
}
System.out.println(""+a+"/"+b+"=");
int c0= in.nextInt();
out.println(a+"/"+b+"="+c0);
if (c0 == counter.divide(a, b)) {
sum += 10;
System.out.println("答案正确");
}
else {
System.out.println("答案错误");
}
break;
}
}
System.out.println("totlescore:"+sum);
out.println(sum);
out.close();
}
}
package fghjg;
public class yunsuan {
private T a;
private T b;
public void yunsaun()
{
a=null;
b=null;
}
public void yunsuan(T a,T b)
{
this.a=a;
this.b=b;
}
public int plus(int a,int b)
{
return a+b;
}
public int minus(int a,int b)
{
return a-b;
}
public int multiply(int a,int b)
{
return a*b;
}
public int divide(int a,int b)
{
if(b!=0 && a%b==0)
return a/b;
else
return 0;
}
}
结果：
三、实验总结
本次实验主要是在上周实验的基础上更加深刻的去理解泛型概念；掌握泛型类的定义与使用以及泛型方法的声明与使用；了解泛型接口的定义与实现。
![[大整数乘法] java代码实现](https://img1.php1.cn/3cd4a/24c6f/9f3/0133bb25da242824.jpeg)
京公网安备 11010802041100号