java代码有没有泛型 java 泛型编程

JAVA中的泛型类是什么东西？

在Java SE1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。 1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。3、泛型的类型参数可以有多个。4、泛型的参数类型可以使用extends语句，例如Textends superclass。习惯上成为“有界类型”。5、泛型的参数类型还可以是通配符类型。例如Class? classType =Class.forName(java.lang.String);

java中的泛型 求详细解释

1、Java泛型

其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Generics＜K,V＞，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子：

//code list 1

import Java.util.Hashtable;

class TestGen0＜K,V＞{

　public Hashtable＜K,V＞ h=new Hashtable＜K,V＞();

　public void put(K k, V v) {

h.put(k,v);

　}

　public V get(K k) {

return h.get(k);

　}

　public static void main(String args[]){

TestGen0＜String,String＞ t=new TestGen0＜String,String＞();

t.put("key", "value");

String s=t.get("key");

System.out.println(s);

　}

}

正确输出:value

这只是个例子（Java中集合框架都泛型化了，这里费了2遍事.），不过看看是不是创建一个用类型作为参数的类，参数是K，V，传入的“值”是String类型。这个类他没有特定的待处理型别，以前我们定义好了一个类，在输入输入参数有所固定，是什么型别的有要求，但是现在编写程序，完全可以不制定参数的类型，具体用的时候来确定，增加了程序的通用性，像是一个模板。

呵呵，类似C++的模板（类似）。

1.1. 泛型通配符

下面我们先看看这些程序：

//Code list 2

void TestGen0Medthod1(List l) {

　for (Object o : l)

System.out.println(o);

}

看看这个方法有没有异议，这个方法会通过编译的，假如你传入String，就是这样List＜String＞。

接着我们调用它,问题就出现了，我们将一个List＜String＞当作List传给了方法，JVM会给我们一个警告，说这个破坏了类型安全，因为从List中返回的都是Object类型的，而让我们再看看下面的方法。

//Code list 3

void TestGen0Medthod1(List＜String＞ l) {

　for (Object o : l)

System.out.println(o);

}

因为这里的List＜String＞不是List＜Object＞的子类,不是String与Object的关系，就是说List＜String＞不隶属于list＜Object＞,他们不是继承关系，所以是不行的，这里的extends是表示限制的。

类型通配符是很神奇的，List＜?＞这个你能为他做什么呢?怎么都是“？”，它似乎不确定，他总不能返回一个？作为类型的数据吧，是啊他是不会返回一个“？”来问程序员的？JVM会做简单的思考的，看看代码吧，更直观些。

//code list 4

List＜String＞ l1 = new ArrayList＜String＞();

li.add(“String”);

List＜?＞ l2 = l1;

System.out.println(l1.get(0));

这段代码没问题的，l1.get(0)将返回一个Object。

1.2. 编写泛型类要注意：

1) 在定义一个泛型类的时候，在 “＜＞”之间定义形式类型参数，例如：“class TestGen＜K,V＞”，其中“K” , “V”不代表值，而是表示类型。

2) 实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：

TestGen＜String,String＞ t=new TestGen＜String,String＞()；

3) 泛型中＜K extends Object＞,extends并不代表继承，它是类型范围限制。

2、泛型与数据类型转换

2.1. 消除类型转换

上面的例子大家看到什么了，数据类型转换的代码不见了。在以前我们经常要书写以下代码，如：

//code list 5

import Java.util.Hashtable;

class Test {

　public static void main(String[] args) {

Hashtable h = new Hashtable();

h.put("key", "value");

String s = (String)h.get("key");

System.out.println(s);

　}

}

这个我们做了类型转换，是不是感觉很烦的，并且强制类型转换会带来潜在的危险，系统可能会抛一个ClassCastException异常信息。在JDK5.0中我们完全可以这么做，如：

//code list 6

import Java.util.Hashtable;

class Test {

　public static void main(String[] args) {

Hashtable＜String,Integer＞ h = new Hashtable＜String,Integer＞ ();

h.put("key", new Integer(123));

int s = h.get("key").intValue();

System.out.println(s);

　}

}

这里我们使用泛化版本的HashMap,这样就不用我们来编写类型转换的代码了，类型转换的过程交给编译器来处理，是不是很方便，而且很安全。上面是String映射到String，也可以将Integer映射为String，只要写成HashTable＜Integer,String＞ h=new HashTable＜Integer,String＞();h.get(new Integer(0))返回value。果然很方便。

java中什么叫泛型?

泛型。规定了此集合中元素的类型。例如java代码有没有泛型：\x0d\x0a\x0d\x0aArrayList arr = new ArrayList ();\x0d\x0a\x0d\x0a这样就创建了一个包含整数的 ArrayList 对象。\x0d\x0a如果要自己定义泛型类，就用如下形式：\x0d\x0a\x0d\x0aclass MyCollection {...}\x0d\x0a\x0d\x0a尖括号中的类型可以有限制，例如java代码有没有泛型你需要让 MyCollection 中的类型都具有可比性，可以用如下格式：\x0d\x0a\x0d\x0aclass MyCollection {...}\x0d\x0a\x0d\x0a此外，要注意泛型的一些特性：\x0d\x0a\x0d\x0a1. 不能直接创建泛型数组。如 new ArrayList[5] 之类的是错的。只能用如下方法：new ArrayList[5] 或者 (ArrayList[])new ArrayList[5];\x0d\x0a\x0d\x0a2. 静态方法中需要小心，因为 E 一般是非静态类型，如果你这样写：\x0d\x0a class MyCollection {\x0d\x0a public static MyCollection abc() {\x0d\x0a ......\x0d\x0a }\x0d\x0a }\x0d\x0a 是错的。你只能把 去掉。

请教关于java的泛型方法

Java泛型详解

概述

在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型

就可以在细分成更多的类型。

例如原先的类型List，现在在细分成ListObject, ListString等更多的类型。

注意，现在ListObject, ListString是两种不同的类型，

他们之间没有继承关系，即使String继承了Object。下面的代码是非法的

    ListString ls = new ArrayListString();

    ListObject lo = ls;

这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是

ListString，破坏了数据类型的完整性。

在引入范型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入范型后，可以解决此问题

（多态），更进一步可以定义多个参数以及返回值之间的关系。

例如

public void write(Integer i, Integer[] ia);

public void write(Double  d, Double[] da);

的范型版本为

public T void write(T t, T[] ta);

2. 定义使用

 类型参数的命名风格为：

 推荐你用简练的名字作为形式类型参数的名字(如果可能，单个字符)。最好避免小写字母，这使它和其他的普通

 的形式参数很容易被区分开来。

 使用T代表类型，无论何时都没有比这更具体的类型来区分它。这经常见于泛型方法。如果有多个类型参数，我们

 可能使用字母表中T的临近的字母，比如S。

 如果一个泛型函数在一个泛型类里面出现，最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混

 淆。对内部类也是同样。

 

 2.1 定义带类型参数的类

 在定义带类型参数的类时，在紧跟类命之后的内,指定一个或多个类型参数的名字，同时也可以对类型参数的取

 值范围进行限定，多个类型参数之间用,号分隔。

 定义完类型参数后，可以在定义位置之后的类的几乎任意地方（静态块，静态属性，静态方法除外）使用类型参数，

 就像使用普通的类型一样。

 注意，父类定义的类型参数不能被子类继承。

 public class TestClassDefineT, S extends T {

     ....  

 }

 

 2.2 定义待类型参数方法

 在定义带类型参数的方法时，在紧跟可见范围修饰（例如public）之后的内,指定一个或多个类型参数的名字， 同时也可以对类型参数的取值范围进行限定，多个类型参数之间用,号分隔。

 定义完类型参数后，可以在定义位置之后的方法的任意地方使用类型参数，就像使用普通的类型一样。

 例如：

 public T, S extends T T testGenericMethodDefine(T t, S s){

     ...

 }

 注意：定义带类型参数的方法，骑主要目的是为了表达多个参数以及返回值之间的关系。例如本例子中T和S的继 承关系， 返回值的类型和第一个类型参数的值相同。

 如果仅仅是想实现多态，请优先使用通配符解决。通配符的内容见下面章节。

 public T void testGenericMethodDefine2(ListT s){

     ...

 }

 应改为

 public void testGenericMethodDefine2(List？ s){

     ...

 }

 

3. 类型参数赋值

 当对类或方法的类型参数进行赋值时，要求对所有的类型参数进行赋值。否则，将得到一个编译错误。

 

 3.1 对带类型参数的类进行类型参数赋值

 对带类型参数的类进行类型参数赋值有两种方式

 第一声明类变量或者实例化时。例如

 ListString list;

 list = new ArrayListString;

 第二继承类或者实现接口时。例如

 public class MyListE extends ArrayListE implements ListE {...} 

 

 3.2 对带类型参数方法进行赋值

 当调用范型方法时，编译器自动对类型参数进行赋值，当不能成功赋值时报编译错误。例如

 public T T testGenericMethodDefine3(T t, ListT list){

     ...

 }

 public T T testGenericMethodDefine4(ListT list1, ListT list2){

     ...

 }

 

 Number n = null;

 Integer i = null;

 Object o = null;

 testGenericMethodDefine(n, i);//此时T为Number, S为Integer

 testGenericMethodDefine(o, i);//T为Object, S为Integer

 

 ListNumber list1 = null;

 testGenericMethodDefine3(i, list1)//此时T为Number

 

 ListInteger list2 = null;

 testGenericMethodDefine4(list1, list2)//编译报错

 

 3.3 通配符

 在上面两小节中，对是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值。例如

 List? unknownList;

 List? extends Number unknownNumberList;

 List? super Integer unknownBaseLineIntgerList; 

 注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素， 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL

 ListString listString;

 List? unknownList2 = listString;

 unknownList = unknownList2;

 listString = unknownList;//编译错误

 

4. 数组范型

 可以使用带范型参数值的类声明数组，却不可有创建数组

 ListInteger[] iListArray;

 new ArrayListInteger[10];//编译时错误

 

5. 实现原理

5.1. Java范型时编译时技术，在运行时不包含范型信息，仅仅Class的实例中包含了类型参数的定义信息。

泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以（基本上就是）把它认为是一个从源码到源码的转换，它把泛型版本转换成非泛型版本。

基本上，擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了，因此，比如说一个ListString类型被转换为List。所有对类型变量的引用被替换成类型变量的上限(通常是Object)。而且，无论何时结果代码类型不正确，会插入一个到合适类型的转换。

       T T badCast(T t, Object o) {

         return (T) o; // unchecked warning

       }

类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担，这很好。不幸的是，这也意味着你不能依靠他们进行类型转换。

5.2.一个泛型类被其所有调用共享

下面的代码打印的结果是什么？

       ListString l1 = new ArrayListString();

       ListInteger l2 = new ArrayListInteger();

       System.out.println(l1.getClass() == l2.getClass());

或许你会说false，但是你想错了。它打印出true。因为一个泛型类的所有实例在运行时具有相同的运行时类(class)，

而不管他们的实际类型参数。

事实上，泛型之所以叫泛型，就是因为它对所有其可能的类型参数，有同样的行为；同样的类可以被当作许多不同的类型。作为一个结果，类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码中或者在静态变量的声明和初始化时使用类型参数（类型参数是属于具体实例的）是不合法的原因。

5.3. 转型和instanceof

泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。

       Collection cs = new ArrayListString();

       if (cs instanceof CollectionString) { ...} // 非法

类似的，如下的类型转换

CollectionString cstr = (CollectionString) cs;

得到一个unchecked warning，因为运行时环境不会为你作这样的检查。

6. Class的范型处理

Java 5之后，Class变成范型化了。

JDK1.5中一个变化是类 java.lang.Class是泛型化的。这是把泛型扩展到容器类之外的一个很有意思的例子。

现在，Class有一个类型参数T, 你很可能会问，T 代表什么？它代表Class对象代表的类型。比如说，

String.class类型代表 ClassString，Serializable.class代表 ClassSerializable。

这可以被用来提高你的反射代码的类型安全。

特别的，因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。

比如说，假定你要写一个工具方法来进行一个数据库查询，给定一个SQL语句，并返回一个数据库中符合查询条件

的对象集合(collection)。

一个方法是显式的传递一个工厂对象，像下面的代码：

interface FactoryT {

      public T[] make();

}

public T CollectionT select(FactoryT factory, String statement) { 

       CollectionT result = new ArrayListT();

       /* run sql query using jdbc */

       for ( int i=0; i10; i++ ) { /* iterate over jdbc results */

            T item = factory.make();

            /* use reflection and set all of item’s fields from sql results */

            result.add( item );

       }

       return result;

}

你可以这样调用：

select(new FactoryEmpInfo(){ 

    public EmpInfo make() { 

        return new EmpInfo();

        }

       } , ”selection string”);

也可以声明一个类 EmpInfoFactory 来支持接口 Factory：

class EmpInfoFactory implements FactoryEmpInfo { ...

    public EmpInfo make() { return new EmpInfo();}

}

然后调用：

select(getMyEmpInfoFactory(), "selection string");

这个解决方案的缺点是它需要下面的二者之一：

调用处那冗长的匿名工厂类，或为每个要使用的类型声明一个工厂类并传递其对象给调用的地方，这很不自然。

使用class类型参数值是非常自然的，它可以被反射使用。没有泛型的代码可能是：

Collection emps = sqlUtility.select(EmpInfo.class, ”select * from emps”); ...

public static Collection select(Class c, String sqlStatement) { 

    Collection result = new ArrayList();

    /* run sql query using jdbc */

    for ( /* iterate over jdbc results */ ) { 

        Object item = c.newInstance();

        /* use reflection and set all of item’s fields from sql results */

        result.add(item);

    }

        return result;

}

但是这不能给我们返回一个我们要的精确类型的集合。现在Class是泛型的，我们可以写：

CollectionEmpInfo emps=sqlUtility.select(EmpInfo.class, ”select * from emps”); ...

public static T CollectionT select(ClassTc, String sqlStatement) { 

    CollectionT result = new ArrayListT();

    /* run sql query using jdbc */

    for ( /* iterate over jdbc results */ ) { 

        T item = c.newInstance();

        /* use reflection and set all of item’s fields from sql results */

        result.add(item);

    } 

    return result;

}

来通过一种类型安全的方式得到我们要的集合。

这项技术是一个非常有用的技巧，它已成为一个在处理注释(annotations)的新API中被广泛使用的习惯用法。

7. 新老代码兼容

7.1. 为了保证代码的兼容性，下面的代码编译器（javac）允许，类型安全有你自己保证

List l = new ArrayListString();

ListString l = new ArrayList();

7.2. 在将你的类库升级为范型版本时，慎用协变式返回值。

例如，将代码

public class Foo { 

    public Foo create(){

        return new Foo();

    }

}

public class Bar extends Foo { 

    public Foo create(){

        return new Bar();

    } 

}

采用协变式返回值风格，将Bar修改为

public class Bar extends Foo { 

    public Bar create(){

        return new Bar();

    } 

}

要小心你类库的客户端。

JAVA泛型有什么作用?泛型是实泛型还是伪泛型?

泛型好处：

泛型简单易用

类型安全 泛型的主要目标是实现java的类型安全。 泛型可以使编译器知道一个对象的限定类型是什么，这样编译器就可以在一个高的程度上验证这个类型

消除了强制类型转换 使得代码可读性好，减少了很多出错的机会

Java语言引入泛型的好处是安全简单。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型的实现原理

泛型的实现是靠类型擦除技术 类型擦除是在编译期完成的 也就是在编译期 编译器会将泛型的类型参数都擦除成它的限定类型，如果没有则擦除为object类型之后在获取的时候再强制类型转换为对应的类型。 在运行期间并没有泛型的任何信息，因此也没有优化。

泛型不考虑继承

List 类型 是否 可以 赋值为 List类型 ？

答案是不可以的

虽然说在赋值之后 String类型可以当做 Object类型使用 但是还是会出现问题

参考：《2020最新Java基础精讲视频教程和学习路线！》

关于java代码有没有泛型和java 泛型编程的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。