A:简答题
1、请简述泛型是什么?有什么用?在哪里用?
1.泛型是确定数据类型的一种方法
2.泛型把运行时期的问题提前到编译时期
避免强制转换
把类型推迟到创建对象或者调用方法时才明确
3.泛型可以在类 接口 方法 上使用
2、请把今天讲解的方法,在API中查找到,并用自己的话进行描述
Vector
public void addElement(E obj)
在集合末尾处添加一个元素obj
public E elementAt(int index)
返回集合中索引index的值
public boolean removeElement(Object obj)
删除集合中第一次出现的元素obj
public void removeElementAt(int index)
删除集合中索引index的值
public void setElementAt(E obj, int index)
把集合中索引index的值修改为obj
public Enumeration<E> elements()
返回一个Enumeration 其中包含此Vector的所有对象
Enumeration
public boolean hasMoreElements()
检测Enumeration 对象是否还有元素
public Object nextElement()
如果Enumeration对象还有元素 该方法得到下一个元素
LinkedList
public void addFirst(E e)
在集合开始处添加元素e
public void addLast(E e)
在集合结尾处添加元素e
public E getFirst()
获取集合第一个元素
public E getLast()
获取集合最后一个元素
public E removeFirst()
删除集合第一个元素
public E removeLast()
删除集合最后一个元素
3、请简述List<? extends T>和List<? super T>之间有什么区别?
List<? extends T> 后面的泛型只能写T或者T的子类类型
List<? super T> 后面的泛型只能写T或者T的父类类型
4、请简述如何编写一个泛型方法,让它能够接受泛型参数并返回泛型类型?并举例
格式
权限修饰符 <泛型类型> 返回类型 方法名(泛型类型 变量名)
public <X> X ok(X x){
return x;
}
5、请简述Java中如何使用泛型编写带有参数的类?并举例
格式
public class 类名<泛型类型1,…>
public class Cat<X>{}
B:看程序写结果(写出自己的分析理由),程序填空,改错,看程序写结果。
1、给出以下代码,请问该程序的运行结果是什么?如有问题,请说明原因。
class Test<T> {
private T name;
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public static void main(String[] args) {
Test<String> strTest = new Test<String>();
strTest.setName("aaa");
System.out.println(strTest.getName());
Test<Integer> intTest = new Test<Integer>();
intTest.setName(1234);
System.out.println(intTest.getName());
}
}
/*
aaa
1234
*/
2、给出以下代码,如有问题,请说明原因。
//需求:定义一个方法,该方法用于打印出任意参数化类型的集合中的所有数据
public static void printCollection (Collection<Object> cols) {
for (Object obj : cols) {
System.out.println( obj );
}
}
1. 定义一个泛型方法
格式:权限修饰符 <泛型类型> 返回类型 方法名(泛型类型 变量名)
2. ? extends E 向下限定,E及其子类
//1.泛型方法的格式改正
public static <X> void printCollection (Collection<X> cols) {
for (X x : cols) {
System.out.println(x);
}
}
//2.泛型通配符
public static void printCollection (Collection<? extends Object> cols) {
for (Object obj : cols) {
System.out.println( obj );
}
}
3、 给出以下代码,如有问题,请说明原因。
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
class GenericDemo {
public static void main(String[] args) {
Collection<Object> c = new ArrayList<Object>();
Collection<Animal> c1 = new ArrayList<Animal>();
//Collection<Animal> c2 = new ArrayList<Dog>();
//Collection<Animal> c3 = new ArrayList<Cat>();
//泛型类型不同
//Collection<? extends Animal> c4 = new ArrayList<Object>();
//泛型通配符<? extends Animal> 后面泛型只能是Animal或者其子类类型
Collection<? extends Animal> c5 = new ArrayList<Animal>();
Collection<? extends Animal> c6 = new ArrayList<Dog>();
Collection<? extends Animal> c7 = new ArrayList<Cat>();
Collection<? super Animal> c8 = new ArrayList<Object>();
Collection<? super Animal> c9 = new ArrayList<Animal>();
//Collection<? super Animal> c10 = new ArrayList<Dog>();
//Collection<? super Animal> c11 = new ArrayList<Cat>();
泛型通配符<? super Animal> 后面泛型只能是Animal或者其父类类型
}
}
4、给出以下代码,请问该程序的运行结果是什么?如有问题,请说明原因。
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
interface Inter {
public abstract void method();
}
class SubEx implements Inter {
public void method() {
System.out.println("SubEx");
}
}
class GenericTest {
public static void main(String[] args) {
List<SubEx> list = new ArrayList<SubEx>();
SubEx se = new SubEx();
list.add(se);
printList1(list);
printList2(list);
//printList3(list);
//printList4(list);
//泛型类型不匹配
}
/*
SubEx
SubEx
*/
public static void printList1(List<? extends Inter> list) {
for (Inter in : list) {
in.method();
}
}
public static void printList2(List<?> list) {
for (Object obj : list) {
((Inter) obj).method();
}
}
public static void printList3(List<Inter> list) {
for (Inter in : list) {
in.method();
}
}
public static void printList4(List<Object> list) {
for (Object obj : list) {
((Inter) obj).method();
}
}
}
C:编程题
1、请编写程序,将自定义对象存储到ArrayList集合,使用泛型并遍历
a.使用迭代器遍历
b.使用列表迭代器遍历
c.使用size()和get()方法遍历
d.使用增强for遍历
public class Homework01 {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
//a.使用迭代器遍历
Iterator<Integer> iterator = arrayList.iterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
System.out.println(integer);
}
//b.使用列表迭代器遍历
ListIterator<Integer> listIterator = arrayList.listIterator();
while (listIterator.hasNext()) {
Integer integer = listIterator.next();
System.out.println(integer);
}
//c.使用size()和get()方法遍历
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
//d.使用增强for遍历
for (Integer integer : arrayList) {
System.out.println(integer);
}
}
}
2、请编写程序,将自定义对象存储到Vector集合,使用泛型并遍历
a.使用迭代器遍历
b.使用Vector特有的迭代器遍历
c.使用size()和get()方法遍历
d.使用增强for遍历
public class Homework02 {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
vector.add("jack");
vector.add("tom");
vector.add("smith");
//a.使用迭代器遍历
Iterator<String> iterator = vector.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
}
//b.使用Vector特有的迭代器遍历
ListIterator<String> listIterator = vector.listIterator();
while (listIterator.hasNext()) {
String s = listIterator.next();
System.out.println(s);
}
//c.使用size()和get()方法遍历
for (int i = 0; i < vector.size(); i++) {
System.out.println(vector.get(i));
}
//d.使用增强for遍历
for (String s : vector) {
System.out.println(s);
}
}
}
3、请编写程序,将自定义对象存储到LinkedList集合,使用泛型并遍历
a.使用迭代器遍历
b.使用列表迭代器遍历
c.使用size()和get()方法遍历
d.使用增强for遍历
public class Homework03 {
public static void main(String[] args) {
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(10);
linkedList.add(20);
linkedList.add(30);
//a.使用迭代器遍历
Iterator<Integer> iterator = linkedList.iterator();
while (iterator.hasNext()) {
Integer integer = iterator.next();
System.out.println(integer);
}
//b.使用列表迭代器遍历
ListIterator<Integer> listIterator = linkedList.listIterator();
while (listIterator.hasNext()) {
Integer integer = listIterator.next();
System.out.println(integer);
}
//c.使用size()和get()方法遍历
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
//d.使用增强for遍历
for (Integer integer : linkedList) {
System.out.println(integer);
}
}
}
4、请编写程序,完成N个数 相加的功能,并测试
public class Homework04 {
public static void main(String[] args) {
int count = 2;//至少添加两个整数
//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("输入第1个整数");
int num1 = sc.nextInt();
System.out.println("输入第2个整数");
int num2 = sc.nextInt();
int sum = num1 + num2;//相加结果
//获取key值
char key = getKey(sc);
while (true) {
//若key为y时 继续添加数据
if (key == 'y') {
count++;
System.out.println("输入第" + count + "个整数");
int num = sc.nextInt();
sum += num;
key = getKey(sc);
}
//若key为n时 退出程序
if (key == 'n') {
break;
}
//若key不是y/n时 重新输入 直到是y/n
if (key != 'y' && key != 'n') {
System.out.println("输入有误 重新输入");
key = getKey(sc);
}
}
System.out.println(count + "个整数和=" + sum);
}
//获取key值 判断是否添加整数
private static char getKey(Scanner sc) {
char key;//判断是否还要相加
System.out.println("是否还要添加整数 y/n");
key = sc.next().charAt(0);
return key;
}
}