【Java】Java学习笔记9-泛型

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量129 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liche33/article/details/104445385
版权

泛型

1.背景

在jdk1.5之前，为了让“集合” （能够存放多个数据元素（对象型数据）的仓库——容器）
能够处理各种类型，可以允许放入多种类型的元素。统一设置成Object
Object s=集合.get(0)
Object s=集合.get(1)
Integer t=(Integer)s
大多数用户都是在使用集合的时候，放入同种类型的元素

jdk1.5之后，出现了泛型的概念（c++中泛型）
在创建集合的时候，就必须规定好这个集合中，只能放入什么类型的元素
解决之前集合中元素的问题：
（1）add(s) String ss=集合.get(0) 解决繁琐性
（2）add入元素的时候，可以检测元素类型是否符合集合声明的泛型类型 ，安全性

介绍集合简单操作：主要会应用到接口和实现类
List接口
ArrayList实现类
List list=new ArrayList(); 使用父类引用指向子类对象
add方法：加入元素
get方法：获取元素

public class Day12_1_T {
public static void main(String[] args) {
 //1.5之前  list集合中可以放入Object
//  缺点：不安全（可以随便放入元素，但是不允许随便取出元素）
//        即使取出的是符合要求的类，操作也很繁琐（强制转换）
  List list=new ArrayList();
  list.add("one");
  list.add("two");
  list.add(Integer.valueOf(3));
  String s1=(String)list.get(0);
  String s2=(String)list.get(1);
  String s3=String.valueOf(list.get(2));
}
}

2.泛型应用

【语法】（泛型类）类型<泛型类型>:允许泛型类中，加入T类型的元素

【使用的情形】两种

创建对象，声明泛型类型：泛型类<类型> 变量名

方法定义，声明形式参数：泛型类<类型>形式参数名

【本质】将所操作的数据类型指定一个参数类型，也被称为，参数化类型

public class Day12_1_T {
	  public static void main(String[] args) {
		  List<String> list=new ArrayList<String>();
		  list.add("one");
		  list.add("two");
		  list.add("tree");
//		  list.add(3);
		  String s1=list.get(0);
		  String s2=list.get(1);
		  String s3=list.get(2);
//		  String s3=String.valueOf(list.get(2));
	}
}

【相关概念】

对于泛型类型来说，在使用类型的时候，如果没有提供泛型类型的泛型类型(<>)，叫做原生类型，如果提供了泛型类型，被称为参数化类型

原生类型和参数化类型之间的转换

public class Day12_1_T {
public static void main(String[] args) {
	  List list1=new ArrayList();  //原生
	  List<String> list2=new ArrayList();//泛型
//	  list1=list2;
	  list2=list1;  //有警告，但是不会出错
//	  原生类型直接赋予给泛型类型，不可以
//	  泛型类型直接赋予给原生类型，可以
}
}

3.自定义泛型类型

{}自定义泛型语法

class 类名<大写字母E [extends 父类类型]>

意味着在类中，可以装入E类型，也可以是父类的任意子类型

E 字母：代表抽象的类型，可以任何定义

习惯性 T(type) E(element) K(key) V(value)

需求，定义一个泛型类（仓库），使得泛型类中，能够装入一个本书，或者能够装入一台计算机

class Book{
	private String name;
	private double price;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public Book(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}
}

class Computer{
	private String type;
	private double price;
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public Computer(String type, double price) {
		super();
		this.type = type;
		this.price = price;
	}
}

//class Integer{
//	private int value;
//	public int intValue(){
//		return this.value;
//	}
//}


class Store<T>{
	private T[] t ;
public T[] getT() {
	return t;
}
public void setT(T[] t) {
	this.t = t;
}
}

public class Day12_1_T {
	public static void main(String[] args) {
	   Book b1=new Book("java",100.0);
	   Book b2=new Book("java",100.0);
	   Book [] bs={b1,b2};
	   Computer c=new Computer("intel7",10000.0);
	   Store<Book> sbook=new Store();
	   sbook.setT(bs);
	   Store<Computer> cstore=new Store();
	   cstore.setT(new Computer[]{c});
	}
}

4.泛型类型的继承

T t=new T();

T[] ta=new T[3];

Object o=new Object();

Object[] oa=new Object[3];

所有类都默认继承Object类

当定义了一个类型之后，如果这个类型有父类型，

name这个类型对应的数组类型有父类型的子类

List T继承Object

List不继承List

泛型类型不保持原有的参数类型的继承关系。

但是数组类型保持元类类型之间的继承关系。

class A{
	
}
class T extends A{}

public class T3{
	public static void main(String[] args) {
		T t=new T();
		Object o=new Object();
		T[] ta=new T[3];
		Object[] oa=new Object[3];
		System.out.println(t instanceof T);
		System.out.println(t instanceof Object);
		System.out.println(ta instanceof T[]);
		System.out.println(ta instanceof Object[]);
		A et = new T();
		List<Object> listo=new ArrayList<>();
		List<T> listt=new ArrayList<>();
		System.out.println(listo instanceof ArrayList);
	}
}

class Fruit{
String name;
public void show(){
	System.out.println("水果");
}
}
class Apple extends Fruit{
public void show(){
	System.out.println("苹果");
}
}

public class Day12_1_T {
public static void doSomething(List<Fruit> fs){
	
}
public static void main(String[] args) {
	List<Fruit> fs =new ArrayList();
	List<Apple> as =new ArrayList();
	doSomething(fs);
	doSomething(as);
	
}
}

5.泛型类型参数的通配符

（可以泛型类型父类型）——通过通配符来实现的。
（1）无界通配符
【语法】? 不确定的类型
List<?>是所有List<>泛型类型的父类型

class Fruit{
	String name;
	public void show(){
		System.out.println("水果");
	}
}
class Apple extends Fruit{
	public void show(){
		System.out.println("苹果");
	}
}

public class Day12_1_T {
	public static void doSomething(List<?> fs){
}
public static void main(String[] args) {
	List<Fruit> fs =new ArrayList();
	List<Apple> as =new ArrayList();
	List<String> ss =new ArrayList();
	doSomething(fs);
	doSomething(as);
	doSomething(ss);
}
}

（2）上限通配符
如果只希望往里面装入水果类型的 List 可以通过上限通配符来设置
【语法】 <? extends X> 表示可以是X类型，也可以是X类型子类型
(了解) extends 可以多继承。 <? extends X&Y> 代表同时继承

class Fruit{
String name;
public void show(){
	System.out.println("水果");
}
}
class Apple extends Fruit{
public void show(){
	System.out.println("苹果");
}
}

public class Day12_1_T {
public static void doSomething(List<? extends Fruit> fs){

}
public static void main(String[] args) {
	List<Fruit> fs =new ArrayList();
	List<Apple> as =new ArrayList();
	List<String> ss =new ArrayList();
	doSomething(fs);
	doSomething(as);
	doSomething(ss);
}
}

（3）下限通配符
可以是X类型，也可以是X类型父类型
【语法】<? super X>

class Food{
	
}
class Fruit extends Food{
String name;
public void show(){
	System.out.println("水果");
}
}
class Apple extends Fruit{
public void show(){
	System.out.println("苹果");
}
}

public class Day12_1_T {
public static void doSomething(List<? super Apple> fs){

}
public static void main(String[] args) {
	List<Fruit> fs =new ArrayList();
	List<Apple> as =new ArrayList();
//	List<String> ss =new ArrayList();
	List<Food> fo =new ArrayList();
	List<Object> oo =new ArrayList();
	doSomething(fs);
	doSomething(as);
	doSomething(fo);
	doSomething(oo);
//	doSomething(ss);
}
}

6.泛型类型的擦除

【泛型类型背景】：java中的泛型类型，仿照c++下的泛型类型，c++泛型类型不仅仅在编译期起作用，在运行期也会起作用
泛型类型检查仅仅是在编译期有效，在编译期过后，在运行期时，所有的泛型参数都会丢失<>
编译期取的元素的类型，取泛型类型擦除之后的类型.
List list=
class Store {
private T t;
}
调用的时候， Store sbook=new Store();
泛型类型在擦除的时候，取什么样的类型
【规则】：如果泛型类型内部，没有继承任何的父类，擦除之后类型取Object类型
如果泛型类型内部，有继承了父类，擦除之后的类型取父类类型。

public class Day12_1_T {
	public static void main(String[] args) {
//		Store <Book> sbook=new Store();
//		编译过后
//		Store sbook=new Store();  泛型类型擦除之后的 样子

	List<Integer> list=new ArrayList();
//		擦除之后List  list=new ArrayList();
	}
}
class Number{
	
}
class Store<T >{
	private T t;
}
//编译之后，被擦除泛型类型
class Store {
	private Object t;
}
class Store<T extends Number>{
	private T t;
}
//编译之后，被擦除泛型类型
class Store {
	private Number t;
}public class T3{
	public static void main(String[] args) {
		List<Integer> list=new ArrayList();
	}
}
class Number{}
class Store{
	private Object t;
}
class Store<T extends Number>{
	private T t;
}
class Store<>{
	private Number t;
}

（1）关于重载方法中的泛型

​ 重载：在同一个类中，有相同名字的方法

​ 名字必须相同

​ 参数类型必须不同

​ 只有返回值不同不叫重载

【重载的要求中，对于类型】：是否能够构成重载，要看擦除类型后，参数类型是否相同，如果擦除之后，相同，则不能重载

interface  A{
}
interface B{
}

public class Day12_1_T<E> {
	public void m(List<String> ls){}
	public void m(List<Integer> li){}
	public void m(List<? extends Integer> li){}

//	上面两个方法擦除之后的样子，相当于参数相同，不是重载
	public void m(List ls){}
	public void m(List li){}



//	泛型  泛型方法  访问权限修饰符 <大写字母>   返回值  方法名字(){}
//	T 的作用域只支持在m的方法内部使用。m可以接受任何类型（引用类型）的参数。
//	不算重载，因为擦除之后，T和E 都是Object
	public <T> void m(T t){};
	public void m(E e){};
	
//	算重载，
	public <T> void m(T t){};
	public void m(String s){};
	
//	算重载 当泛型类型继承多个接口的时候，擦除类型使用第一个类型
	public <T extends  A & B> void m(T t){};
	public  void m(B t){};
	
//	不算重载，使用A作为擦除类型
	public <T extends  A & B> void m(T t){};
	public  void m(A t){};	

public static void main(String[] args) {}
}

（2）关于方法重写泛型规则

【规则】名字相同，子类中重写父类方法

参数：要求参数类型一样，如果泛型类型擦除之后一样也可以

子类扩展

子类的参数类型是原生类型，父类参数类型擦除类型跟子类一致

父类类型的参数，擦除泛型类型后，跟子类参数类型一致，也可以算是重写

但是反过来，子类类型如果擦除泛型之后，跟父类类型一致，不能构成重写

class Fruit{
	public void m(List<String> list){
	}
}
class Apple extends Fruit{
	public void m(List list){
	}

}
离澈澈澈
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java仓储模式_仓储(Repository)和工作单元模式(UnitOfWork)
weixin_35271253的博客
02-26 1301
仓储和工作单元模式仓储模式为什么要用仓储模式通常不建议在业务逻辑层直接访问数据库。因为这样可能会导致如下结果：重复的代码编程错误的可能性更高业务数据的弱类型更难集中处理数据，比如缓存无法轻松地从外部依赖项测试业务逻辑在业务逻辑层通过仓库模式访问数据则可以实现如下特点：最大化可以用自动化测试的代码量，并隔离数据层以支持单元测试。对数据集中管理、提供一致的访问规则和逻辑。通过将业务逻辑与数据或服务访问...
java 泛型 工厂_Java设计模式泛型化之工厂模式 | 学步园
weixin_31083901的博客
02-12 495
关于工厂模式，本文就不详述了。大家可以百度。基本的结构是这样的：一个抽象产品(接口或者抽象类)几个具体的产品类去实现这个抽象产品一个工厂类一个调用类下面是示例代码：抽象产品(接口)public interface Product {public void doSomething();}具体产品实现类public class ProductA implements Product {@Overrid...
你必须知道的Java泛型
qq_42820805的博客
05-19 106
前言“文本已收录至我的GitHub仓库，欢迎Star：https://github.com/bin392328206/six-finger”絮叨上周，小六六踩了个大坑，一周没更新文章，怎么...
定义泛型接口和类
runfeel
07-09 203
JDK1.5之后的List接口，Iterator接口，Map接口的代码： public interfaceList&lt;E&gt; { voidadd(E x); Iterator&lt;E&gt; iterator(); } public interfaceIterator&lt;E&gt; { E next(); Boolean hasNext(); } P...
Java核心类库（一）——常用类库（泛型）
技术小白
06-10 174
常用类库
【Java】菜鸟教程个人Java学习笔记
苏柒的博客
03-15 631
检索目录前言正文在线编程主要特性专业术语：DOS命令操作基础规范数组排序日期和时间方法方法的优点方法的命名规则方法的定义变量作用域FileInputStreamFileOutputStream异常Java 数据结构Java 实例Java 环境设置实例Java 字符串Java 数组Java 时间处理Java 方法打印图形Java 文件操作Java 目录操作Java 异常处理Java 数据结构Java 集合Java 网络实例Java 线程Java 测验未完待续 前言 根据最近和众多师兄，同学，以及逛学校论坛看经
Java学习笔记：Java基础篇(九)——面向对象：Java 封装
Y的博客
09-10 211
Java 封装 封装是指一种将抽象性函数式接口的实现细节部分包装、隐藏起来的方法。 封装可以防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 实现Java封装的步骤 修改属性的可见性来限制对属性的访问（一般限制为private） 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问【采用 this 关键字是为了解决实例变量和局部变量之间发生的
java基础学习笔记之泛型
09-02
泛型是Java编程语言中的一个重要特性，首次在JDK 1.5版本中引入，它允许程序员在定义类、接口和方法时使用类型参数，从而实现了类型的安全性和代码的复用性。泛型的主要目标是增强类型安全，避免在运行时出现...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java基础尚硅谷宋红康学习笔记
05-29
9. **Spring框架**：Spring是Java企业级应用的主流框架，提供依赖注入、AOP、数据访问、Web应用等功能。 10. **Java并发编程**：包括线程池、锁机制（如synchronized、ReentrantLock）、并发容器（如...
Java泛型学习笔记.pdf
10-04
Java泛型是Java编程语言中的一个重要特性，它允许在类、接口和方法中使用类型参数，从而提高了代码的重用性和安全性。以下是对Java泛型的一些关键知识点的详细解释： 1. **类型变量命名规则**：类型参数通常使用...
java基础知识学习笔记.rar
06-20
这些只是Java基础知识的一部分，深入学习还包括异常处理、多线程、网络编程、反射、注解、枚举、模块化系统等内容。理解并熟练掌握这些知识，是成为一名合格Java开发者的必要条件。在实践中不断学习和应用，才能不断...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1263
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 811
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 366
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 501
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2393
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1564
Java实现拼图小游戏
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 283
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java泛型深入理解与应用
"java李兴华学习笔记之泛型" 在Java编程中，泛型是自JDK 1.5版本引入的一个重要特性，它极大地提高了代码的类型安全性和重用性。李兴华老师的课程主要关注如何利用泛型来优化程序设计。下面将详细讲解泛型的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值