JAVA14——泛型

最新推荐文章于 2023-05-17 21:37:18 发布
最新推荐文章于 2023-05-17 21:37:18 发布
阅读量304 收藏
点赞数
分类专栏： JAVA基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiao39gs/article/details/107385489
版权

目录

引入

概述

泛型类

泛型接口：定义类时使用泛型

泛型方法

泛型子类

泛型擦除

泛型没有多态

通配符

泛型嵌套

泛型与数组

JDK7泛型改进

引入

一个学生的成绩有三种情况，应如何处理？

1、整数

2、小数

3、字符串

代码：

student.java

public class Student {
	private Object javase;
	private Object oracle;
	
	
	public Student(Object javase, Object oracle) {
		super();
		this.javase = javase;
		this.oracle = oracle;
	}
	public Object getJavase() {
		return javase;
	}
	public void setJavase(Object javase) {
		this.javase = javase;
	}
	public Object getOracle() {
		return oracle;
	}
	public void setOracle(Object oracle) {
		this.oracle = oracle;
	}
}

app.java

/**
 * 获取值：
 * 1.强制类型转换
 * 2.手动类型检查：避免转换错误：java.lang.ClassCastException
 * @author qiao39gs
 *
 */
public class App {

	public static void main(String[] args) {
		Object obj = 80;
		//int score = (int)obj;	//jdk1.7以后：Object—Integer—自动拆箱
		int score = (Integer) obj;	//jdk1.6及以前版本
		System.out.println(score);
		
		//存入整数：int—Integer—Object
		Student stu = new Student(80,90);
		
		int javaseScore = (Integer) stu.getJavase();
		String oracleScore = null;
		if(stu.getOracle() instanceof String){
			oracleScore = (String) stu.getOracle();
		}
		System.out.println("分数为："+javaseScore+","+oracleScore);
	}
	
}

不能将oracle的成绩转换为String类型

概述

  • 概念：泛型就是参数化类型，使用广泛的类型。
  • 起因：数据类型不明确：
    • 装入数据的类型都被当作Object对待，从而“丢失”自己的实际类型。 
    • 获取数据时往往需要转型，效率低，容易产生错误
  • 作用：
    • 安全：在编译的时候检查类型安全
    • 省心：所有的强制转换都是自动和隐式的，提高代码的重用率

泛型类

  • 格式：<>
    class类名<字母列表>{
    修饰符 字母 属性 ;
    修饰符 构造器(字母){

    }
    修饰符 返回类型 方法(字母){

    }
    不能使用在静态属性、静态方法上
  • 使用：指定具体类型
    1.编译时会进行类型检查；
    2.获取数据时不需要强制类型转换。
    泛型使用时不能指定基本类型。
  • 泛型常见字母
    T Type表示类型
    K V 分别代表键值中的Key Value
    E 代表 Element
    ？表示不确定的类型

eg:

/**
 * 泛型类：声明时使用泛型
 * 使用时确定类型
 * @author qiao39gs
 *
 * @param <T>
 */
public class Student<T1,T2> {
	private T1 javaScore;
	private T2 oracleScore;
	
	//private static T1 test;	//不能使用静态属性|静态方法上
	
	public T1 getJavaScore() {
		return javaScore;
	}

	public void setJavaScore(T1 javaScore) {
		this.javaScore = javaScore;
	}

	public T2 getOracleScore() {
		return oracleScore;
	}

	public void setOracleScore(T2 oracleScore) {
		this.oracleScore = oracleScore;
	}

	public static void main(String[] args) {
		//使用时指定类型
		Student<String,Integer> stu = new Student<String,Integer>();
		//1.安全：类型检查
		stu.setJavaScore("优秀");
		//2.省心：类型转换
                stu.setOracleScore(93);
		int it = stu.getOracleScore();	//自动拆箱
	}
	
}

泛型接口：定义类时使用泛型

  1. 格式：<>
    interface 接口名 <字母列表>{
            修饰符 返回类型 方法(字母);
    }
  2. 因为不能使用在静态属性上，更不能用在全局常量上

eg:

/**
 * 接口中泛型字母只能使用在方法中，不能使用在全局常量中
 * @author qiao39gs
 *
 * @param <T>
 */
public interface Comparator<T> {
	void compare(T t);
}

泛型方法

  • 定义使用：<字母>
    修饰符 <字母> 返回类型 方法名(字母){

    }
    要定义泛型方法，只需将于泛型参数列表置返回值前
  • 注意：泛型还可以定义在方法中，是否拥有泛型方法，与其所在的类是否泛型没有关系

eg:

/**
 * 泛型方法<> 返回类型签名
 * 只能访问对象的信息，不能修改信息
 * @author qiao39gs
 *
 */
public class TestMethod {
	
	public static void main(String[] args) {
		test("a");	//T—String
	}
	//泛型方法
	public static<T> void test(T a){
		System.out.println(a);
	}
}

泛型子类

  • 子类与父类|接口一样使用泛型
  • 子类指定具体的类型
  • 子类与父类|接口同时擦除类型
  • 子类泛型，父类接口 擦除
  • 错误:不能子类擦除，父类|接口泛型

擦除统一使用 Object对待

eg:

/**
 * 父类为泛型类
 * 1.属性
 * 2.方法
 * 
 * 要么同时擦除，要么子类大于等于父类的类型
 * 不能子类擦除，父类泛型
 * 1.属性类型
 * 父类中，随子类而定
 * 子类中，随子类而定
 * 2.方法重写：
 * 随父类而定
 * 
 * 
 * @author qiao39gs
 *
 * @param <T>
 */
public abstract class Father<T,T1> {
	T name;
	public abstract void test(T t);
}
/**
 * 子类声明时指定具体类型
 * 属性类型为具体类型
 * 方法同理
 */
class Child1 extends Father<String,Integer>{
	String t2;
	@Override
	public void test(String t){
		
	}
}
/**
 * 子类为泛型类，类型在使用时确定
 * @param <T1>
 * @param <T>
 */
class Child2<T1,T> extends Father<T,T1>{
	T t2;
	@Override
	public void test(T t){
		
	}
}
/**
 * 子类为泛型，父类不指定类型，泛型的擦除，使用Object替换
 * @param <T1>
 * @param <T>
 */
class Child3<T1,T2> extends Father{
	
	@Override
	public void test(Object t){
		
	}
}
/**
 * 子类与父类同时擦除
 */
class Child4 extends Father{
	String name;
	@Override
	public void test(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}
/**
 * 错误：子类擦除，父类使用泛型
class Child5 extends Father<T,T1>{
	String name;
	@Override
	public void test(T t) {
		// TODO Auto-generated method stub
		
	}
}
*/

泛型擦除

  • 擦除：
    • 在使用时没有指定具体的类型
    • 子类继承时没有指定类型
  • 处理：
    • 擦除后不类型检查
    • 一旦擦除之后按Object接收
    • 依然存在编译警告，加上 Object可以去除，但是有些画蛇添足

eg:

/**
 * 泛型接口：与继承同理
 * 重写方法随父类而定
 * @author qiao39gs
 *
 * @param <T>
 */
public interface Comparable<T> {
	void compare(T t);
}
//声明子类指定具体类型
class Comp implements Comparable<Integer>{

	@Override
	public void compare(Integer t) {
		// TODO Auto-generated method stub
		
	}
	
}
//擦除
class Comp1 implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}
//父类擦除，子类泛型
class Comp2<T> implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}
//子类泛型>=父类泛型
class Comp3<T> implements Comparable<T>{

	@Override
	public void compare(T t) {
		// TODO Auto-generated method stub
		
	}
	
}
//父类泛型，子类擦除	错误

eg2:

/**
 * 泛型的擦除
 * 1.继承|声明不指定类型
 * 2.使用时不指定类型
 * 统一Object对待
 * 	1.编译器警告(Student is a raw type. References to generic type Student<T> should be parameterized)
 *    消除警告：加<Object>
 *  2.不完全等同于Object,编译不会类型检查
 * @author qiao39gs
 *
 * @param <T>
 */
public class Student<T> {
	private T javaScore;
	private T oracleScore;
	
	//private static T1 test;	//不能使用静态属性|静态方法上
	
	public T getJavaScore() {
		return javaScore;
	}

	public void setJavaScore(T javaScore) {
		this.javaScore = javaScore;
	}

	public T getOracleScore() {
		return oracleScore;
	}

	public void setOracleScore(T oracleScore) {
		this.oracleScore = oracleScore;
	}

	public static void main(String[] args) {
		Student stu = new Student();
		//消除警告使用Object
		Student<Object> stu1 = new Student<Object>();
		stu1.setJavaScore("A");  //以Object对待
		
		test(stu);	//stu相当于 Object但是不完全等同 Object
		//擦除，不会类型检查
		//test(stu1);	
		test1(stu);
		test1(stu1);
	}
	
	public static void test(Student<Integer> a){
		
	}
	
	public static void test1(Student<?> a){
		
	}
	
}

泛型没有多态

  1. 回顾类与接口存在多态
  2. 泛型没有多态
    直接使用：A< Object> a = new A< String>();  错误
    方法形参与返回类型也不存在泛型多态
  3. 不能使用instanceof判断是否为泛型实例
    a instanceof A<String>

多态的两种形式eg:

Fruit.java:

public class Fruit {

}
class Apple extends Fruit{
	
}

 FruitApp.java

public class FruitApp {

	public static void main(String[] args) {
		Fruit f = new Apple();
		test(new Apple());
	}
	
	//形参使用多态
	public static void test(Fruit f){
		
	}
	
	//返回类型使用多态
	public static Fruit test2(){
		return new Apple();
	}
	
}

 泛型不能使用多态：

 A.java

public class A<T> {

}

 App.java

public class App {
	
	public static void main(String[] args) {
		//A<Fruit> f = new A<Apple>();	报错：Type mismatch: cannot convert from A<Apple> to A<Fruit>
		A<Fruit> f = new A<Fruit>();
		//test(new A<Apple>());	报错：The method test(A<Fruit>) in the type App is not applicable for the arguments (A<Apple>)
	}
	
	//形参使用多态
	public static void test(A<Fruit> f){
		
	}
	//返回类型使用多态
	public static A<Fruit> test2(){
		//return (A<Fruit>) (new A<Apple>());	报错：Cannot cast from A<Apple> to A<Fruit>
		return null;
	}
	
}

通配符

? extends super

  1. 可以用在声明类型及声明方法参数上，不能用在声明类上
  2. ？可以接受泛型的任意类型，只能接收和输出，不能修改
           方法声明时参数无法正确知道具体的类型，因此不能修改
  3. ？ extends    泛型上限    <=
  4. ？ super        泛型下限    >=
/**
 * ?类型不定，使用时确定类型
 * ?的使用:声明类型|声明方法上，不能声明类或使用时
 * ？ extends <=   泛型上限  指定类型 子类或自身
 * ？ super   >=   泛型下限  指定类型为自身或父类  
 * @author qiao39gs
 *
 */
public class Student<T> {
	T score;
	
	public static void main(String[] args) {
		Student<?> stu = new Student<String>();
		test(new Student<Integer>());
		
		test2(new Student<Apple>());
		//test3(new Student<Apple>());	//泛型没有多态
		
		//test4(new Student<Apple>());	//<
		stu = new Student<Fruit>();
		//test4(stu);	//使用时确定类型 
		test4(new Student<Object>());
		test4(new Student<Fruit>());
	}
	
	public static void test(Student<?> stu){
		
	}
	
	public static void test3(Student<Fruit> stu){
		
	}
	// <=
	public static void test2(Student<? extends Fruit> stu){
		
	}
	// >=
	public static void test4(Student<? super Fruit> stu){
		
	}
}

泛型嵌套

  1. 声明：嵌套使用泛型
    A<B<C>> a = new A<B<C>>();
  2. 使用：从外到内，一层层拆分
    稍微复杂一些，与调用没有任何的关系，只确定了类型
public class Nest <T> {
	T stu;
	
	public static void main(String[] args) {
		//泛型的嵌套
		Nest<Student<String>> room = new Nest<Student<String>>();
		//从外到内拆分
		room.stu = new Student<String>();
		Student<String> stu = room.stu;
		String score = stu.score;
		System.out.println(score);
	}
	
}

泛型与数组

  • 没有泛型数组，不能创建泛型数组
  • 可以只有声明，可以使用？
  • A<String>[] a1 = null;
  • A<?>[] a2 = new A<?>[10]；
public class Array {
	
	public static void main(String[] args) {
		Student<?>[] arr2 = new Student[10];
		
		MyArrayList<String> strList = new MyArrayList<String>();
		strList.add(0,"aa");
		String elem = strList.getElem(0);
		System.out.println(elem);
	}
	
}
class MyArrayList<E>{
	//E[] cap = new E[10];	没有泛型数组
	Object[] cap = new Object[10];
	
	public void add(int idx,E e){
		cap[idx] = e;
	}
	
	public E[] getAll(){
		return (E[]) cap;
	}
	
	public E getElem(int idx){
		return (E) cap[idx];
	}
}

JDK7泛型改进

  • jdk7改进：声明时指定泛型即可，创建对象不用再次编写类型
  • 如  A<String> a = new A<>0;
public class Test7 {
	
	public static void main(String[] args) {
		List<String> arrList = new ArrayList<String>();
		List<String> arrList2 = new ArrayList<>();
	}
	
}

 

rjbp40ht
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础：14.1 泛型
桃子味的梨
03-28 397
文章目录1. 回顾ArrayList类2. 泛型的概念3.通配泛型4.注意 1. 回顾ArrayList类 ArrayList是一种泛型类，具有一个泛型类型<E>，创建一个ArrayList 时，可以指定一个具体的类型来替换E。Java 提供ArrayList 类来存储不限定个数的对象。位于java.util 包中。存储在ArrayList中的元素必须是一种对象，不能使用int的基本数...
Java基础 —— 泛型（二）限制类型参数
能量老8的博客
03-03 981
List
Java学习14--泛型
yanxinrui1995的博客
05-21 139
 泛型：标识着集合中保存的元素 &lt;泛型（类型）&gt; 好处： 1.操作数据更加安全(规范集合中 能保存的数据) 2.可以避免向下转型（强转类型）的麻烦 3.将运行时的错误 转到编译时报错 private static void fun2() { // 不加泛型 集合中保存三个学生 ArrayList&lt;Student&gt; list = new ArrayList&lt;&g...
Java之泛型
不努力只能看别人脸色。
08-19 430
为什么要使用泛型JDK1.4以前类型不明确，只能用Object替代，从而失去了自己的类型，取出来之后往往需要转型，效率低下。//例如学生的成绩有多种可能，字符串，整型，浮点型等，此时就应该使用Object，它可以接受任何类型。 public class Student { //成绩 private Object javase; public Student() { }
Java基础 : Integer解析
小尘鸟
01-22 331
Java基础之Integer解析 Integer的定义 首先举例一个经典面试题知识点 public class Test { public static void main(String[] args) { Integer a = 100; Integer b = 100; int f = 100; Syste...
Object类型转为Integer类型
热门推荐
雨落未成曲的博客
12-10 1万+
Object类型转为Integer类型两种方式 两种方式 1、使用（Integer）方式，可以兼容为null的情况，不会报错（推荐） Integer abc = (Integer) obj; 2、使用parseInt方式，这样的话obj不能为null，否则会报错 这样是将object类型使用toString转为字符串String类型，然后将String类型使用parseInt转为int类型，再通过自动包装将int类型转为Integer类型 Integer.parseInt(obj.toString());
Java基础——泛型
最新发布
weixin_50458070的博客
05-17 223
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型//在实例化泛型类时，必须指定T的具体类型//key这个成员变量的类型为T,T的类型由外部指定public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定return key;
Java高级——泛型
ou_yang_mu_ling的博客
09-11 497
泛型一、为什么要有泛型？1.1 泛型1.2 问题一——类型不安全1.2 问题二——强转时可能出现报错1.3 引出泛型二、在集合中使用泛型2.1 在ArrayList中使用泛型2.2 在HashMap中使用泛型总结三、自定义泛型结构3.1自定义泛型类3.2自定义泛型方法四、泛型在继承上的体现五、通配符的使用六、泛型应用举例 一、为什么要有泛型？ 1.1 泛型 可以理解为生活中的标签 把元素的类型设计成一个参数,这个参数就是泛型 所谓泛型，就是允许在定义类、接口时通过一个标识符表示类中某个属性的类型或者是某个
java基础 —— 泛型概述和基本使用
求学之路的苦行僧
09-11 221
泛型概述和基本使用 A:泛型概述 B:泛型好处 提高安全性(将运行期的错误转换到编译期) 省去强转的麻烦 C:泛型基本使用 <>中放的必须是引用数据类型 D:泛型使用注意事项 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型) ArrayList存储字符串和自定义对象并遍历泛型版(掌握) A:案例演示 ArrayList存储字符串并遍历泛...
Java——泛型之泛型概述、泛型定义格式、泛型好处、泛型类、泛型方法、泛型接口、类型通配符、可变参数
smile4548656的博客
04-19 190
Java——泛型
Java语言之Integer类
qq_43380674的博客
06-20 7219
Java之Integer类 Integer类简介： Integer类是基本数据类型int的包装器类，是抽象类Number的子类，位于java.lang包中。 Integer类在对象中包装了一个基本类型int的值，也就是每个Integer对象包含一个int类型的字段。在Integer源码中如下定义： private final int value; 字段: [static int] MAX_VA...
Integer类详细介绍：
chen_kai_fa的博客
02-22 2277
Integer类的方法讲解。
java中Integer类的常用方法
qq_43410906的博客
03-27 1057
文字描述不清楚，我们还是直接看代码： public class IntegerTest { public static void main(String[] args) { Integer i = new Integer('Q'); Integer i1=new Integer('c'); /* * toString()返回的是一个字符串， * 并且该toStrin...
Object类型转换为Integer类型
秋风伴落叶
04-28 2573
Integer.parseInt(obj.toString()); Integer.parseInte(String.valueof(obj));
Java——从键盘获取学生成绩并排名等级
m0_47386561的博客
04-21 1450
Scanner
菜鸡自学JAVA坎坷路day.19（泛型1）
qq_38053395的博客
05-27 126
1.testGeneric01package testGeneric01; /** * 获取值: * 1、强制类型转换 * 2、手动类型检查:避免转换错误 java.lang.ClassCastException: * @author Wang * */ public class gen01 { public static void main(String[] args) { ...
java---面向对象 11（自动拆箱、装箱）
m0_64819500的博客
08-12 128
java一维数组题拆箱装箱
面向对象关于成绩等级练习题
handsome1_的博客
05-07 1137
面向对象包装类练习题 利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出 最高分，并输出学生成绩等级。 提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的 长度。而向量类java.util.Vector可以根据需要动态伸缩。 创建Vector对象： Vector v=new Vector(); 给向量添加元素： v.addElement(Object obj); //obj必须是对象 取出向量中的元素： Object obj=v.elementAt(0);.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值