首页 > 编程语言 >day28--Java泛型01

day28--Java泛型01

时间：2022-08-29 20:47:10浏览次数：60  
标签：01 name -- age int 泛型 new public String

Java泛型01

1.泛型的理解和好处

看一个需求：

  1. 请编写程序，在ArrayList中添加三个Dog对象
  2. Dog对象含有name和age，并输出name和age（要求使用getXXX（））

先用传统的方法来解决--->引出泛型

传统的方法：

package li.generic;

import java.util.ArrayList;

@SuppressWarnings("all")
public class Introduce_ {
    public static void main(String[] args) {
        
        //用传统的方法来解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺财",10));
        arrayList.add(new Dog("发财",1));
        arrayList.add(new Dog("小黄",5));
        
        for (Object o:arrayList) {
            //向下转型
            Dog dog = (Dog) o;
            System.out.println(dog.getName()+"-"+dog.getAge());
        }

    }
}

class Dog {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

//假设，我们的程序员不小心添加了一只猫
arrayList.add(new Cat("招财猫",8));

那么 在使用增强for循环输出的时候向下转型时就会抛出异常：类型转换错误

image-20220829152816907

使用传统方法问题的分析：

  1. 不能对加入到集合ArrayList中的数据进行约束（不安全）
  2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

使用泛型来解决问题：

package li.generic;

import java.util.ArrayList;

@SuppressWarnings("all")
public class Introduce_ {
    public static void main(String[] args) {

        //使用泛型
        // 1. 当我们这样写的时候：ArrayList<Dog>  表示集合ArrayList中的元素是Dog类型
        // 2. 如果编译器发现添加的类型不满足要求，就会报错
        // 3.在遍历的时候，可以直接取出Dog类型而不是Object
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财",10));
        arrayList.add(new Dog("发财",1));
        arrayList.add(new Dog("小黄",5));

        //假设，我们的程序员不小心添加了一只猫，就会报错
        // arrayList.add(new Cat("招财猫",8));

        System.out.println("====使用泛型====");
        for (Dog dog:arrayList) {
            System.out.println(dog.getName()+"-"+dog.getAge());
        }

    }
}

class Dog {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

class Cat {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

package li.generic;

import java.util.ArrayList;

@SuppressWarnings("all")
public class Introduce_ {
    public static void main(String[] args) {

        //使用泛型
        // 1. 当我们这样写的时候：ArrayList<Dog>  表示集合ArrayList中的元素是Dog类型
        // 2. 如果编译器发现添加的类型不满足要求，就会报错
        // 3.在遍历的时候，可以直接取出Dog类型，而不是Object
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财",10));
        arrayList.add(new Dog("发财",1));
        arrayList.add(new Dog("小黄",5));

        //假设，我们的程序员不小心添加了一只猫，就会报错
        // arrayList.add(new Cat("招财猫",8));

        System.out.println("====使用泛型====");
        for (Dog dog:arrayList) {
            System.out.println(dog.getName()+"-"+dog.getAge());
        }

    }
}

class Dog {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

class Cat {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

泛型的好处：

  1. 编译时，检查添加元素的类型，提高了安全型

  2. 减少了类型转换的次数，提高效率

    如上面例子所示：不使用泛型的时候，Dog对象放到ArrayList里会先转成Object类型，在取出的时候还要再转换成Dog类型（Dog--加入-->Object--取出-->Dog）

    使用了泛型，则放入和取出时都不需要类型转换，提高效率（Dog-->-Dog-->Dog）

  3. 不再提示编译警告

    不添加@SuppressWarnings("all")编译器也不再警告

2.泛型介绍

泛型是一种可以表示数据类型的 数据类型

如下图：public class ArrayList<E>{} E 称为泛型

image-20220829161048526

泛（广泛）型（类型）===>integer，String，Dog，……

  1. 泛型又称参数化类型，是jdk5.0出现的新特性，解决数据类型的安全性问题
  2. 在类声明或者实例化时只要指定好需要的具体类型即可
  3. Java泛型可以保证如果程序在编译时没有发出警告，运行就不会产生ClassCastException异常。同时，代码更加简洁、健壮
  4. 泛型的作用是：可以在类声明时 通过一个标识 表示类中的某个属性，或者是某个方法的返回值的类型，或者是参数类型

例子：

package li.generic;

public class Generic03 {
    public static void main(String[] args) {
        Person<String> person = new Person<String>("jack");
        person.showCalss();//class java.lang.String
        /*
       可以这样理解：上面的Person类变为了
       class Person{
            String s;

             public Person(String s) {
                this.s = s;
            }

            public String f() {
             return s;
            }
        }

        */
        Person<Integer> person1 = new Person<Integer>(100);
        person1.showCalss();//class java.lang.Integer
        /*  可以这样理解：上面的Person类变为了
       class Person{
            Integer s;

             public Person(Integer s) {
                this.s = s;
            }

            public Integer f() {
             return s;
            }
        }
        */

    }
}

class Person<E> {
    E s; // 用 E表示 s的数据类型，该数据类型在定义 Person对象的时候指定，即在编译期间，就确定 E是什么类型

    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用E
        return s;
    }

    public void showCalss(){
        System.out.println(s.getClass());//显示s的运行类型
    }
}

注意：E的数据类型在定义 Person 对象的时候指定，即在编译期间，就确定E是什么类型

泛型是一种可以表示数据类型的 数据类型

3.泛型的语法

3.1泛型的声明

interface 接口<T>{} 和class 类<K,V>{}//比如：List、ArrayList

说明：

1)其中，T,K,V不代表值，而是表示类型

2)任意字母都可以。常用T表示，是Type的缩写

3.2泛型的实例化

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

(1)List<String> strList = new ArrayList<String>() ;

(2)Iterator<Customer> iterator = customer.iterator();

3.3泛型使用举例

例子：泛型使用举例：

练习：

  1. 创建三个学生对象
  2. 学生对象放入到HashSet中使用
  3. 放入到HashMap中，要求Key是String name ，Value就是学生对象
  4. 使用两种方法遍历

练习：

package li.generic;

import java.util.*;

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

        //使用泛型的方法给HashSet放入三个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("marry", 17));
        students.add(new Student("link", 123));

        //使用HashSet的增强for
        System.out.println("===使用HashSet的增强for===");
        for (Student student : students) {
            System.out.println(student);
        }


        //使用泛型的方法给HashMap放入三个学生对象
        HashMap<String, Student> hm = new HashMap<String, Student>();
        hm.put("jack", new Student("jack", 18));
        hm.put("lucy", new Student("lucy", 28));
        hm.put("olin", new Student("olin", 16));


        //迭代器 EntrySet
        System.out.println("===迭代器 EntrySet===");
        Set<Map.Entry<String,Student>> entries = hm.entrySet();
       Iterator<Map.Entry<String,Student>> iterator1 = entries.iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, Student> next =  iterator1.next();
            System.out.println(next.getKey()+"-"+next.getValue());

        }
    }
}

class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
image-20220829174053923

3.4泛型使用的注意事项和细节

  1. interface List<T>{} ,public class HashSet<E>{}..等等

    说明：T，E只能是引用类型

    看看下面语句是否正确？

    List<Integer> list = new ArrayList<Integer>();//正确

    List<int> list2 = new ArrayList<int>();//错误

  2. 在指定泛型具体类型后，可以传入该类型或者其子类类型

  3. 泛型使用形式

    3.1 在实际的开发中，我们往往简写，编译器会进行类型推断,推荐使用下面的写法
    ArrayList<Integer> list1 = new ArrayList<>();

    3.2 泛型默认是Object类型，即如果没有给泛型指定类型，默认就是Object：

    ArrayList arrayList = new ArrayList();//等价为 ArrayList<Object> arrayList = new ArrayList<>();

例子：

package li.generic;

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

public class GenericDetail {
    public static void main(String[] args) {
        //1.给泛型指向的数据类型要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>();//ok
        //List<int> list2 = new ArrayList<int>();错误

        //2.因为 E指定了A类型，构造器传入了 new A()
        Pig<A> aPig = new Pig<A>(new A());//将A类型赋给泛型E，说明Pig构造器可以接收的是A类型的对象

        //在指定泛型具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig2 = new Pig<A>(new B());

        aPig.showClass();//class li.generic.A
        aPig2.showClass();//class li.generic.B

        // 3.泛型的使用形式
        //在实际的开发中，我们往往简写，编译器会进行类型推断,推荐使用下面的写法
        ArrayList<Integer> list1 = new ArrayList<>();
        
    }
}
class A{}
class B extends A{}
class Pig<E>{
    E e;

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

    public void showClass(){
        System.out.println(e.getClass());//运行类型
    }
}

4.泛型课堂练习

定义Employee类

  1. 该类包括：private成员变量name，sal，birthday，其中birthday为MyDate类的对象；

  2. 为每一个属性定义getter、setter方法；

  3. 重写toString方法输出name，sal，birthday；

  4. MyDate类包括：private成员变量year，month，day。并为为每一个属性定义getter、setter方法；

  5. 创建该类的3个对象，并把这些对象放入ArrayList集合中（ArrayList需使用泛型来定义），对集合中的元素进行排序，并遍历输出：

    排序方式：调用ArrayList的sort方法，传入Comparator对象（使用泛型），先按照name排序，如果name相同，则按照生日日期的先后排序。（即定制排序）

练习：

package li.generic;

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

public class GenericHomework {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom", 20000, new MyDate(1980, 12, 11)));
        employees.add(new Employee("jack", 12000, new MyDate(2001, 12, 12)));
        employees.add(new Employee("tom", 50000, new MyDate(1980, 12, 10)));

        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                
//                //比较name
//                int i = o1.getName().compareTo(o2.getName());
//                if (i != 0) {
//                    return i;
//                }
//                //如果name相同，就比较birthday-year
//                int yearMinus = o1.getBirthday().getYear()-o2.getBirthday().getYear();
//                if (yearMinus !=0) {
//                    return yearMinus;
//                }
//                //如果year相同，就比较month
//                int monthMinus = o1.getBirthday().getMonth()-o2.getBirthday().getMonth();
//                if (monthMinus !=0) {
//                    return monthMinus;
//                }
//                //如果month相同，就比较mday
//                return o1.getBirthday().getDay()-o2.getBirthday().getDay();

                //比较name
                int i = o1.getName().compareTo(o2.getName());
                if (i != 0) {
                    return i;
                }
                
                //下面是对birthday的比较，因此，我们最好把日期的比较放到MyDate类完成
                //封装后的维护性和复用性更好
               return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });

        for (Employee e : employees) {
            System.out.println(e);
        }
    }
}

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 implements Comparable<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 + '\'' +
                '}';
    }

    @Override
    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;
        }
        //如果month相同，就比较mday
        return day-o.getDay();
    }
}

image-20220829201930124

标签：01,name,--,age,int,泛型,new,public,String
From： https://www.cnblogs.com/liyuelian/p/16637287.html

相关文章

  • 220829-漏洞分类再深入
    本篇文章针对漏洞分类问题进行深入的理解和分析。在《网络安全漏洞分类分级指南》（GB/T30279-2020）中，对漏洞分了4大类。第一类代码问题简单来说，就是程序员在写代码的时......
  • Day01__MarkDown学习
    MarkDown学习标题+空格即为标题（#数量表示级数）eg：三级标题四级标题字体Hello，World！Hello，World！（左右俩*为加粗）Hello，World！（左右一*为斜体）Hello，World！（左右仨*为加粗斜体）H......
  • .NET LINQ和es6的对比
    前言前后端采用不同的开发语言，作为后端开发为主的开发人员，了解两种语言的不同点更有助于快速了解和熟悉前端的开发；本编主要是做后端linq和前端es6的对比，了解linq在后端的......
  • Debain 11 安装并配置 wireguard
    1、安装aptinstallwireguard2、开启ipv4流量转发并使其生效echo"net.ipv4.ip_forward=1">>/etc/sysctl.confsysctl-p3、配置wireguard服务端3.1、生成服......
  • 链表节点删除
      代码：1importjava.util.*;23publicclassMain{4publicstaticvoidmain(String[]args){5Scannerscan=newScanner(System.in);......
  • 树的重心
    给定一颗树，树中包含n个结点（编号1∼n）和n−1条无向边。请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。重心定义：重心是指树中的一个结点，如果将这......
  • 【Git】快速入门
    参考廖大的git入门教程https://www.liaoxuefeng.com/wiki/896043488029600首先打开gitbash，告诉git你是谁，你的邮箱是什么gitconfig--globaluser.name"YourName"......
  • 学习随笔——codeforces题目Plus and Multiply解答
    摘要：构造算法与数论的结合，巧妙之处在于我们要自己模拟一遍计算过程然后从中找出特殊点。题目原地址如下：https://codeforces.com/problemset/problem/1542/B题目截图如下：......
  • 基于django原生代码提供api接口
    创建了表单student:fromdjango.dbimportmodelsclassStudent(models.Model):#学生信息name=models.CharField(max_length=255,verbose_name="姓名"......
  • Github发布包
    发布包是让用户接触项目不错的方式：1、页面顶端，点击你的用户名    2、在你的profile页面，点击Repositories窗口，接着点击你的库的名称3、点击右侧create re......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99