集合3（泛型）

于 2020-09-03 20:59:32 发布
阅读量161 收藏 1
点赞数
分类专栏： 基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49689284/article/details/108391776
版权

泛型概念：

  • 广泛的类型，在定义一个类的时候，类型中有些方法参数，返回值类型不确定，就使用一个符号，来表示那边尚未确定的类型，这个符号就称之为泛型。
import java.util.ArrayList;

public class Text9 {
    public static void main(String[] args) {
        //需求：求集合中每个元素的长度
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        list.add(2.3);
        System.out.println(list);//[abc, 1, 2.3]
        for (int i = 0; i <list.size() ; i++) {
            Object obj = list.get(i);
            String str = (String)obj;//向下转换
            System.out.println(str.length());
            //只能获取“abc”的长度3，int类型的报错，java.lang.ClassCastException 类型转换异常
        }
    }
}

问题1：

  • 存入集合中元素都会向上类型转换成Object类型，当获取该元素并需要使用该元素特有方法时，就必须向下类型转换。

问题2：

  • 频繁向上/向下的类型转换，代码繁琐，容易出现类型转换异常。

解决：

  • 让集合提供类型检查功能，使用泛型实现。
import java.util.ArrayList;
import java.util.List;

public class Text9 {
    public static void main(String[] args) {
        //泛型集合：使用泛型技术的集合
        List<String> list = new ArrayList();
        list.add("abc");
        list.add("zzzz");
        //list.add(1);类型检测，报错，参数不符合泛型<String>

        for (int i = 0; i <list.size() ; i++) {
            String s = list.get(i);
            System.out.println(s.length());// 3  4
        }

		System.out.println("==================");
        //类似数组
        String[] ss = new String[3];//已经确定了数组类型为String
        ss[0] = "abcd";
        ss[1] = "abcdfg";
        //ss[1] = 1; 报错，不兼容的类型: int无法转换为java.lang.String
  }
}

泛型集合：

语法：

集合类型<类型>  集合对象名 = new 集合类<>();

集合类：集合框架中的类及其接口，都支持泛型。

<类型>：泛型，类型必须引用类型，如果集合中存在是基本类型的值，泛型必须定义成对应包转类，不能使用基本数据类型。

另外两种泛型集合定义语法：
集合类<类型> 集合对象名 = new 集合类<>();  //称之为泛型菱形技术
集合类<类型> 集合对象名 = new 集合类();     //称之为泛型擦出技术（常用）

泛型类：

概念：

  • 定义类时使用泛型技术，该类就是泛型类。

语法;

访问修饰符	class	类名<T......>{
成员属性/方法
}

<T......>：T定义时无法确定类的类型，将类型确定交给调用方。
泛型可以是一个或多个，多个以“，”隔开。

成员属性：属性的类型可以使用 T 来表示。
成员方法：方法的返回值类型，参数类型都可以使用T来表示。

class Source<T>{
    //成员属性
    private T date;

    //成员方法
    public T getDate() {
        return date;
    }

    public void setDate(T date) {
        this.date = date;
    }

    private Integer count;//普通成员属性

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }
}

public class Text10 {
    public static void main(String[] args) {
        Source<String> s = new Source();
        s.setDate("泛型成员属性");
        String ss = s.getDate();
        System.out.println(ss);//泛型成员属性

        Source s2 = new Source();
        s2.setCount(10);//普通成员属性
        int n = s2.getCount();
        System.out.println(n);//10
    }
}

特点：

  1. 由于泛型将类型确定由于定义方转交给调用方，从而让泛型类达到通用效果。
  2. 如果泛型类，实例化时没有确定具体类型，这时该泛型类的泛型就是Object类型。
  3. 泛型类中可以有泛型类型属性，可以有普通类型属性。可以有返回值类型是泛型的方法，可以有返回值类型是普通类型的方法。可以有参数类型是泛型的方法，也可以有参数类型是普通类型的方法。

泛型方法

概念：

  • 使用与泛型类不一样的泛型作为参数类型的方法。

语法：

访问修饰符  <Q> 返回值类型  方法名（Q q，....）{
方法体
}

<Q>：泛型方法的泛型类型，该类型字母要与泛型类字母不同。
该泛型确定通过调用该方法时，提供实际参数来确认。
该实际参数的类型就是泛型的类型。泛型可以是一个或多个，多个以”,”隔开。

 class Fx<T>{
    T data;

    //非静态的泛型方法
    public<Q> Q method(Q q){
        T a; //非静态的泛型方法中可以使用泛型类的泛型
        return q;
    }

    //静态的泛型方法
    public static<Q> Q function(Q q){
        //T a; 报错，静态的泛型方法中不能调用泛型类的泛型
        //原因：静态方法随着类加载就生成，泛型类的泛型是调用方调用时确定，静态方法早于泛型生成。
        return q;
    }
}

public class Text11 {
    public static void main(String[] args) {
        Fx<String> fx = new Fx();
        fx.data = "abc";

        Integer n = fx.method(1);
    }
}

特点：

  1. 泛型方法的泛型确认，在调用方法时，提供的实际参数来确认，该泛型类型就是实际参数的类型。
  2. 非静态泛型方法可以使用泛型类的类型，静态泛型方法不可以使用泛型类的类型。

泛型接口：

概念：

  • 定义接口使用泛型技术，该接口就是泛型接口

语法：

访问修饰符 interface 接口名<T>{
    成员
}

<T>：T定义时无法确定的类型，用于传递泛型。泛型可以是一个或多个，多个以”,”隔开。

interface inter<T>{
    //普通接口 = 静态常量 + 抽象方法
    //public static T a = 100;报错，静态常量无法使用泛型类的泛型
    public T method();

    public void function(T t);
}

//多继承，多实现
interface inter2<T> extends inter<T>{
    //泛型接口通过继承传递泛型给子接口
}

class Imp<T> implements inter<T>{//泛型接口通过实现传递泛型给实现类

    @Override
    public T method() {
        return null;
    }

    @Override
    public void function(T t) {

    }
}
public class Text12 {
    public static void main(String[] args) {
        Imp<String> imp = new Imp<>();
    }
}

特点

  1. 泛型接口的静态常量成员不能使用泛型类的泛型作为该成员的类型使用
  2. 泛型接口的抽象方法能使用泛型类的泛型作为返回值类型或参数类型使用。
  3. 泛型接口通过实现 传递 泛型给实现类
  4. 泛型接口通过继承 传递 泛型给子接口

泛型通配符

概念：

  • 用于接收多个泛型类型的符号

符号：<?>

代码示例

import java.util.ArrayList;

class Person{
    private String name;
    private int 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;
    }

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

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

class Student extends Person {

    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + super.getName() + '\'' +
                ", age=" + super.getAge() +
                '}';
    }
}
class Teacher extends Person{
    private String id;

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

    public String getId() {
        return id;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + super.getName() + '\'' +
                ", age=" + super.getAge() +  '\'' +
                ", id='" + id + '\'' +
                '}';
    }
}
public class Text1 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList();
        for (int i = 0; i <2 ; i++) {
            list.add(new Student("小明"+i,18+i));
        }


        ArrayList<Teacher> tlist = new ArrayList();
        for (int i = 0; i <2 ; i++) {
            tlist.add(new Teacher("老师"+i,28+i,"001"+i));
        }

        foreach(list);
        foreach(tlist);

    }
    public static void foreach(ArrayList<?> list){//若泛型设置Student，Teacher类就不能使用
        System.out.println(list);
    }
}

泛型上下限

概念：

  • 用于限制具有继承关系的的泛型类型的接收。

泛型上限：<? extends 类名>

泛型下限：<? super 类名>

代码示例

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

class Person{
    private String name;
    private int 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;
    }

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

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

class Student extends Person{
    public Student(String name, int age) {
        super(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + super.getName() + '\'' +
                ", age=" + super.getAge() +
                '}';
    }
}

class Teacher extends Person{

    private String id;

    public String getId() {
        return id;
    }

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

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

    @Override
    public String toString() {
        return "Teacher{" +
                "id='" + id + '\'' +
                "name='" + super.getName() + '\'' +
                ", age=" + super.getAge() +
                '}';
    }
}

public class Test10 {

    public static void foreach(List<? super Student> list) {
        System.out.println(list);
    }


    public static void main(String[] args) {
        List<Student> list = new ArrayList();//3个学生集合
        //添加十名学生
        for (int i = 1 ; i <= 3 ; i++) {
            list.add(new Student("小王"+i,19+i));
        }

        List<Teacher> tlist = new ArrayList();//3个老师集合
        for (int i = 1 ; i <= 3 ; i++) {
            tlist.add(new Teacher("老王"+i,39+i,"00"+i));
        }

        List<Person> plist =  new ArrayList();//3个人集合
        for (int i = 1 ; i <= 3 ; i++) {
            plist.add(new Person("隔壁邻居"+i,29+i));
        }

        foreach(list);
        //foreach(tlist);//报错
        foreach(plist);
    }
}
「 清茶苦酒 」
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
泛型集合泛型集合泛型集合
06-26
泛型集合解释的非常好泛型集合泛型集合泛型集合解释的非常好泛型集合泛型集合泛型集合解释的非常好泛型集合泛型集合泛型集合解释的非常好泛型集合泛型集合
泛型集合
技术专栏
04-23 240
日志<br />已经是第一篇<br />下一篇：证明你喜欢他(她)...<br />|返回日志列表泛型集合 分享复制地址<br />日志地址:<br />请用Ctrl+C复制后贴给好友。转发到微博<br />刘德2011年03月27日 23:52阅读(0)评论(0) 分类：个人日记权限: 公开字体：中▼小中大更多▼设置置顶权限设置推荐日志转为私密日志删除编辑<br /><br />    //用来统计单词的个数<br />     //泛型类型包括(类,接口,委托和结构---没有泛型枚举)和泛型方法<br
Java——泛型集合
weixin_30568591的博客
08-17 41
　　Java 集合有一个缺点——把一个对象 “丢进” 集合里之后，集合就会 “忘记” 这个对象的数据类型,当再次取出该对象时,该对象的编译类型就变成了 Object 类型(其运行时类型没变)。集合对元素类型没有任何限制，这样可能引发一些问题。例如，想创建一个只想保存Dog 对象的集合，但程序也可以轻易的将字符串类型数据“丢” 进集合当中。 Dog ououDog=new Dog("...
C# 泛型集合
09-19 218
原文出处我的wiki，转载请说明出处 考虑到泛型在集合类型中的广泛应用，这里一起讨论。 1. 泛型 1.1 泛型的定义与约束 创建泛型方法、委托、接口或类时，需要在名称后增加尖括号及其中的泛型参数，泛型参数通常用T或T为前缀的描述性单词表示。 /// <summary> /// 集合类型扩展方法 /// </summar...
集合与泛型
01-12
### 集合与泛型知识点总结 #### 泛型概览 - **引入原因**：在Java 1.5及之后的版本中，引入了泛型这一特性，旨在提高集合类使用的安全性与灵活性。主要解决的问题包括： - **元素存储的安全性问题**：在非泛型...
集合+泛型.docx
05-14
集合和泛型在 Java 中的应用 集合（Collection）是 Java 中的一种数据结构，用于存储和操作数据的集合。泛型（Generic）是 Java 5 中引入的一种特性，用于限制集合中元素的类型。 集合 集合是 Java 中的一种数据...
java集合和泛型
05-01
所谓泛型，就是参数化类型。集合框架就是一个用来表示和操作集合统一的架构，包含了集合的接口与实现类。本文件通过举例来讲解泛型和集合的基础操作。
Day17 Java 集合和泛型.pdf
08-09
将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值
集合与泛型 ppt
08-14
Java中的集合类与泛型机制（Java SE 1.5中加入了泛型机制）
Java入门系列-19-泛型集合
weixin_30770783的博客
10-23 137
集合 如何存储每天的新闻信息？每天的新闻总数是不固定的，太少浪费空间，太多空间不足。 如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象，可以使用Java集合框架。 Java 集合框架提供了一套性能优良、使用方便的接口和类，位于 java.util 包中。 接口 Collection 存储一组不唯一，无序的对象，它有两个子接口 List和Set。List 接口存储一组不唯一，有序(插...
Java集合与泛型解析：理解集合问题和泛型应用
"Java集合存在的问题-集合与泛型 ppt" 在Java编程中，集合框架扮演着至关重要的角色，它提供了一种高效且灵活的方式来存储和管理数据。然而，早期的Java集合（例如在Java SE 1.4及更早版本）存在一些问题，主要体现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值