Java基础 - 泛型 - 结业笔记

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量394 收藏
点赞数
分类专栏： 笔记 成长阶段 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39123467/article/details/122423010
版权

文章目录

泛型的语法

泛型的声明

interface 接口 {}和 class 类 <K,V>{}

//比如：List，ArrayList

说明：

  1. 其中：T，K，V不代表值，而是表示类型
  2. 任意字母都可以。常用T表示，是Type的缩写

泛型使用的注意事项和细节

interface List<T>{}
public class HashSet<E>{}
  1. T,E 只能是引用类型
  • 看看下面语句是否正确？
List<Integer> list = new ArrayList<Integer>();	//ok
List<int> list2 = new ArrayList<int>();			//error，int是基本数据类型
  1. 在指定泛型具体类型后，可以传入该类型或者其子类类型
  2. 泛型使用形式
List <Integer> list1 = new ArrayList<Integer>();
List <Integer> list2 = new ArrayList<>();
  1. 如果我们这样写
List list3 = new ArrayList();

默认给它的 泛型是[E 就是 Object]

package com.tao.generic_;

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

/**
 * Create By 刘鸿涛
 * 2022/1/11 1:20
 */
public class GenericDetail {
    public static void main(String[] args) {
        Pig<A> pig = new Pig<A>(new A());   //A作为Pig的泛型
        pig.show();
        Pig<A> pig2 = new Pig<A>(new B());  //因为B继承A
        pig2.show();

        //3.泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();

        //在实际开发中，我们往往简写
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //4.如果是这样写，泛型默认是 Object
        ArrayList arrayList = new ArrayList();
        //     ||||||||
        ArrayList<Object> arrayList1 = new ArrayList();
        

    }
}
class A{

}
class B extends A{

}
class Pig<E>{
    E e;
    public Pig(E e){
        this.e = e;
    }

    public void show(){
        System.out.println(e.getClass());
    }
}

泛型的实例化

要在类名后面指定类型参数的值（类型）。如：

  1. List strList = new ArrayList();
  2. Iterator iterator = customers.iterator();

泛型应用实例

创建 3个学生对象

放入到HashSet中学生对象，使用.

放入到 HashMap中，要求 Key 是String name，Value 就是 学生对象

使用两种方式遍历

请添加图片描述

package com.tao.generic_;

import java.util.*;

/**
 * Create By 刘鸿涛
 * 2022/1/11 0:06
 */
@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("刘刘",20));
        students.add(new Student("涛涛",40));
        students.add(new Student("汤姆",50));

        System.out.println("---增强for遍历---");
        for (Student o:students){
            System.out.println(o);
        }

        //使用泛型方式
        HashMap<String,Student> map = new HashMap<String,Student> ();
        map.put("刘刘",new Student("刘刘",20));
        map.put("涛涛",new Student("涛涛",40));
        map.put("汤姆",new Student("汤姆",50));
        //迭代器 EntrySet
        Set<Map.Entry<String,Student>> entries = map.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());
        }
    }
}

/**
 *  创建 3个学生对象
 *  放入到HashSet中学生对象，使用.
 *  放入到 HashMap中，要求 Key 是String name，Value 就是 学生对象
 *  使用两种方式遍历
 */
class Student {
    String name;
    int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return name + "," + age;
    }
}

泛型课堂练习

  • 定义Employee类
  1. 该类包含：private成员变量name，sal，brithday，其中birthday 为 MyDate 类的对象；
  2. 为每一个属性定义 getter，setter 方法；
  3. 重写 toString 方法输出 name，sal，birthday
  4. MyDate类包含：private成员变量month，day，year；并为每一个属性定义getter，setter 方法；
  5. 创建该类的 3个对象，并把这些对象放入 ArrayList 集合中（ArrayList 需使用泛型来定义），对集合中的元素进行排序，并遍历输出；
  • 排序方式：调用ArrayList 的sort 方法，传入 Comparator对象[使用泛型]，先按照name排序，如果那么相同，则按生日日期的先后排序。
package com.tao.generic_;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * Create By 刘鸿涛
 * 2022/1/11 1:46
 */
public class HomeWork01 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<Employee>();
        employees.add(new Employee("刘刘", 10, new MyDate(2000, 10, 10)));
        employees.add(new Employee("刘刘", 10, new MyDate(2001, 11, 11)));
        employees.add(new Employee("刘刘", 10, new MyDate(1999, 12, 12)));
        System.out.println(employees);
        System.out.println("==对员工进行排序==");
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee emp1, Employee emp2) {
                //先按照 name 排序，如果name相同，则按生日日期的先后排序。[定制排序]
                //先对传入的参数进行验证
                if(!(emp1 instanceof Employee && emp2 instanceof Employee)){
                    System.out.println("类型不正确");
                    return 0;
                }
                //比较name
                int i = emp1.getName().compareTo(emp2.getName());
                if(i != 0){
                    return i;
                }

                //下面是对birthday的比较，因此，我们最好把这个比较，放在MyDate类完成
                //封装后，将来可维护性和复用性，就大大提高
                return emp1.getBirthday().compareTo(emp2.getBirthday());
            }
        });
        System.out.println(employees);

    }
}

class Employee {
    private String name;
    private int sal;
    private MyDate birthday;

    public Employee(String name, int sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSal() {
        return sal;
    }

    public void setSal(int sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    public int compareTo(MyDate o){
        //如果name 相同，就比较 birthday 、 year
        int yearMinus = year - o.getYear();
        if (yearMinus != 0){
            return yearMinus;
        }
        //如果year 相同，就比较 month
        int monthMinus = month - o.getMonth();
        if (monthMinus != 0){
            return monthMinus;
        }
        return 0;
    }
}

自定义泛型

基本语法

class 类名<T,R...>{	//...表示可以有多个泛型
	成员
}

注意细节

  1. 普通成员可以使用泛型（属性，方法）
  2. 使用泛型的数组，不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）
  5. 如果在创建对象时，没有指定类型，默认为Object
package com.tao.generic_.customgeneric;


/**
 * Create By 刘鸿涛
 * 2022/1/11 2:36
 */
public class Customgeneric {
    public static void main(String[] args) {
        Tiger<String, Double, Object> taotao = new Tiger<String, Double, Object>("taotao");
        taotao.setR(4.0);   //Double
        taotao.setM(11.0);  //Object
        taotao.setT("f");   //String
        System.out.println(taotao);
    }
}
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2. T，R，M 泛型的标识符，一般是单个大写字母
//3. 泛型标识符可以有多个
//4. 普通成员可以使用泛型（属性、方法）
//5. 使用泛型的数组，不能初始化
//6. 静态方法不能使用泛型
class Tiger<T,R,M>{
    String name;
    R r;
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开辟空间
//    T[] ts = new T[8];  //error
    public Tiger(String name){
        this.name = name;
    }
    public Tiger( R r, M m, T t) {
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;                     //error
//    public static void m1(M m){}    //error

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {   //方法使用泛型
        return r;       //返回值为泛型
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                '}';
    }
}

自定义泛型接口

基本语法

interface 接口名 <T,R...>{

}

注意细节

  1. 接口中，静态成员也不能使用泛型（这个和泛型类规定一样）
  2. 泛型接口的类型，在继承接口或者实现接口时确定
  3. 没有指定类型，默认为Object
interface A<A,B>{

}
interface B extends A<String,Double>{   //确定父类接口中的泛型类型，如果没有指定，默认Object
 
}


package com.tao.generic_.customgeneric;

/**
 * Create By 刘鸿涛
 * 2022/1/11 5:14
 */
public class CustomInterfaceGeneric {
    public static void main(String[] args)  {

    }
}

/**
 *
 *  泛型接口使用的说明
 *  1.接口中，静态成员也不能使用泛型
 *  2.泛型接口的类型，在继承接口或者实现接口时确定
 */
//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String,Double>{

}
//当我们去实现IA接口时，因为IA在继承IUsu接口时，指定了U 为String R为Double,
//在实现IUsu接口的方法时，使用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) {

    }

    @Override
    public Double method(String s) {
        return IA.super.method(s);
    }
}

//实现接口时，直接指定泛型接口的类型
//给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) {

    }
}
interface IUsb<U, R>{

    int n = 10;
    //U name = "taotao";   //error，不能这样使用
    //普通方法中，可以使用接口泛型
    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;
    }
}
//没有指定类型，默认为Object
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) {

    }
}

自定义泛型方法

基本语法

修饰符 <T,R...>返回类型 方法名(参数列表){

}

注意细节

  2. 当泛型方法被调用时，类型会确定

  3. public void eat(E e){}
//修饰符后没有<T,R...>eat方法不是泛型方法，而是使用了泛型

泛型方法练习

package com.tao.generic_.customgeneric;

/**
 * Create By 刘鸿涛
 * 2022/1/11 17:56
 */
public class CustomGenericMethodExercise {
    public static void main(String[] args) {
        Apple<String,Integer,Double>apple = new Apple<>();
        apple.fly(10);      //Integer
        apple.fly(new Dog());   //Dog
    }
}
class Apple<T,R,M>{
    public<E> void fly(E e){
        //getClass()运行类型或者包名，getSimpleName()类的简写名称
        System.out.println(e.getClass().getSimpleName());
    }
    public void eat(R r){}
    public void run(M m){}
}
class Dog{


}

泛型继承和通配

  1. 泛型不具备继承性

List list = new ArrayList(); //error

  1. <?>：支持任意泛型类型
  2. <? extends A>：支持A类以及A类的子类，规定了泛型的上限
  3. <？super A>：支持A类以及A类的父类，不限于直接父类，规定了泛型的下限
package com.tao.generic_.customgeneric;

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

/**
 * Create By 刘鸿涛
 * 2022/1/11 18:22
 */
public class GenericExercise {
    public static void main(String[] args) {
        //泛型没有继承性
        //ArrayList<Object> a = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<A> list3 = new ArrayList<>();
        List<B> list4 = new ArrayList<>();
        List<C> list5 = new ArrayList<>();

        //如果是 List<?>c,可以接收任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends A> c       表示 上限，可以接收 A或者 A子类
//        printCollection2(list1);      //Object error
//        printCollection2(list2);      //String error
        printCollection2(list3);
        printCollection2(list4);
        printCollection2(list5);

        printCollection3(list1);        //A的父类
//        printCollection3(list2);      //String error
        printCollection3(list3);        //A类
//        printCollection3(list4);      //B类 error
//        printCollection3(list5);      //C类 error

    }

    //编写几个方法
    //说明：List <?> 表示 任意的泛型类型都可以接收
    public static void printCollection1(List<?> c) {
        for (Object o : c) { //通配符，取出时，就是Object
            System.out.println(o);

        }
    }

    //？ extends A 表示 上限，可以接收 A或者 A子类
    public static void  printCollection2(List<? extends A> c){
        for (Object o : c){
            System.out.println(o);
        }
    }

    // ? super 子类类名AA：支持AA类以及AA类的父类，不限于直接父类
    //规定了泛型的下限
    public static void printCollection3(List<? super A> c){
        for (Object o : c){
            System.out.println(o);
        }
    }
}

class A {

}

class B extends A {

}

class C extends B {

}

JUnit使用

  • 为什么需要JUnit
  1. 一个类有很多功能代码需要测试，为了测试，就需要写入到main方法中
  2. 如果有多个功能代码测试，就需要来回注销，切换很麻烦
  3. 如果可以直接运行一个方法，就方便很多，并且可以给出相关信息，就好了 -> JUnit

请添加图片描述

  • Alt + Enter导入包

请添加图片描述

泛型课堂练习2

编程题 Homework01

 package com.tao.generic_.homeword;

import org.testng.annotations.Test;

import java.util.*;

/**
 * Create By 刘鸿涛
 * 2022/1/11 19:16
 */
public class Homework01 {
    public static void main(String[] args) {

    }

    @Test
    public void testList(){
        //说明
        //这里我们给T 指定类型是User
        DAO<User> dao = new DAO<>();
        dao.save("001",new User(1,10,"jack"));
        dao.save("002",new User(2,18,"king"));
        dao.save("003",new User(3,38,"smith"));

        List<User> list = dao.list();

        System.out.println("list = " + list);

        dao.update("003",new User(3,58,"milan"));
        //更新数据后
        System.out.println(dao.list());

        System.out.println("id=03" + dao.get("003"));   //milan
    }
}
class DAO<T>{
    private Map<String,T> map = new HashMap<String,T>();
    //保存T类型的对象到 Map 成员变量中
    public void save(String id,T entity){
        map.put(id, entity);
    }
    //从 map中获取 id 对应的对象
    public T get(String id){
        return map.get(id);
    }
    //替换 map 中key为 id的内容，改为 entity对象
    public void update(String id,T entity){
        map.put(id, entity);
    }
    //返回map 中存放的所有T 对象
    //遍历map[k - v] ， 将map的所有value（T entity），封装到ArrayList返回即可
    public List<T> list(){
        //创建 ArrayList
        List<T> list = new ArrayList<>();

        //遍历map
        Set<String> keySet = map.keySet();
        for (String o : keySet){
            //map.get(o) 返回就是User 对象 -> ArrayList
            list.add(map.get(o));   //list.add(get(o));
        }
        return list;
    }
    //删除指定id对象
    public void delete(String id){
        map.remove(id);
    }

}
class User{
    private int id,age;
    private String name;

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

泛型结论

一句话搞定泛型

  • 泛型就是一种可以接收数据类型的数据类型！！
鬼鬼骑士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java重点--泛型
YOU__FEI的博客
10-01 2367
定义一个含有泛型的类，模拟ArrayList集合泛型是一个未知的数据类型，当我们不确定什么什么数据类型的时候，可以使用泛型泛型可以接收任意的数据类型，可以使用Integer,String,Student…创建对象的时候确定泛型的数据类型好处 ：类型不写死，创建对象泛型是什么类型，类中泛型就是什么类型首先定义一个含有泛型的类public class 含有泛型的类 < E > {} //所有使用数据类型的时候，都使用了泛型E }接着就可以在主方法中使用它了public class 主方法 {
java泛型实例化_java基础-泛型举例详解
weixin_39843215的博客
02-20 1069
泛型泛型是JDK5.0增加的新特性，泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数。这种类型参数可以在类、接口、和方法的创建中，分别被称为泛型类、泛型接口、泛型方法。一、认识泛型在没有泛型之前,通过对类型Object的引用来实现参数的"任意化",但"任意化"带来的缺点是需要显示的强制类型转换,此种转换要求开发者对实际参数类型预知的情况下进行,对于强制转换错误的情况,编译器可能不会提示错...
Java 基础 - 泛型
Liarboy
09-09 2053
这种方法可以解决开始遇到的问题，编译器知道类型参数的范围，如果传入的实例类型B是在这个范围内的话允许转换，这时只要一次类型转换就可以了，运行时会把对象当做A的实例看待。在使用泛型的时候，我们可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。擦除方法定义中的类型参数原则和擦除类定义中的类型参数是一样的，这里仅以擦除方法定义中的有限制类型参数为例。当类定义中的类型参数存在限制（上下界）时，在类型擦除中替换为类型参数的上界或者下界，比如形如。
（46）Java基础 --泛型
kulr_w的博客
03-04 1141
一、泛型的概述 定义 广泛的类型，在定义一个类的时候，类型中有些方法参数、返回值类型不确定，就使用一个符号，来表示那些尚未确定的类型，这个符号，就称为泛型。 使用 对于有泛型的类型，在这些类型后面跟上尖括号，尖括号里面写上泛型的确定类型（在使用某个类创建对象时，已经可以确定这个具体的类型了，那么就直接写出具体类型）。 例如：List<Integer> al = new ArrayList<Integer>(); 泛型的好处 ...
JAVA---泛型
weixin_56777219的博客
01-10 2390
JAVA---泛型
Java基础-泛型
ww741258963123的博客
06-15 1167
Java基础-泛型 1、什么是泛型 ​ 泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例 如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即 传入实际的类型参数，也称为类型实参）。 泛型是一种参数化类型。 2、泛型的使用规则 泛型是JDK5.0出现，在之前的版本中是不能使用的； 泛型是需要写在一对<>中的； 泛型的类型必须是引用类型，不能是基本数据类型；如果是基本数据 类型，必须使用其包装类。 如果有多个
Java基础-泛型与set
爪蛙毁一生的博客
02-07 1830
泛型的介绍​ 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制泛型的好处把运行时期的问题提前到了编译期间避免了强制类型转换泛型的定义格式: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如:: 指定多种类型的格式,多种类型之间用逗号隔开.例如: 不可以存储重复元素没有索引,不能使用普通for循环遍历不可以存储重复元素没有索引可以将元素按照规则进行排序。
java-泛型-参数
weixin_57830401的博客
02-20 1320
泛型类： 定义格式 修饰符 class 类名<类型> { } 示例代码 泛型类 public class Generic<T> { private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } } 测试类 public class GenericDemo { public stati.
Java----泛型与集合
m0_64063877的博客
03-19 3322
Java----泛型与集合一、泛型二级目录三级目录 一、泛型 1、泛型的安全机制 泛型作用：强制了集合存储固定的数据类型 2、书写格式 //集合类<> 3、泛型的好处 ①安全性提高了 ②程序代码量减少 ③避免了强制类型转换 ④程序的问题提前到了运行前 4、泛型中的E E没有实际价值，只是一个变量 特殊：等待接收指定的数据类型 ArrayList<String> ar = new ArrayList<String>(); //此时E变成String类型 5、自定
JAVA泛型-泛型方法的定义和使用
热门推荐
northcastle的博客
10-23 5万+
1.泛型方法的定义和语法 1.1 定义 泛型方法 是在调用方法的时候指明泛型的具体类型。 【泛型方法 能够使方法独立于类的处理指定的类型。】 1.2 语法 修饰符 <T,E,…> 返回值类型 方法名（形参列表）{ 。。。。。。 } 修饰符与返回值类型中间的 泛型标识符 <T,E,…>,是 泛型方法的标志，只有这种格式声明的方法才是泛型方法。 泛型方法声明时的 泛型标识符 <T,E,…> 表示在方法可以使用声明的泛型类型。 与泛型类相同，泛型标识符可以是任意类
java基础-泛型学习总结
03-12
思维导图
java基础-泛型通配符
03-12
java基础-泛型通配符
大学课程讲义-Java基础-泛型.docx
08-14
大学课程讲义_Java基础_泛型.docx
8-java进阶-泛型1
08-03
相当于一个标签，声明我这里只能放什么样的数据类型泛型里面只能放类，所以基本数据类型要转换成包装类如果实例化的过程中没有指明数据类型，则默认为object表示：
JAVA-泛型课件-泛型课件
05-11
个人制作且上课使用的课件，希望对大家初步了解泛型相关内容有一定的帮助。个人制作且上课使用的课件，希望对大家初步了解泛型相关内容有一定的帮助。
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1474
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 954
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 985
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 780
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java基础(十二 )-----Java泛型详解
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鬼鬼骑士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值