高考报名时间2022年11月1日还剩 天 距离2023年6月7日高考还有 天
栏目分类:
子分类:
返回
名师互学网用户登录
名师互学网
快速导航关闭
当前搜索
当前分类
前沿技术 软件开发 系统运维 产品运营 生活办公 面试经验 考试题库
子分类
人工智能 大数据 云计算 区块链 物联网 深度学习 机器学习 NLP 计算机视觉 语音识别 其他 大数据系统 数据可视化 数据挖掘与分析 其他 Docker/k8s 虚拟化 云平台 其他 基本原理 数字货币 智能合约 EOS应用 其他 通讯技术 嵌入式开发 单片机 物联网应用 HarmonyOS 其他 后端开发 Web开发 移动开发 游戏开发 Python Java 架构设计 C/C++/C# PHP .Net Go语言 R语言
实用工具
学习工具 小学数学练习 字帖生成 在线画板 函数绘制 拼音字母表 在线词典 黄历查询 亲戚关系计算 安全期计算 中国历史 Excel函数 模拟请求 json格式化 浏览器指纹
热门搜索
路由器设置 木托盘 宝塔面板 儿童python教程 心情低落 朋友圈 vim 双一流学科 专升本 我的学校 日记学校 西点培训学校 汽修学校 情书 化妆学校 塔沟武校 异形模板 西南大学排名 最精辟人生短句 6步教你追回被骗的钱 南昌大学排名 清朝十二帝 北京印刷学院排名 北方工业大学排名 北京航空航天大学排名 首都经济贸易大学排名 中国传媒大学排名 首都师范大学排名 中国地质大学(北京)排名 北京信息科技大学排名
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java基础 - 泛型 - 结业笔记

Java 更新时间： 发布时间： IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java基础 - 泛型 - 结业笔记

文章目录

泛型的语法

泛型的声明泛型使用的注意事项和细节泛型的实例化 泛型应用实例泛型课堂练习自定义泛型

基本语法注意细节自定义泛型接口

基本语法注意细节 自定义泛型方法

基本语法注意细节 泛型方法练习泛型继承和通配JUnit使用泛型课堂练习2

编程题 Homework01 泛型结论

泛型的语法 泛型的声明

interface 接口 {}和 class 类 {}

//比如：List，ArrayList

说明：

    其中：T，K，V不代表值，而是表示类型任意字母都可以。常用T表示，是Type的缩写
泛型使用的注意事项和细节 
interface List{}
public class HashSet{}
    T,E 只能是引用类型

看看下面语句是否正确？ 

List list = new ArrayList();	//ok
List list2 = new ArrayList();			//error，int是基本数据类型
    在指定泛型具体类型后，可以传入该类型或者其子类类型泛型使用形式
List  list1 = new ArrayList();
List  list2 = new ArrayList<>();
    如果我们这样写
List list3 = new ArrayList();

默认给它的 泛型是[E 就是 Object]

package com.tao.generic_;

import java.util.ArrayList;
import java.util.List;


public class GenericDetail {
    public static void main(String[] args) {
        Pig pig = new Pig(new A());   //A作为Pig的泛型
        pig.show();
        Pig pig2 = new Pig(new B());  //因为B继承A
        pig2.show();

        //3.泛型的使用形式
        ArrayList list1 = new ArrayList();
        List list2 = new ArrayList();

        //在实际开发中，我们往往简写
        ArrayList list3 = new ArrayList<>();
        List list4 = new ArrayList<>();
        ArrayList pigs = new ArrayList<>();

        //4.如果是这样写，泛型默认是 Object
        ArrayList arrayList = new ArrayList();
        //     ||||||||
        ArrayList arrayList1 = new ArrayList();
        

    }
}
class A{

}
class B extends A{

}
class Pig{
    E e;
    public Pig(E e){
        this.e = e;
    }

    public void show(){
        System.out.println(e.getClass());
    }
}
 
泛型的实例化 

要在类名后面指定类型参数的值（类型）。如：
 

    List strList = new ArrayList();Iterator iterator = customers.iterator();
 
泛型应用实例 

 

创建 3个学生对象
 

放入到HashSet中学生对象，使用.
 

放入到 HashMap中，要求 Key 是String name，Value 就是 学生对象
 

使用两种方式遍历
 

 

package com.tao.generic_;

import java.util.*;


@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入3个学生对象
        HashSet students = new HashSet();
        students.add(new Student("刘刘",20));
        students.add(new Student("涛涛",40));
        students.add(new Student("汤姆",50));

        System.out.println("---增强for遍历---");
        for (Student o:students){
            System.out.println(o);
        }

        //使用泛型方式
        HashMap map = new HashMap ();
        map.put("刘刘",new Student("刘刘",20));
        map.put("涛涛",new Student("涛涛",40));
        map.put("汤姆",new Student("汤姆",50));
        //迭代器 EntrySet
        Set> entries = map.entrySet();
        Iterator> iterator = entries.iterator();
        System.out.println("============================");
        while (iterator.hasNext()){
            Map.Entry next = iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}


class Student {
    String name;
    int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return name + "," + age;
    }
}


 
泛型课堂练习 

定义Employee类 

    该类包含：private成员变量name，sal，brithday，其中birthday 为 MyDate 类的对象；为每一个属性定义 getter，setter 方法；重写 toString 方法输出 name，sal，birthdayMyDate类包含：private成员变量month，day，year；并为每一个属性定义getter，setter 方法；创建该类的 3个对象，并把这些对象放入 ArrayList 集合中（ArrayList 需使用泛型来定义），对集合中的元素进行排序，并遍历输出；
 

排序方式：调用ArrayList 的sort 方法，传入 Comparator对象[使用泛型]，先按照name排序，如果那么相同，则按生日日期的先后排序。 

package com.tao.generic_;

import java.util.ArrayList;
import java.util.Comparator;


public class HomeWork01 {
    public static void main(String[] args) {
        ArrayList employees = new ArrayList();
        employees.add(new Employee("刘刘", 10, new MyDate(2000, 10, 10)));
        employees.add(new Employee("刘刘", 10, new MyDate(2001, 11, 11)));
        employees.add(new Employee("刘刘", 10, new MyDate(1999, 12, 12)));
        System.out.println(employees);
        System.out.println("==对员工进行排序==");
        employees.sort(new Comparator() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                //先按照 name 排序，如果name相同，则按生日日期的先后排序。[定制排序]
                //先对传入的参数进行验证
                if(!(emp1 instanceof Employee && emp2 instanceof Employee)){
                    System.out.println("类型不正确");
                    return 0;
                }
                //比较name
                int i = emp1.getName().compareTo(emp2.getName());
                if(i != 0){
                    return i;
                }

                //下面是对birthday的比较，因此，我们最好把这个比较，放在MyDate类完成
                //封装后，将来可维护性和复用性，就大大提高
                return emp1.getBirthday().compareTo(emp2.getBirthday());
            }
        });
        System.out.println(employees);

    }
}

class Employee {
    private String name;
    private int sal;
    private MyDate birthday;

    public Employee(String name, int sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + ''' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    public int compareTo(MyDate o){
        //如果name 相同，就比较 birthday 、 year
        int yearMinus = year - o.getYear();
        if (yearMinus != 0){
            return yearMinus;
        }
        //如果year 相同，就比较 month
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0){
            return monthMinus;
        }
        return 0;
    }
}


 
自定义泛型 
基本语法 

class 类名{	//...表示可以有多个泛型
	成员
}

 
注意细节 

    普通成员可以使用泛型（属性，方法）使用泛型的数组，不能初始化静态方法中不能使用类的泛型泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）如果在创建对象时，没有指定类型，默认为Object
 

package com.tao.generic_.customgeneric;



public class Customgeneric {
    public static void main(String[] args) {
        Tiger taotao = new Tiger("taotao");
        taotao.setR(4.0);   //Double
        taotao.setM(11.0);  //Object
        taotao.setT("f");   //String
        System.out.println(taotao);
    }
}
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2. T，R，M 泛型的标识符，一般是单个大写字母
//3. 泛型标识符可以有多个
//4. 普通成员可以使用泛型（属性、方法）
//5. 使用泛型的数组，不能初始化
//6. 静态方法不能使用泛型
class Tiger{
    String name;
    R r;
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开辟空间
//    T[] ts = new T[8];  //error
    public Tiger(String name){
        this.name = name;
    }
    public Tiger( R r, M m, T t) {
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;                     //error
//    public static void m1(M m){}    //error

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {   //方法使用泛型
        return r;       //返回值为泛型
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + ''' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                '}';
    }
}


 
自定义泛型接口 
基本语法 

interface 接口名 {

}

 
注意细节 

    接口中，静态成员也不能使用泛型（这个和泛型类规定一样）泛型接口的类型，在继承接口或者实现接口时确定没有指定类型，默认为Object
 

interface A{

}
interface B extends A{   //确定父类接口中的泛型类型，如果没有指定，默认Object
 
}


 

package com.tao.generic_.customgeneric;


public class CustomInterfaceGeneric {
    public static void main(String[] args)  {

    }
}


//在继承接口 指定泛型接口的类型
interface IA extends IUsb{

}
//当我们去实现IA接口时，因为IA在继承IUsu接口时，指定了U 为String R为Double,
//在实现IUsu接口的方法时，使用String替换U，是Double替换R
class AA implements IA{
    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }

    @Override
    public Double method(String s) {
        return IA.super.method(s);
    }
}

//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U，使用Float替换R
class BB implements IUsb{
    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}
interface IUsb{

    int n = 10;
    //U name = "taotao";   //error，不能这样使用
    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    //在jdk8中，可以在接口中，使用默认方法
    default R method(U u){
        return null;
    }
}
//没有指定类型，默认为Object
class CC implements IUsb{       //
    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

 
自定义泛型方法 
基本语法 

修饰符 返回类型 方法名(参数列表){

}

 
注意细节 

     
    当泛型方法被调用时，类型会确定
      
    public void eat(E e){}
//修饰符后没有eat方法不是泛型方法，而是使用了泛型

     
 
泛型方法练习 

package com.tao.generic_.customgeneric;


public class CustomGenericMethodExercise {
    public static void main(String[] args) {
        Appleapple = new Apple<>();
        apple.fly(10);      //Integer
        apple.fly(new Dog());   //Dog
    }
}
class Apple{
    public void fly(E e){
        //getClass()运行类型或者包名，getSimpleName()类的简写名称
        System.out.println(e.getClass().getSimpleName());
    }
    public void eat(R r){}
    public void run(M m){}
}
class Dog{


}

 
泛型继承和通配 

    泛型不具备继承性
 

 
 
List list = new ArrayList(); //error
 

 

     ：支持任意泛型类型  ：支持A类以及A类的子类，规定了泛型的上限 <？super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
 

package com.tao.generic_.customgeneric;

import java.util.ArrayList;
import java.util.List;


public class GenericExercise {
    public static void main(String[] args) {
        //泛型没有继承性
        //ArrayList a = new ArrayList();

        //举例说明下面三个方法的使用
        List list1 = new ArrayList<>();
        List list2 = new ArrayList<>();
        List list3 = new ArrayList<>();
        List list4 = new ArrayList<>();
        List list5 = new ArrayList<>();

        //如果是 Listc,可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List c       表示 上限，可以接收 A或者 A子类
//        printCollection2(list1);      //Object error
//        printCollection2(list2);      //String error
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        printCollection3(list1);        //A的父类
//        printCollection3(list2);      //String error
        printCollection3(list3);        //A类
//        printCollection3(list4);      //B类 error
//        printCollection3(list5);      //C类 error

    }

    //编写几个方法
    //说明：List  表示 任意的泛型类型都可以接收
    public static void printCollection1(List c) {
        for (Object o : c) { //通配符，取出时，就是Object
            System.out.println(o);

        }
    }

    //？ extends A 表示 上限，可以接收 A或者 A子类
    public static void  printCollection2(List c){
        for (Object o : c){
            System.out.println(o);
        }
    }

    // ? super 子类类名AA：支持AA类以及AA类的父类，不限于直接父类
    //规定了泛型的下限
    public static void printCollection3(List c){
        for (Object o : c){
            System.out.println(o);
        }
    }
}

class A {

}

class B extends A {

}

class C extends B {

}

 
JUnit使用 

为什么需要JUnit 

    一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中如果有多个功能代码测试，就需要来回注销，切换很麻烦如果可以直接运行一个方法，就方便很多，并且可以给出相关信息，就好了 -> JUnit
 

 

Alt + Enter导入包 

 
泛型课堂练习2 
编程题 Homework01 

 package com.tao.generic_.homeword;

import org.testng.annotations.Test;

import java.util.*;


public class Homework01 {
    public static void main(String[] args) {

    }

    @Test
    public void testList(){
        //说明
        //这里我们给T 指定类型是User
        DAO dao = new DAO<>();
        dao.save("001",new User(1,10,"jack"));
        dao.save("002",new User(2,18,"king"));
        dao.save("003",new User(3,38,"smith"));

        List list = dao.list();

        System.out.println("list = " + list);

        dao.update("003",new User(3,58,"milan"));
        //更新数据后
        System.out.println(dao.list());

        System.out.println("id=03" + dao.get("003"));   //milan
    }
}
class DAO{
    private Map map = new HashMap();
    //保存T类型的对象到 Map 成员变量中
    public void save(String id,T entity){
        map.put(id, entity);
    }
    //从 map中获取 id 对应的对象
    public T get(String id){
        return map.get(id);
    }
    //替换 map 中key为 id的内容，改为 entity对象
    public void update(String id,T entity){
        map.put(id, entity);
    }
    //返回map 中存放的所有T 对象
    //遍历map[k - v] ， 将map的所有value（T entity），封装到ArrayList返回即可
    public List list(){
        //创建 ArrayList
        List list = new ArrayList<>();

        //遍历map
        Set keySet = map.keySet();
        for (String o : keySet){
            //map.get(o) 返回就是User 对象 -> ArrayList
            list.add(map.get(o));   //list.add(get(o));
        }
        return list;
    }
    //删除指定id对象
    public void delete(String id){
        map.remove(id);
    }

}
class User{
    private int id,age;
    private String name;

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + ''' +
                '}';
    }
}


 
泛型结论 

一句话搞定泛型
 

泛型就是一种可以接收数据类型的数据类型！！




















Java相关栏目本月热门文章












热门相关搜索






路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名















学习工具


代数计算器


三角函数


解析几何


立体几何






知识解答


教育知识


百科知识


生活知识


常识知识






写作必备


作文大全


作文素材


句子大全



实用范文






关于我们


关于我们


联系我们


网站地图






 交流群

名师互学网交流群




名师互学网客服

名师互学网客服












名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 








我们一直用心在做

关于我们
文章归档
网站地图
联系我们

版权所有 (c)2021-2022 MSHXW.COM


ICP备案号：晋ICP备2021003244-6号