个人名片:
🐼作者简介:一名大一在校生
🐻❄️个人主页:小新爱学习.
🐼个人WeChat:hmmwx53
🕊️系列专栏:零基础学java ----- 重识c语言 ---- 计算机网络
🐓每日一句:没有太晚的开始,只有过早的放弃
前言:
最近有许多小伙伴问小新有没有好用的刷题网站,想提升一下自我能力
经过小新缜密的思考与亲身体验,推荐超实用的🎉点击直接访问牛客网🎉
里面用丰富的大厂面试真题、各类算法由易到难层层递进、专项题库应有尽有,还不快来体验体验🎏🎏🎏
快来开启刷题之旅吧!!!
文章目录
- 泛型
-
- 1.1 泛型概述:
-
-
- 泛型定义格式:
- Demo:
- 总结:
- java 中泛型标记符:
-
- 1.2 泛型类
-
-
- 泛型类的定义格式:
- 泛型类的使用:
-
- 1.3 泛型方法:
-
-
- 泛型方法的定义格式:
- 泛型方法的定义和使用
-
- 1.4 泛型接口:
-
-
- 泛型接口的定义格式:
- 泛型接口的定义和使用
-
- 1.5 类型通配符
-
- 代码示例:
- 1.6 可变参数:
-
-
- 代码示例:
-
- 欢迎添加微信,加入我的核心小队,请备注来意
泛型
1.1 泛型概述:
Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参,对于参数化类型的理解:
顾名思义:就是将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型
这种参数类型可以用在类,方法和接口中,分别被称为泛型类,分型方法,泛型接口。
假定我们有这样一个需求:写一个排序方法,能够对整型数组、字符串数组甚至其他任何类型的数组进行排序,该如何实现?
答案是可以使用 Java 泛型。
使用 Java 泛型的概念,我们可以写一个泛型方法来对一个对象数组排序。然后,调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。
泛型定义格式:
- <类型>:指定一种类型格式。这里的类型可以是形参
- <类型1,类型2…>:指定多种类型的格式,多种类型之间的用逗号隔开。这里的类型可以看成是形参
- 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型
Demo:
要求:collection集合存储字符串并遍历
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//要求:
public class Demo {
public static void main(String[] args) {
//创建集合对象
//Collection c = new ArrayList();//先不使用泛型
//使用泛型
Collection<String> c = new ArrayList<String>();
//添加元素:
c.add("hello");//向上转型
c.add("world");
c.add("java");
//c.add(100);//自动封装为Integer类型,使用泛型可以将编译器出现的问题提前
//遍历集合(迭代器)
//Iterator t = c.iterator();
Iterator<String> t = c.iterator();//使用泛型不需要强制转换
while(t.hasNext()) {
//Object obj = t.next();
//String obj = (String)t.next();//向下转型,变为String类型
String s = t.next();
// ClassCastException
System.out.println(s);
}
}
}
在未指定集合中元素类型的时候,默认是Object类型,因为泛型默认是引用类型,而Object可以代表所有的引用类型
因为添加的时候是Object类型,所以获取也是
总结:
泛型的好处:
- 把运行时期的问题提前到了编译时期
- 避免了强制类型转换
java 中泛型标记符:
- E - Element (在集合中使用,因为集合中存放的是元素)
- T - Type(Java 类)
- K - Key(键)
- V - Value(值)
- N - Number(数值类型)
- ? - 表示不确定的 java 类型
1.2 泛型类
概述:
泛型类的声明和非泛型类的声明类似,除了在类名后面添加了类型参数声明部分。
和泛型方法一样,泛型类的类型参数声明部分也包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数,这些类被称为参数化的类或参数化的类型。
泛型类的定义格式:
- 格式:修饰符class类名< 类型>{ }
- 范例:public class Generic< T> { }
此处T可以随便写为任意标识符,常见的如T,E,K,V等形式的参数常用与表示泛型
泛型类的使用:
public class Generic <T>{
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public static void main(String[] args) {
Generic<String> g = new Generic<String>();
g.setT("张三");
System.out.println(g.getT());
Generic<Integer> g1 = new Generic<Integer>();
g1.setT(20);
System.out.println(g1.getT());
}
}
控制台输出:张三 20
1.3 泛型方法:
泛型方法的定义格式:
- 格式:修饰符< 类型> 返回值类型 方法名(类型 变量名){ }
- 范例:public < T> void show(T t){ }
泛型方法的定义和使用
package com.ithmm_06;
public class Generic <T> {
// public void show(Integer i){
// System.out.println(i);
// }
// public void show(Double d){
// System.out.println(d);
// }
//使用泛型改进方法
// public void show(T t){
// System.out.println(t);
// }
//使用泛型方法改进
public <T> void show(T t){
System.out.println(t);
}
public static void main(String[] args){
// Generic t = new Generic();
// t.show("hello");
// t.show(1);
// t.show(2.0);
//t.show(true);//报错没有boolean类型方法
//使用泛型创建对象
// Generic<String> g1 = new Generic<String>();
// g1.show("hello");
//
// Generic<Integer> g2 = new Generic<Integer>();
// g2.show(1);
//
// Generic<Double> g3 = new Generic<Double>();
// g3.show(2.0);
Generic g = new Generic();
g.show("hello");
g.show(1);
g.show(2.0);
}
}
控制台输出:hello 1 2.0
1.4 泛型接口:
泛型接口的定义格式:
- 格式:修饰符 interface 接口名 < 类型>{ }
- 范例:public interface Generic< T> { }
泛型接口的定义和使用
package com.ithmm_07;
public class Generic {
public static void main(String[] args) {
//测试类
GenericFace<String> g = new GenericImpl<String>();
g.show("Hello");
GenericFace<Integer> g2 = new GenericImpl<Integer>();
g2.show(100);
}
}
interface GenericFace <T> {
void show(T t);
}
class GenericImpl <T> implements GenericFace<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
控制台输出:hello 100
1.5 类型通配符
为了表示各种泛型List的父类,可以使用类型通配符
- 类型通配符:<?>
- List<?>:表示元素类型未知的List,他的元素可以匹配任何的类型
- 这种带通配符的List仅仅表示它是个=各种泛型List的父类,并不能把元素添加到其中
如果我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类,可以使用类型通配符的上限
- 类型通配符的上限:<?extends 类型>
- List<? extends Number>:它表示类型是Number或者其子类型
除了可以指定类型通配符的上限,我们也可以指定类型通配符的下限
- 类型通配符:<?Super 类型>
代码示例:
package com.ithmm_07;
import java.util.ArrayList;
import java.util.List;
public class GenericDemo {
public static void main(String[] args) {
//类型通配符
List<?> kist1 = new ArrayList<Object>();
List<?> kist2 = new ArrayList<Number>();
List<?> kist3 = new ArrayList<String>();
System.out.println("-------------------");
//类型通配符的上限
// List<? extends Number> lis = new ArrayList<Object>();//报错
List<?extends Number> list5 = new ArrayList<Integer>();
List<?extends String> list6 = new ArrayList<String>();
//类型通配符下限<? super 类型>
List <? super Number> list7 = new ArrayList<Object>();
List <?super Number> list8 = new ArrayList<Number>();
// List<? super Number> list9 = new ArrayList<Integer>();报错
}
}
1.6 可变参数:
注意:
可变参数又称个数可变,用作方法的形参出现,那么方法参数个数就是可变的
可变参数只能作为函数的最后一个参数,但其前面可以有也可以没有任何其他参数
由于可变参数必须是最后一个参数,所以一个函数最多只能有一个可变参数
Java的可变参数,会被编译器转型为一个数组
变长参数在编译为字节码后,在方法签名中就是以数组形态出现的。这两个方法的签名是一致的,不能作为方法的重载。如果同时出现,是不能编译通过的。可变参数可以兼容数组,反之则不成立
- 格式:修饰符 返回值类型 方法名 (数据类型…变量名){ }
- 范例:public static int sum (int …a){ }
可变参数注意事项
- 这里的可变参数是一个数组
- 如果一个方法有多个参数,包含可变参数,可变参数要放在最后面
代码示例:
package com.ithmm_07;
public class ArgDemo01 {
public static void main(String[] args) {
System.out.println(sum(10,20,2,0,5,5));
System.out.println(sum(10,20));
System.out.println(sum(2,5,4,8,8,5,5,5));
}
public static int sum(int ... a){
int sum =0;
for(int i: a){
sum += i;
}
return sum;
}
}
欢迎添加微信,加入我的核心小队,请备注来意
👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇