java编程思想----泛型

最新推荐文章于 2024-09-19 22:02:23 发布
最新推荐文章于 2024-09-19 22:02:23 发布
阅读量514 收藏
点赞数
分类专栏： java编程思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuofai_/article/details/82532968
版权

泛型

一般的类和方法,只能使用具体的类型,要么是基本类型,要么是自定义的类.如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大.

简单泛型

  1. 有许多原因促成了泛型,而最引人注目的一个原因就是为了创造容器类.
  2. 泛型的主要目的之一就是用来指定容器要持有什么类型的对象,而且编译器来保证类型的正确性.
  3. 在使用泛型时,我们更喜欢暂时不指定类型,而是稍后决定具体使用什么类型,要达到这个目的,需要使用类型参数,放在类名后面.然后在使用这个类的时候.再用实际的类型替换此类型参数.在例子中T就是类型参数.类型参数简单理解就是一个类的引用
  4. 一个元组类库概念元组:它是将一组对象直接打包存储于其中的一个单一对象.这个容器对象允许读取其中元素,但是不允许向其中存放新的对象.(这个概念也称为数据传送对象或信使)
public class TwoTuple<A,B> {
    public final A first;
    public final B second;
    public TwoTuple(A a,B b){
        first = a;
        second = b;
    }
    public String toString(){
        return "(" + first + " , " + second + ")";
    }
}

上面程序的安全性:客户端程序可以读取first和second对象,然后可以随心所欲地使用这两个对象.但是它们无法将其他值赋予first或second.因为final声明为你买了相同的安全保险,而且这种格式更简洁明了.

public class LinkedStack<T> {
    public static class Node<U>{
        U item;
        Node<U> next;
        Node(){
            item = null;
            next = null;
        }
        Node(U item,Node<U>next){
            this.item = item;
            this.next = next;
        }
        boolean end(){
            return item == null && next == null;
        }
    }
    private Node<T> top = new Node<T>();//End sentinel
    public void push(T item){
        top = new Node<T>(item,top);
    }

    public T pop(){
        T result = top.item;
        if (!top.end())
            top = top.next;
        return result;
    }
    public static void main(String[] args) {
        LinkedStack<String> lss = new LinkedStack<String>();
        for (String s :
                "Phaster on stun!".split(" ")) {
            lss.push(s);
        }
        String s;
        while((s = lss.pop()) != null)
        {
            System.out.println(s);
        }
    }
}

15.3泛型接口

泛型也可以应用于接口.例如生成器(generator),这是一种专门负责创建对象的类.这是工厂方法设计模式的一种应用.不过,当生成器创建新的对象时,它不需要任何参数,而工厂方法一般需要参数.也就是说,生成器无需额外的信息就知道如何创建对象.
例:public interface Generator\ {T next();}

15.4泛型方法

要定义泛型方法,只需将泛型参数列表置于返回值之前
例:public \ void f(T x){}

  1. 是否拥有泛型方法,与其所在的类是否是泛型没有关系.
  2. 泛型方法使得该方法能够独立于类而产生变化.

原则: 无论何时,只要你能做到,就应该尽量使用泛型方法.也就是说,如果使用泛型方法可以取代将整个类泛型化,那么就应该只使用泛型方法,因为它可以使事情更清楚.另外,对于一个static的方法而言,无法访问泛型类的类型参数,所以如果static方法需要使用泛型能力,就必须使其成为泛型方法.

  1. 类型推断只对赋值操作有效,其他时候并不起作用.如果你将一个泛型方法调用的结果作为参数,传递给另一个方法,这时编译器并不会执行类型推断.这种情况下,编译器认为:调用泛型方法后,其返回值被赋给一个Object类型的变量.
public class LimitsOfInference{
    static void f(Mat<Person,List<? extends Pet>> petPeople){
    }
    public static void main(String[] args){
        //f(New.map());//Does not compile
        f(New.<Person,List<Pet>>map());//显式的类型说明,必须在点操作符之前使用this关键字,如果使用static方法,必须在点操作之前加上类名.(很少使用显式)
    }
}
  1. 一个通用的Generator
public interface Generator<T> {
    T next();
}
//可以看到只要传入一个类.class运行next方法就会创建该类的对象
//这样大大减少了我们要写的代码.java泛型要求传入Class对象,以便也可以在create()方法中用它进行类型判断
public class BasicGenerator<T> implements Generator<T> {
    private Class<T> type;
    public BasicGenerator(Class<T> type){
        this.type = type;
    }
    @Override
    public T next() {
       try {
           //Assumes type is a public class
           return type.newInstance();
       }catch (Exception e){
           throw new RuntimeException(e);
       }
    }
    public static <T> Generator<T> create(Class<T> type){
        return new BasicGenerator<>(type);
    }
}

15.5匿名内部类

15.6构造复杂模型

class Product {
  private final int id;
  private String description;
  private double price;
  public Product(int IDnumber, String descr, double price){
    id = IDnumber;
    description = descr;
    this.price = price;
    System.out.println(toString());
  }
  public String toString() {
    return id + ": " + description + ", price: $" + price;
  }
  public void priceChange(double change) {
    price += change;
  }
  public static Generator<Product> generator =
    new Generator<Product>() {
      private Random rand = new Random(47);
      public Product next() {
        return new Product(rand.nextInt(1000), "Test",
          Math.round(rand.nextDouble() * 1000.0) + 0.99);
      }
    };
}

class Shelf extends ArrayList<Product> {
  public Shelf(int nProducts) {
    Generators.fill(this, Product.generator, nProducts);
  }
}

class Aisle extends ArrayList<Shelf> {
  public Aisle(int nShelves, int nProducts) {
    for(int i = 0; i < nShelves; i++)
      add(new Shelf(nProducts));
  }
}

class CheckoutStand {}
class Office {}

public class Store extends ArrayList<Aisle> {
  private ArrayList<CheckoutStand> checkouts =
    new ArrayList<CheckoutStand>();
  private Office office = new Office();
  public Store(int nAisles, int nShelves, int nProducts) {
    for(int i = 0; i < nAisles; i++)
      add(new Aisle(nShelves, nProducts));
  }
  public String toString() {
    StringBuilder result = new StringBuilder();
    for(Aisle a : this)
      for(Shelf s : a)
        for(Product p : s) {
          result.append(p);
          result.append("\n");
        }
    return result.toString();
  }
  public static void main(String[] args) {
    System.out.println(new Store(14, 5, 10));
  }
} /* Output:
258: Test, price: $400.99
861: Test, price: $160.99
868: Test, price: $417.99
207: Test, price: $268.99
551: Test, price: $114.99
278: Test, price: $804.99
520: Test, price: $554.99
140: Test, price: $530.99
...
*///:~

正如我们在Store.toString()中看到的,其结果是许多层容器,但是它们是类型安全且安全且可管理的.

15.7擦除的神秘之处

当开始深入研究泛型时,会发现大量的东西乍看是没有意义的.例:可以声明ArrayList.class,但是不能声明ArrayList\.class

class Frob {}
class Fnorkle {}
class Quark<Q> {}
class Particle<POSITION,MOMENTUM> {}

public class LostInformation {
  public static void main(String[] args) {
    List<Frob> list = new ArrayList<Frob>();
    Map<Frob,Fnorkle> map = new HashMap<Frob,Fnorkle>();
    Quark<Fnorkle> quark = new Quark<Fnorkle>();
    Particle<Long,Double> p = new Particle<Long,Double>();
    System.out.println(Arrays.toString(
      list.getClass().getTypeParameters()));
    System.out.println(Arrays.toString(
      map.getClass().getTypeParameters()));
    System.out.println(Arrays.toString(
      quark.getClass().getTypeParameters()));
    System.out.println(Arrays.toString(
      p.getClass().getTypeParameters()));
  }
} /* Output:
[E]
[K, V]
[Q]
[POSITION, MOMENTUM]
*///:~

在泛型代码内部,无法获得任何有关泛型参数类型的信息.
你可以知道诸如类型参数标识符和泛型类型边界这类的信息–你却无法知道用来创建某个特定实例的实际的类型参数.
java泛型是使用擦除来实现的,这意味着当你在使用泛型时,任何具体的类型信息都被擦除了,你唯一知道的就是你在使用一个对象.因此List\和List\在运行时事实上是相同类型.这两种形式都被擦除成它们的”原生”类型,即List.

  1. 迁移兼容性:因为泛型不是在Java1.0中的一部分,所以需要擦除来实现.擦除减少了泛型的泛化性.
  2. 在基于擦除的实现中,泛型类型被当做第二类型处理,即不能在某些重要的上下文环境中使用类型,泛型类型只有在静态类型检查期间才出现.在此之后程序中的所有泛型类型都将被擦除,替换为它们的非泛型上界.例如List\这样的类型注解将被擦除为List,而普通的类型变量在未指定边界的情况下将被擦除为Object
  3. 擦除的核心动机是它使得泛化的刻画短可以使用非泛化的类库来使用.反之亦然.被称为”迁移兼容性”
  4. 通过允许非泛型代码和泛型代码共存,擦除使得这种向着泛型的迁移称为可能.
  5. 擦除的问题:擦除的代价是显著的.泛型不能用于显式地引用运行时类型的操作之中,例如转型instanceof操作和new表达式.因为关于参数的类型信息都丢失了.
  6. 使用在编写泛型代码时,必须时刻提醒自己,你只是看起来好像拥有有关参数的类型信息而已.
//由于上面的原因尽可能这样写代码.不要直接写出具体类型
class GenericBase<T> {
    private T element;
    public void set(T arg){arg = element;}
    public T get(){return element;}
}
class Derived1<T> extends GenericBase<T>{}
class Derived2 extends GenericBase{}//No waring
//class Derived3 extends GenericBase<?>{}
//Strange error;
//  unexpected type found:?
//  required: class or interface without bounds

public class ErasureAndInheritance {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        Derived2 d2 = new Derived2();
        Object obj =  d2.get();
        d2.set(obj);
    }
}
//擦除相等版(所产生的字节码是相同的)对进入set()的类型检查是不需要的因为这将由编译器执行.
//由于所产生的get()和set()字节码相同,所以在泛型中的所有动作都发生在边界处--对于传进来的值进行额外的编译期检查,并插入对传递出去的值的转型.
//这有助于澄清对擦除的混淆,记住,"边界就是发生动作的地方".
public class SimpleHolder {
    private Object obj;
    public void set(Object obj){
        this.obj = obj;
    }
    public Object get(){
        return obj;
    }

    public static void main(String[] args) {
        SimpleHolder holder = new SimpleHolder();
        holder.set("Item");
        String s = (String )holder.get();
    }
}


public class GenericHolder<T> {
    private T obj;
    public void set(T obj){this.obj = obj;}
    public T get() {return obj;}

    public static void main(String[] args) {
        GenericHolder <String> holder =
                new GenericHolder<>();
        holder.set("Item");
        String s = holder.get();
    }
}

15.8擦除的补偿

擦除丢失了泛型代码中执行某些操作的能力.任何在运行时需要知道确切类型信息的操作都将无法工作
有时必须通过引入类型标签来对擦出进行补偿. 

//把两个代码中有用的内容拿出来比较
public class GenericArray<T> {
    private T[] array;
    @SuppressWarnings("unchecked")
    public GenericArray(int sz){
        array = (T[])new Object[sz];
    }
}


public class GenericArray2<T> {
    private Object[] array;
    public GenericArray2(int sz){
        array = new Object[sz];
    }
    public void put(int index,T item){
        array[index] = item;
    }
    @SuppressWarnings("unchecked")
    public T get(int index){
        return (T)array[index];
    }
    @SuppressWarnings("unchecked")
    public T[] rep(){
        return (T[])array;//Warning: unchecked cast
    }
}
  1. 初看起来,这好像没有什么变化,只是转型挪了地方.如果没有\@SuppressWarnings注解,仍旧会得到unchecked警告,但是,现在的内部表示是Object[]而不是T[].
  2. 当get()被调用时,他将对象转型为T,这实际上是正确的类型,因此这是安全的.然而如果你调用rep(),它还是尝试着将Object[]转型为T[],这仍旧是不正确的,将在编译期产生警告,在运行时产生异常.因此没有任何方式可以推翻底层的数组类型,他只能是Object[].在内部将array当作Object[]而不是T[]处理的优势时:我们不太可能忘记这个数组的运行时类型,从而意外地引入缺陷(尽管大多数也可能是所有这类缺陷都可以在运行时快速地检测到)

个人理解补充:下面这样的程序是错误的不能创建泛型数组,如果T没有无参构造的话这样建立对象是错误的方法

public class Erased<T> {
  private final int SIZE = 100;
  public static void f(Object arg) {
    if(arg instanceof T) {}          // Error
    T var = new T();                 // Error
    T[] array = new T[SIZE];         // Error
    T[] array = (T)new Object[SIZE]; // Unchecked warning
  }
} ///:~

15.9边界

边界使得你可以在用于泛型的参数类型上设置限制条件.尽管这使得你可以强制规定泛型可以引用的类型,但是潜在的一个更重要的效果是你可以按照自己的边界类型来调用方法.
因为擦除移除了类型信息,所以,可以用无界泛型参数调用的方法只是那些可以用Object调用的方法.为了执行能够将这个参数限制为某个类型的子集,从而用这些类型子集来调用方法.Java泛型重用了extends关键字.
注意:要理解extends关键字在泛型边界上下文环境中和在普通情况下所具有的意义是完全不同的.

interface HasColor{java.awt.Color getColor();}
class Colored<T extends HasColor>{
    T item;
    Colored(T item){this.item = item;}
    T getItem(){return item;}
    //The bound allows you to call a method;
    java.awt.Color color(){return item.getColor();}
}

//在继承的每个层次上添加边界限制
class HoldItem<T>{
    T item;
    HoldItem (T item){this.item = item;}
    T getItem() {return item;}
}
class Colored2<T extends HasColor> extends HoldItem<T>{//()中的extends声明了边界,后面的extends继承了HoldItem<T>继承了T然后在T的基础上前面的extends边界会做一个判断所以也就是在继承边界的基础上又添加了一个边界
    Colored2(T item){super(item);}
    java.awt.Color color(){return item.getColor();}
}

15.10通配符

class Fruit{}
class Apple extends Fruit{}
class Jonathan extends Apple{}
class Orange extends Fruit{}
public class CovarianArrays {
    public static void main(String[] args) {
        Fruit[] fruit  = new Apple[10];
        fruit[0] = new Apple();
        fruit[1] = new Jonathan();
        //Runtime type is Apple[],not Fruit[] or Orange[]
        try {
            //所以这里的向上转型是不合适的
            //Compiler allows you to add Fruit:
            fruit[0] = new Fruit();

        }catch (Exception e){
            System.out.println(e);
        }
        try {
            //Compiler allows you to add Oranges;
            fruit[0] = new Orange();

        }catch (Exception e){
            System.out.println(e);
        }
    }
}

上面程序注释向上转型是不合适的

  1. 与数组不同,泛型没有内建的协变类型.这是因为数组在语言中是完全定义的,因此可以内建了编译和运行时的检查,但是在使用泛型时,编译器和运行时系统都不知道你想用什么类型做些什么,以及该采用什么样的规则.想要在两个类型之间建立某种类型的向上转型关系,这正是通配符所允许的.
public class GenericsAndCovariance {
    public static void main(String[] args) {
        //Wildcards allow covariance
        List<? extends Fruit> flist = new ArrayList<Apple>();
//        flist.add(new Apple());
//        flist.add(new Fruit());
//        flist.add(new Object());
        flist.add(null);
        //We know that it returns at least Fruit:
        Fruit f = flist.get(0);
    }
}
  1. List\
//总结性代码并注意英文注释
public class Holder<T> {
  private T value;
  public Holder() {}
  public Holder(T val) { value = val; }
  public void set(T val) { value = val; }
  public T get() { return value; }
  public boolean equals(Object obj) {
    return value.equals(obj);
  }
  public static void main(String[] args) {
    Holder<Apple> Apple = new Holder<Apple>(new Apple());
    Apple d = Apple.get();
    Apple.set(d);
    // Holder<Fruit> Fruit = Apple; // Cannot upcast
    Holder<? extends Fruit> fruit = Apple; // OK
    Fruit p = fruit.get();
    d = (Apple)fruit.get(); // Returns 'Object'
    try {
      Orange c = (Orange)fruit.get(); // No warning
    } catch(Exception e) { System.out.println(e); }
    // fruit.set(new Apple()); // Cannot call set()
    // fruit.set(new Fruit()); // Cannot call set()
    System.out.println(fruit.equals(d)); // OK
  }
} /* Output: (Sample)
java.lang.ClassCastException: Apple cannot be cast to Orange
true
*///:~
  1. 调用get(),它只会返回一个Fruit–这就是在给定”任何扩展自Fruit的对象”这一边界之后,它所能知道的一切了.
  2. set()方法不能工作于Apple或Fruit,因为set()参数也是”?Extends Fruit”,这意味着它可以是 任何事物,而编译器无法验证”任何事物“的类型安全性.
  3. 但是,equals()方法工作良好,因为它将接受Object类型而并非T类型的参数.因此编译器只关注传递进来和要返回的对象类型,他并不会分析代码,以查看是否执行了任何实际的写入和读取操作.

逆变

  1. 调用get(),它只会返回一个未知对象,这意味着它可以是 任何事物,而编译器无法验证”任何事物“的类型安全性.只能用Object来接收get对象
  2. set()方法能工作于Apple或Fruit,因为set()参数是”? super Fruit”,”任何扩展自Fruit的对象”这一边界之后,它所能知道的一切了.

无界通配符

\

Java编程思想-泛型
极客栈
01-15 353
package com.jzg.thinkingInJava.test.T; public interface Performs { void speak(); void sit(); } package com.jzg.thinkingInJava.test.T; import com.jzg.tingkingInJava.test.RTTI.typeinfo.Dog...
Java基础 -- 04泛型＜T＞
热门推荐
mmlz00的博客
12-20 1万+
目录 泛型概念： 泛型种类： 泛型接口 泛型类 泛型方法 普通泛型方法 静态泛型方法 泛型构造函数 泛型进阶： 泛型通配符 泛型上界 泛型下界 泛型擦除 泛型注意事项 泛型的用法: 泛型的示例: 高阶篇 泛型概念： 没有JDK5问世以前的老代码： 先看第1个小示例：Integer类型...
Java学习笔记（十二）：泛型的使用
汤圆学Java
08-17 736
来源：http://www.cnblogs.com/lwbqqyumidi/p/3837629.htmlJava总结篇系列：Java泛型 一. 泛型概念的提出（为什么需要泛型）？ 首先，我们看下下面这段简短的代码:public class GenericTest { public static void main(String[] args) { List list = ne
Java中的泛型详解
最新发布
2302_77756558的博客
09-19 1038
泛型允许我们定义类、接口或方法时使用类型参数。换句话说，泛型使得数据类型可以延迟到实例化时再指定。泛型提供了编译时的类型检查，从而避免了在运行时进行不安全的强制类型转换。在这个类中，T是一个类型参数，代表类中可以持有任何类型的数据。在使用Box类时，可以指定T的具体类型。K getKey();
Java编程思想之泛型（上）
我与风来
09-03 392
简单泛型 泛型方法 泛型接口 元组 擦除 擦除的补偿 泛型数组
Java编程思想之泛型
qq_33403693的博客
08-16 406
1.     泛型实现了参数化类型的概念，意思是适用于许多许多的类型。在创建参数化类型的一个实例时，编译器会负责转型操作，并保证类型的正确性。 2.     泛型的主要目的之一是用来指定容器要持有什么类型的对象，而且由编译器来保证类型的正确性。 3.     泛型类的格式：类名后面跟尖括号，尖括号里放入类型参数。 4.     元组用来将一组对象直接打包存储于某一个单一对象中。这个容器对象运
Java中的泛型 --- Java 编程思想
weixin_30919919的博客
03-01 451
前言 ​ 我一直都认为泛型是程序语言设计中一个非常基础，重要的概念，Java 中的泛型到底是怎么样的，为什么会有泛型，泛型怎么发展出来的。通透理解泛型是学好基础里面中非常重要的。于是，我对《Java编程思想》这本书中泛型章节进行了研读。可惜遗憾的是，自己没有太多的经验，有些东西看了几次也是有点懵。只能以后有机会，再进行学习了。但是自己也理解了挺多的。下面就是自己对于泛型的理解与感悟。如有不对，望指...
Java编程思想-笔记.docx
06-21
Java编程思想笔记 本笔记涵盖了Java编程思想的多个方面，包括访问权限控制、封装、继承、多态、接口、内部类、持有对象等。 访问权限控制 访问权限控制是为了把变动的事物与保持不变的事物区分开来。Java中有四种...
thinking-in-java-zh:Java 编程思想
05-14
在Java编程思想中，读者可以学习到以下关键知识点： 1. **基础语法**：包括变量、数据类型、运算符、流程控制（如if语句、switch语句、循环）、方法、类和对象等基本元素。这些是所有Java程序员必须掌握的基础。 2...
《java编程思想》_java编程思想_java编程思想_ThinkinginJava_mileefx_
10-03
《Java编程思想》是Java程序员领域的一本经典之作，由Bruce Eckel撰写，以其深入浅出的讲解方式和丰富的实例闻名。这本书对于想要深入理解Java语言的人来说，是一份宝贵的资源。"Thinking in Java"，直译为“思考...
Java泛型编程思想
来了点个赞再走...
05-05 839
每天进步一点点什么是泛型自定义泛型类通配符泛型方法泛型的嵌套使用 什么是泛型 JDK1.5之后出现的新技术泛型(Generic),此技术的最大特点是类中的属性的类型可以由外部决定，泛型即“参数化类型”，一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在调用时传入具体的类型（类型实参） 自定义泛型类 在泛型接口中、泛型类和泛型方法的定义过程中，我们常见的如T、E
Java编程思想 泛型总结
勤劳的搬运工
09-27 408
一般的类和方法 只能使用具体的类型 要么是基本类型 要么是自定义的类 如果要编写可以应用于多种类型的代码 这种刻板的限制对代码的束缚就会很大 与C++的比较 Java中的泛型就需要与C++进行一番比较 理由有二 首先 了解C++模板的某些方面 有助于你理解泛型的基础 同时 非常重要的一点是 你可以了解Java泛型的局限是什么 以及为什么会有这些限制 最终的目的是帮助你理解 Java泛型的边界在哪里...
《Java编程思想》第15章 泛型
qq_43783527的博客
07-31 619
确实能够具备更好的灵活性。但是，考虑到除了final类不能扩展，其他任何类都可以被扩展，所以这种灵活性大多数时候也会有一些性能损耗。而我们希望达到的目的是编写更通用的代码，要使代码能够应用于“某种不具体的类型”，而不是一个具体的接口或类。这样的方法更加通用一些，可应用的地方也多一些。在类的内部也是如此，因为任何实现了该接口的类都能够满足该方法，这也包括暂时还不存在的类。这就是JavaSES的重大变化之一泛型的概念。泛型实现了参数化类型的概念，使代码可以。要求你的代码必须使用特定的接口。...........
java编程思想--15泛型
06-25 246
有时方法调用需返回多个对象，你应该经常需要这样的功能吧。可是return语句只允许返回单个对象，因此，解决办法就是创建一个对象，用它来持有想要返回的多个对象。当然，可以在每次需要的时候，专门创建一个类来完成这样的工作。可是有了泛型，我们就能够一次性地解决该问题。同时，我们在编译期就能确保类型安全。这些携带多个返回结果的对象我们称之为容器，它是将一组返回结果对象直接打包存储于其中的一个单一对象中，这...
Java 泛型详解
weixin_34268610的博客
08-25 235
2019独角兽企业重金招聘Python工程师标准>>> ...
java编程思想读书笔记 第十五章 泛型 （泛型方法）
abc709272013的博客
10-21 908
泛型方法 首先需要知道的是，可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是否是泛型没有关系。泛型方法使得该方法能够独立于类而产生变化。一个基本原则是：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个 stat
Java编程思想 第十五章 泛型
name_sakura的博客
07-08 567
无
Java编程思想—泛型(1)
Coder_py的博客
01-07 188
Java编程思想—泛型(1) 泛型 简单使用 三个Holder进行对比，引出类型参数的概念 public class Apple { } public class Holder_1 { // 明确指定持有的对象 private Apple apple; public Holder_1(Apple apple) { this.apple = apple;...
Java编程思想入门与高级技巧解析
《Java编程思想读书笔记》是一本面向Java初学者和高级编程人员的实用指南，它深入探讨了Java编程的关键概念与特性，特别是针对那些希望提升编程技能或深化理解Java语言的读者。本书主要涵盖了以下几个重要的知识点：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值