- Java锁的逻辑(结合对象头和ObjectMonitor)
- 还在用饼状图?来瞧瞧这些炫酷的百分比可视化新图形(附代码实现)⛵
- 自动注册实体类到EntityFrameworkCore上下文,并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
看下面这段代码:
private static int add(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static float add(float a, float b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static double add(double a, double b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
如果没有泛型,要实现不同类型的加法,每种类型都需要重载一个add方法;通过泛型,我们可以复用为一个方法:
private static <T extends Number> double add(T a, T b) {
System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
return a.doubleValue() + b.doubleValue();
}
泛型中的类型在使用时指定,不需要强制类型转换( 类型安全 ,编译器会 检查类型 ) 。
下面这段代码:
List list = new ArrayList();
list.add("xxString");
list.add(100d);
list.add(new Person());
我们在使用上述list中,list中的元素都是Object类型(无法约束其中的类型),所以在取出集合元素时需要人为的强制类型转化到具体的目标类型,且很容易出java.lang.ClassCastException`异常.
引入泛型,它将提供类型的约束,提供编译前的检查:
List<String> list = new ArrayList<String>();
// list中只能放String, 不能放其它类型的元素
1、编译时,检查添加元素的类型,提高了安全性 。
2、减少了类型转换的次数,提高效率 。
3、不再提示编译警告 。
1.泛型又称参数化类型,是Jdk5.0出现的新特性,解决数据类型的安全性问题 。
2.在类声明或实例化时只要指定好需要的具体的类型即可.
3.Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException.异常。同时,代码更加简洁、健壮 。
4.泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型,或者是某个方法的返回值的类型,或者是参数类型.
代码举例:
public class Generic03 {
public static void main(String[] args) {
//注意,特别强调:E具体的数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
Person<String> person = new Person<>("dfdfs");
person.show();//String
/**
* Person类相当于下面这样子
* class Person{
* String s;//E表示s的数据类型,该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
*
* public Person(String s) {//E也可以是参数类型
* this.s = s;
* }
*
* public String f(){//返回类型使用E
* return s;
* }
* public void show(){
* System.out.println(s.getClass());//显示s的运行类型
* }
* }
*/
Person<Integer> person2 = new Person<>(100);
person2.show();
/**
* Person类相当于下面这样子
* class Person{
* Integer s;//E表示s的数据类型,该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
*
* public Person(Integer s) {//E也可以是参数类型
* this.s = s;
* }
*
* public Integer f(){//返回类型使用E
* return s;
* }
* public void show(){
* System.out.println(s.getClass());//显示s的运行类型
* }
* }
*/
}
}
//泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型,或者是某个方法的返回值的类型,或者是参数类型
class Person<E>{
E s;//E表示s的数据类型,该数据类型在定义Person对象的时候指定,即在编译期间,就确定E是什么类型
public Person(E s) {//E也可以是参数类型
this.s = s;
}
public E f(){//返回类型使用E
return s;
}
public void show(){
System.out.println(s.getClass());//显示s的运行类型
}
}
interface 接口名 {}和class 类名<K,V>{} 。
说明:
1)其中,T,K,V不代表值,而是表示类型 。
2)任意字母都可以。常用T表示,是Type的缩写 。
要在类名后面指定类型参数的值(类型)。如:
List<String> strList = new ArrayList<String>();
Iterator<Customer> iterator = customers.iterator();
需求:
1.创建3个学生对象 。
2.放入到HashSet中学生对象,使用. 。
3.放入到HashMap中,要求Key 是String name,Value就是学生对象 。
4.使用两种方式遍历 。
public class GenericExercise {
public static void main(String[] args) {
//使用泛型方式给HashSet放入3个学生对象
HashSet<Student> students = new HashSet<>();
students.add(new Student("jack",18));
students.add(new Student("tom",18));
students.add(new Student("ml",18));
//第一种遍历方式,增强for循环
for (Student student:students){
System.out.println(student);
}
//使用泛型方式给HashMap放入3个学生对象
HashMap<String, Student> hm = new HashMap<>();
hm.put("milan",new Student("milan",34));
hm.put("jack",new Student("jack",31));
hm.put("tom",new Student("tom",30));
//2.迭代器
Set<Map.Entry<String, Student>> entries = hm.entrySet();
Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
System.out.println("==========================");
while (iterator.hasNext()){
Map.Entry<String, Student> next = iterator.next();
System.out.println(next.getKey()+"-"+next.getValue());
}
}
}
class Student{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
1.interface 接口名 {}和class 类名<K,V>中T,K,V只能是引用类型。如下面:
List<Integer> list = new ArrayList<Integer>();//这样写正确
List<int> list = new ArrayList<int>();//这样写错误
2.在给泛型指定具体类型后,可以传入该类型或者其子类类型 。
3.泛型使用形式 。
//1.第一种方式
List<Integer> list1 = new ArrayList<Integer>();
//2.第二种方式
List<Integer> Iist2 = new ArrayList<>();
3.如果我们这样写List list3=new ArrayList();默认给它的泛型是 E就是Object.,等价于ArrayList arrayList = new ArrayList (),
语法:
class 类名<T,R....>{//......表示可以有多个泛型
成员
}
注意事项
1.普通成员可以使用泛型(属性、方法) 。
2.使用泛型的数组,不能初始化 。
3.静态方法中不能使用类的泛型 。
4.泛型类的类型,是在创建对象时确定的(因为创建对象时,需要指定确定类型) 。
5.如果在创建对象时,没有指定类型,默认为Object 。
class Tiger<T,R,M>{
String name;
R r;//属性使用到泛型
M m;
T t;
T[] ts;//因为数组在new时不能确定T的类型,就无法在内存开空间
public Tiger(String name) {
this.name = name;
}
public Tiger(R r, M m, T t) {
this.r = r;
this.m = m;
this.t = t;
}
public Tiger(String name, R r, M m, T t) {//构造器使用泛型
this.name = name;
this.r = r;
this.m = m;
this.t = t;
}
//因为静态是和类相关的,在类加载时,对象还没有创建
//所以,如果静态方法和静态属性使用了泛型,JVM就无法完成初始化
//static R r2;
// public static void m1(M m){
//
// }
public R getR() {//返回类型可以使用泛型
return r;
}
public void setR(R r) {//方法使用到泛型
this.r = r;
}
}
语法:
interface 接口名<T,R....>{
}
注意事项:
1.接口中,静态成员也不能使用泛型(这个和泛型类规定一样) 。
2.泛型接口的类型,在继承接口或者实现接口时确定 。
3.没有指定类型,默认为Object 。
/**
* 泛型接口使用的说明
* 1.接口中,静态成员也不能使用泛型
* 2.泛型接口的类型,在继承接口或者实现接口时确定
* 3.没有指定类型,默认为Object
*/
//在继承接口指定泛型接口的类型
interface IA extends IUsb<String,Double>{
}
//当我们去实现IA接口时,因为IA在继承IUsub接口时,指定了U为String, R为Double,在实现IUsub接口的方法时,使用String替换U,是Double替换R
class AA 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) {
}
}
//实现接口时,直接指定泛型接口的类型
//给U指定Integer给R指定了Float
//所以,当我们实现IUsb方法时,会使用Integer替换U,使用Float替换R
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) {
}
}
//没有指定类型,默认为Object
//建议直接写成IUsb<Object,Object>
class CC implements IUsb{//等价class CC implements IUsb<Object,,Object>
@Override
public Object get(Object o) {
return null;
}
@Override
public void hi(Object o) {
}
@Override
public void run(Object r1, Object r2, Object u1, Object 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;
}
}
语法 。
修饰符 <T,R...>返回类型 方法名(参数列表){
}
注意事项:
1.泛型方法,可以定义在普通类中,也可以定义在泛型类中 。
2.当泛型方法被调用时,类型会确定 。
3.public void eat(E e){},修饰符后设有<T,R.>eat方法不是泛型方法,而是使用了泛型 。
public class CustomMethodGeneric {
public static void main(String[] args) {
Car car = new Car();
car.fly("宝马",100);//当调用方法时,传入参数,编译器,就会确定类型
System.out.println("==================");
Fish<String, ArrayList> fish = new Fish<>();
fish.hello(new ArrayList(),11.3f);
}
}
//泛型方法,可以定义在普通类中,也可以定义在泛型类中
class Car{//普通类
public void run(){//普通方法
}
//泛型方法
//1.<T,R>就是泛型
//2.是提供给 fly使用的
public <T,R> void fly(T t,R r){//泛型方法
System.out.println(t.getClass());
System.out.println(r.getClass());
}
}
class Fish<T,R>{//泛型类
public <U,M> void eat(U u,M m){//泛型方法
}
//下面的这个hi方法不是泛型方法,是hi方法使用了类声明的泛型
public void hi(T t){
}
//泛型方法,可以使用类声明的泛型,也可以使用自己声明泛型
public <K> void hello(R r,K k){
System.out.println(r.getClass());
System.out.println(k.getClass());
}
}
说明:
1.泛型不具备继承性 。
2.<?>:支持任意泛型类型 。
3.<? extends A>:支持A类以及A类的子类,规定了泛型的上限 。
4.<? super A>:支持A类以及A类的父类,不限于直接父类,规定了泛型的下限 。
public class GenericExtends {
public static void main(String[] args) {
//泛型没有继承性
//List<Object> list = new ArrayList<String>();
List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<AA> list3 = new ArrayList<>();
List<BB> list4 = new ArrayList<>();
List<CC> list5 = new ArrayList<>();
//如果是List<?>c,可以接受任意的泛型类型
printCollection1(list1);
printCollection1(list2);
printCollection1(list3);
printCollection1(list4);
printCollection1(list5);
//List<? extends AA>c:表示上限,可以接受AA或者AA子类
//printCollection2(list1); error
//printCollection2(list2); error
printCollection2(list3);
printCollection2(list4);
printCollection2(list5);
//List<?super AA>c:支持AA类以及AA类的父类,不限于直接父类
printCollection3(list1);
//printCollection3(list2); error
printCollection3(list3);
//printCollection3(list4); error
//printCollection3(list5); error
}
//说明:List<?>表示任意的泛型类型都可以接受
public static void printCollection1(List<?> c){
for (Object object :c){
System.out.println(object);
}
}
//?extends AA表示上限,可以接受AA或者AA子类
public static void printCollection2(List<? extends AA> c){
for (Object object:c){
System.out.println(object);
}
}
//?super 子类类名AA:支持AA类以及AA类的父类,不限于直接父类,规定了泛型的下限
public static void printCollection3(List<? super AA> c){
for (Object object:c){
System.out.println(object);
}
}
}
class AA{
}
class BB extends AA {
}
class CC extends BB {
}
最后此篇关于java基础——泛型的文章就讲到这里了,如果你想了解更多关于java基础——泛型的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
可以用这种方式转换字符串吗?我们有相同的参数,Java 做出了正确的选择。如果值是整数 - 我们调用 parseInt(value),否则如果值是 double 型 - 我们调用 parseDoubl
如果这段代码中有一个愚蠢的错误,我提前道歉,但我似乎无法解决它。我的问题是这样的,我用GCC-8(通过home-brew安装在Mac上)编译,然后在终端中执行。当使用 int do 定义变量 s &
我用 a-videosphere 制作了一个 a-scene。我尝试使用按钮启用/禁用声音,但有些想法不起作用?这是我的代码: var gargamel = 0; function
我正在使用 ISAAC 实现来生成随机整数。我需要用这些整数创建一个高斯值。首先,我需要将它们从 0 更改为 1 的 double 值。我怎样才能在Java中做到这一点?这是到目前为止我将整数转换为
我将 0x0000 到 0x01c2 范围内的十六进制值从 BLE 获取到我的手机 a 作为字符串。为了将其绘制在图表中,我必须将其转换为 double,我已经尝试过 this method但遗憾的是
我有一个父类(super class) Animal和一个子类 Dog 。在第三节课中,我有一个 List它同时接受子类型和父类(super class)型对象。 public class foo{
关闭。这个问题需要多问focused 。目前不接受答案。 想要改进此问题吗?更新问题,使其仅关注一个问题 editing this post . 已关闭 6 年前。 Improve this ques
我正在尝试查询我的用户的距离。我可以用这段代码做到这一点 PFGeoPoint.geoPointForCurrentLocationInBackground { (geoPoint: PFGe
考虑示例:http://jsfiddle.net/KWLu7/16/ 我正在尝试将总体重要性值计算为每个选定选择重要性的总和乘以其父标准重要性: var watch = $scope.$watch("
这个问题在这里已经有了答案: Bounding generics with 'super' keyword (6 个答案) 关闭 2 年前。 我有一个列表装饰器,它应该允许从一个列表转换到另一个列表
为什么下面的代码没有选择最近父类(super class)型的隐式 val? class A class B extends A trait TC[-T] { def show(t: T): Stri
这是我想要做的 def merge[A, B, C](eithers: Either[A,B]*)(implicit ev1: A x, x => x)) 关于scala - 推断常见的父类(s
我正在尝试从具有 double 类型列的Cassandra表中获取 double 值。我已经使用CQL3语法创建了表: CREATE TABLE data_double ( datetime
是否应该在不需要显式类型定义的情况下编译以下 this ? def prepList[B >: A](prefix: PlayList[B]) : PlayList[B] = prefix.fol
我正在查看某人的代码,并且在创建结构时使用了 abstract type AbstractFoo end julia> struct Foo1 struct Foo2 foo_op(x::Abst
一些示例代码: public class Main { class SomeType { } class A { protected T createSome
是否可以只接受类的泛型类型的父类(super class)型? 我正在寻找的是这样的: class MyClass { public void myMethod(TS someObject
在我的代码中,我有许多 ArrayList 被传递到排序方法中。每个 ArrayList 都有不同的泛型类型,但所有这些类型都是 Sorter 的实现。排序方法旨在接受 Sorter 类型的 Arra
如果已经有人问过这个问题,请链接并关闭这个问题。 我目前正在为另一个使用起来复杂得多(并且有潜在危险)的 API 的简化 API 设计原型(prototype)。 考虑到相关的有点复杂的对象创建,我决
我正在尝试构建一个具有某些依赖项的 android 应用程序,但是其中一个导致了此错误: Illegal class file: Class module-info is missing a supe
我是一名优秀的程序员,十分优秀!