Day16练习

Hello World️

已于 2022-08-02 17:49:39 修改

阅读量153

点赞数

分类专栏： javaSE 文章标签： java 开发语言

于 2022-05-19 10:28:13 首次发布

本文链接：https://blog.csdn.net/m0_51318597/article/details/124858062

版权

javaSE 专栏收录该内容

59 篇文章 1 订阅

订阅专栏

本文深入探讨了Java中的泛型概念及其作用，包括泛型在类、接口和方法上的应用。详细解释了泛型在Vector和LinkedList等集合类中的使用方法，并对比了List<? extends T>与List<? super T>的区别。此外，还提供了泛型方法的编写范例以及带参数泛型类的创建。最后，通过示例代码展示了如何在实际编程中遍历ArrayList、Vector和LinkedList等集合。

摘要由CSDN通过智能技术生成

文章目录

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

Hello World️

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Day16练习

文章目录A:简答题B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。C:编程题A:简答题1、请简述泛型是什么?有什么用?在哪里用？1.泛型是确定数据类型的一种方法2.泛型把运行时期的问题提前到编译时期避免强制转换把类型推迟到创建对象或者调用方法时才明确3.泛型可以在类接口方法上使用 2、请把今天讲解的方法，在API中查找到，并用自己的话进行描述Vector public void addElement(E obj) 在集合末尾处添加一
复制链接

扫一扫

专栏目录