Java泛型_java_内存溢出

Java泛型泛型引入

问题:请编写程序，在ArrayList中，添加3个Dog对象，要求使用get( )方法来获取name和age

1.使用传统方法

package com.泛型;

import java.util.ArrayList;
@SuppressWarnings("all")
public class Generic01 {
    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) {
            //向下转型 Object->Dog
            Dog dog = (Dog)o;
            System.out.println(dog.getName()+"-"+dog.getAge());
        }
        arrayList.add(new Cat());
    }
}
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 int getAge() {
        return age;
    }
}
class Cat{
}

按照传统方法写有两个问题：

（1）Cat类的对象，也可以加入到ArrayList中，不能对加入集合的元素进行约束，不安全

（2）在循环或者迭代器中，每次都需要向下转型，在数量较大的集合遍历中，效率变低

2.使用泛型

ArrayList arrayList = new ArrayList();
//->替换为
ArrayList<Dog> arrayList = new ArrayList<Dog>();

（1）在加入Cat对象时，已经报红了，编译时，检查添加元素类型，提高安全性

（2）在增强for循环中，不需要类型转换，提高效率

泛型介绍

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

package com.泛型;

public class Generic02 {
    public static void main(String[] args) {
        Person<String> stringPerson = new Person<String>("ZMC666");
        /*相当于：
        class Person {
            String s;

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

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

泛型语法泛型的声明

interface接口{}和class类{}

说明：

其中，T,K,V都不代表值，而是表示类型
任意字母都可以，通常用T表示，是Type的缩写

泛型的实例化

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

ArrayList<String> arrayList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();

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

1.T,E等等只能是引用类型

ArrayList<Integer> integers = new ArrayList<Integer>();//OK
ArrayList<int> integers = new ArrayList<int>();//错误

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

package com.泛型;

public class GenericDetail {
    public static void main(String[] args) {
        Pig<A> aPig = new Pig<A>(new A());
        aPig.show();//class com.泛型.A
        Pig<A> aPig1 = new Pig<>(new B());
        aPig1.show();//class com.泛型.B
    }
}
class A{
}

class B extends A{
}

class Pig<E>{
    E s;

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

    public void show(){
        System.out.println(s.getClass());
    }
}

3.泛型使用形式

ArrayList<Integer> integers = new ArrayList<>();//idea中，new ArrayList().var 自动生成

这样写，编译器会进行类型推断后面<>里的内容可以不用写，但是前面的一定要写

推荐这种写法！在实际开发中，往往这样简写。

4.如果按照传统的写法，泛型默认的是Object

ArrayList arrayList = new ArrayList();//泛型默认的是Object
//等价于
ArrayList<Object> arrayList = new ArrayList<>();//所以传入任意的对象都可以，因为都是Object的子类

泛型练习题

package com.泛型;

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

public class GenericExercise {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom",2000,new MyData(2000,11,11)));
        employees.add(new Employee("jack",12000,new MyData(2001,11,12)));
        employees.add(new Employee("john",5000,new MyData(1999,10,11)));

        //对雇员进行排序
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                int i = o1.getName().compareTo(o2.getName());
                if(i!=0){
                    return i;
                }
                //下面是对birthday的比较
                return o1.getBirthday().compareTo(o2.getBirthday());
            }

        });
        System.out.println(employees);
    }
}
class Employee{
    private String name;
    private double sal;
    private MyData birthday;

    public Employee(String name, double sal, MyData birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

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

    public double getSal() {
        return sal;
    }

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

    public MyData getBirthday() {
        return birthday;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}
class MyData implements Comparable<MyData>{
    private int year;
    private int month;
    private int day;

    public MyData(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 "MyData{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

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

自定义泛型基本语法

class 类名（表示可以有多个泛型成员）

注意：

1.使用泛型的数组，不能初始化

2.静态方法中不能使用类的泛型

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

    }
}
class Tiger<T,R,E>{
    String name;
    T t;
    R r;
    E e;

    public Tiger(String name, T t, R r, E e) {
        this.name = name;
        this.t = t;
        this.r = r;
        this.e = e;
    }
    //下面几种是错误示范
    E[] e2 = new E[8];//因为不确定E的类型，无法开辟空间
    static R r2;//类在加载时，对象还没有创建，泛型在创建对象时才被指定，JVM无法完成初始化
    public static void t1(T t){}
}

自定义泛型接口基本语法

interface 接口名

注意细节

1.接口中，静态成员也不能使用泛型（与泛型类规定一致）

2.泛型接口的类型，在继承接口或者实现接口的时候确定

3.没有指定类型，则默认为Object

//在继承接口时，确定泛型接口的类型
interface IA extends IUsb<String,Double>{
}
//在使用IUsb接口的方法时，使用String替换U，使用Double替换R
class IAA 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) {

    }
}
interface IUsb<U,R>{
    //普通方法中，可以使用接口泛型
    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;
    }
}

//在实现接口时，确定泛型接口的类型
class BB implements IUsb<Integer,Float>{

    @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<U,R>{
    //普通方法中，可以使用接口泛型
    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;
    }
}

自定义泛型方法基本语法

修饰符返回类型方法名（参数列表）{}

注意细节

1.泛型方法，可以定义在普通类中，也可以定义在泛型类中

2.当泛型方法被调用时，类型会确定

3.public void eat(E e){}, 修饰符后没有 eat方法不是泛型方法，而是使用了泛型

//泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car{
    public void run(){}
    public <T,R> void fly(T t,R r){}//泛型方法
}
    
class Fish<T,R>{
    public void run(){}
    //泛型方法可以使用类声明的泛型，也可以使用自己声明的泛型
    public <U,M> void eat(U u,M m){}//泛型方法
}

class orange<T>{
    //1.hi方法不是泛型方法
    //2.hi方法使用了类声明的 泛型
    public void hi(T t){}
}

泛型的继承和通配符泛型的继承和通配符说明

1.泛型不具备继承性

ArrayList<Object> list = new ArrayList<String>();//错误

2. : 支持任意泛型类型

3. : 支持A类以及A类的子类，规定了泛型的上限

4. ：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

package com.泛型;

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

public class GenericExtends {
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<AB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是List
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //如果是List
        //printCollection2(list1);错
        //printCollection2(list2);错
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        //如果是List
        printCollection3(list1);
        //printCollection3(list2);错
        printCollection3(list3);
        //printCollection3(list4);错
        //printCollection3(list5);错

    }
    //c 表示任意的泛型类型都可以接受
    public static void printCollection1(List<?> c){
        for (Object object : c ) {
            System.out.println(object);
        }
    }
    // 表示支持A类以及A类的子类，规定了泛型的上限
    public static void printCollection2(List<? extends AA> c){
        for (Object object : c ) {
            System.out.println(object);
        }
    }
    // c) 表示支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
    public static void printCollection3(List<? super AA> c){
        for (Object object : c ) {
            System.out.println(object);
        }
    }
}

class AA{}
class AB extends AA{}
class CC extends AB{}

泛型综合练习 JUnit

1.JUnit是一个java语言的单元测试框架

2.多数Java的开发环境都已经集成了JUnit作为单元测试工具

3.在相应方法上加上@Test 并Alt+Insert，选择Add’JUnit5.8’ to classpath即可，这样做可以直接运行一个方法

package com.泛型;

import org.junit.jupiter.api.Test;

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

    }
    @Test
    public void m1(){
        System.out.println("调用m1方法");
    }
    @Test
    public void m2(){
        System.out.println("调用m2方法");
    }
}

综合练习

package com.泛型;

import org.junit.jupiter.api.Test;
import java.util.*;

public class GenericHomework {
    public static void main(String[] args) {
        
    }
    @Test
    public void testlist(){
        DAO<User> dao = new DAO<>();
        dao.save("001",new User(1,10,"LUCY"));
        dao.save("002",new User(2,20,"TOM"));
        dao.save("003",new User(3,30,"JERRY"));

        List<User> list = dao.list();
        System.out.println("list="+list);

        dao.update("002",new User(2,40,"MILAN"));
        dao.delete("001");
        list= dao.list();
        System.out.println("list修改后="+list);

        System.out.println("id=003"+dao.get("003"));
    }
}
class DAO<T>{
    private Map<String,T> map = new HashMap<>();
    
    public T get(String id){
        return map.get(id);
    }
    
    public void update(String id,T entity){
        map.put(id,entity);
    }
    
    public List<T> list(){
        List<T> list = new ArrayList<>();
        //遍历map
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            list.add(map.get(key));
        }
        return list;
    }

    public void delete(String id){
        map.remove(id);
    }

    public void save(String id,T entity){//把entity保存到map
        map.put(id,entity);
    }
}
class User{
    private int id;
    private int 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 + '\'' +
                '}';
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/795271.html

Java泛型

发表评论

评论列表（0条）