javaobject泛型

⑴ java，泛型问题和Object，类型转换问题

简单点说，不扯那些书上的，弱类型语言无类型，高级语言有类型，每个类型有自己的方法，这里就说java，java基本数据类型有8中，对应的包装类也是有方法的，比如int对应的Integer，按你说的统一就Object类型，那么每个类型都有自己的方法，你都用Object方法要怎么用？你可以如果我要用String，那么我就把Object转换为String，可是往往写代码的时候，你还不知道未来那个数据是什么类型，这种情况也是有的，再说泛型，泛型这个东西简单来说就是在编译期间确定类型，这样IDE可以帮你检查类型，举例一个集合List，这里以前是可以装任何Object的，有了泛型以后，我们可以这样List<String>意思说这里的集合我只能装字符串类型，否则编译时就过不去，这样的好处是你内心知道这里只是字符串，未来在从集合中获取一个对象时，直接就可以用字符串的方法，而不是拿出Object在转换，并且如果只是单纯的List集合，你如何确定代码装入集合中的对象就一定是字符串，倘若很复杂的代码，里面不小心装入的Integer对象，也很难检测，恐怕只有运行报错的时候你才知道，最后要说泛型只存在于编译期间，编译过后泛型擦除！

⑵ java泛型<T>和<Object>的区别

使用<T>来声明类型持有者名称，自定义泛型类时，类持有者名称可以使用T(Type)，如果是容器的元素可以使用E(Element)，若键值匹配可以用K(Key)和V(Value)等，若是<?>，则是默认是允许Object及其下的子类，也就是java的所有对象了。

⑶ java 泛型 对象 如何判断

java中的泛型对象使用instanceof来判断。
具体代码如下：

public class Demo {
public static void main(String[] args) {
List<Task> list = new ArrayList<Task>();
list.add(new Task());
for(int i=0;i<list.size();i++){
if(list.get(i) instanceof Task){
System.out.println(true);
}else{
System.out.println(false);
}
}

}
static class Task{
}
}

instanceof作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。可以用来判断继承中的子类的实例是否为父类的实现。

⑷ 如何在Java程序中使用泛型

在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行向下的强制类型转换，转换到特定的类型。
比如：
List myIntList = new LinkedList(); // 1

myIntList.add(new Integer(0)); // 2

Integer x = (Integer) myIntList.iterator().next(); // 3

第三行的这个强制类型转换可能会引起运行时的错误。
泛型的思想就是由程序员指定类型，这样集合就只能容纳该类型的元素。
使用泛型：
List<Integer> myIntList = new LinkedList<Integer>(); // 1'

myIntList.add(new Integer(0)); // 2'

Integer x = myIntList.iterator().next(); // 3'

将第三行的强制类型转换变为了第一行的List类型说明，编译器会为我们检查类型的正确性。这样，代码的可读性和健壮性也会增强。

泛型使用基础
例如：

public interface List <E>
{
void add(E x);
Iterator<E> iterator();
}

public interface Iterator<E>
{
E next();
boolean hasNext();
}

尖括号中包含的是形式类型参数（formal type parameters），它们就如同一般的类型一样，可以在整个类的声明中被使用。
当类被使用时，会使用具体的实际类型参数（actual type argument）代替。
比如前面的例子中的List<Integer>，那么所有的E将会被Integer类型所代替。
泛型类型参数只能被类或接口类型赋值，不能被原生数据类型赋值，原生数据类型需要使用对应的包装类。
形式类型参数的命名：尽量使用单个的大写字母（有时候多个泛型类型时会加上数字，比如T1，T2），比如许多容器集合使用E，代表element（元素），Map中用K代表键keys，V代表值。

⑸ java泛型中 <Object>是对象类型 <T>代表什么类型 能否把所有泛型的简写介绍小

<T>表示的是形式泛型类型(formal generic type)，一般在接口中声明一个泛型类型；
在实现中，要用具体类型来代替它。
根据约定：像E或T这样的单个大写字母用于指示形式泛型类型。

⑹ java中list集合存储了object元素，根据泛型进行分组

for(Object object : list) {
String str = object.toString();
if (StringUtils.isNumeric(str )) {
// 是数字
} else {
// 不是数字
}
}

⑺ java中泛型指的是什么

我来简述一下泛型的知识吧:

如果一个类的后面跟上一个尖括号,表示这个类是泛型类.

可以这样声明:class 名称<泛型列表>
如:class A<E>
其中A是泛型类的名称,E是泛型.(可以是任何对象或接口)

其中给出的泛型可以作为类的成员变量的类型,方法的类型以及局部变量的类型.类体和变通类完全一样,由成员变量和方法构成.

举个例子:
class Chorus<E,F>
{
void makeChorus(E person,F yueqi)
{
yueqi.toString();
person.toString() ;
}
}
--------------
上面的类中将类E和类F作为类Chorus的一部分来使用.这就是泛型类的目的,将多个类包含进一个类来使用!!!

如果你想深入理解就可以找一些书来看,一些基本的教材里面也都有提到泛型的.

希望我说的对你有所帮助!!!

⑻ java泛型的深入泛型

因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了，实际上就是“Object泛型”，暂时这么称呼。 publicclassObjectFoo{privateObjectx;publicObjectFoo(Objectx){this.x=x;}publicObjectgetX(){returnx;}publicvoidsetX(Objectx){this.x=x;}}写出Demo方法如下： publicclassObjectFooDemo{publicstaticvoidmain(Stringargs[]){ObjectFoostrFoo=newObjectFoo(newStringFoo(HelloGenerics!));ObjectFoodouFoo=newObjectFoo(newDoubleFoo(newDouble(33)));ObjectFooobjFoo=newObjectFoo(newObject());System.out.println(strFoo.getX=+(StringFoo)strFoo.getX());System.out.println(douFoo.getX=+(DoubleFoo)douFoo.getX());System.out.println(objFoo.getX=+objFoo.getX());}}运行结果如下：
strFoo.getX=StringFoo@5d748654
douFoo.getX=DoubleFoo@d1f24bb
objFoo.getX=java.lang.Object@19821f
解说：在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法。 强制类型转换很麻烦，我还要事先知道各个Object具体类型是什么，才能做出正确转换。否则，要是转换的类型不对，比如将“Hello Generics!”字符串强制转换为Double,那么编译的时候不会报错，可是运行的时候就挂了。那有没有不强制转换的办法----有，改用 Java5泛型来实现。 classGenericsFoo<T>{privateTx;publicGenericsFoo(Tx){this.x=x;}publicTgetX(){returnx;}publicvoidsetX(Tx){this.x=x;}}publicclassGenericsFooDemo{publicstaticvoidmain(Stringargs[]){GenericsFoo<String>strFoo=newGenericsFoo<String>(HelloGenerics!);GenericsFoo<Double>douFoo=newGenericsFoo<Double>(newDouble(33));GenericsFoo<Object>objFoo=newGenericsFoo<Object>(newObject());System.out.println(strFoo.getX=+strFoo.getX());System.out.println(douFoo.getX=+douFoo.getX());System.out.println(objFoo.getX=+objFoo.getX());}}运行结果：
strFoo.getX=Hello Generics!
douFoo.getX=33.0
objFoo.getX=java.lang.Object@19821f
和使用“Object泛型”方式实现结果的完全一样，但是这个Demo简单多了，里面没有强制类型转换信息。
下面解释一下上面泛型类的语法：
使用<T>来声明一个类型持有者名称，然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。
当然T仅仅是个名字，这个名字可以自行定义。
class GenericsFoo<T> 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsFoo<T extends Object>。
与Object泛型类相比，使用泛型所定义的类在声明和构造实例的时候，可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如
GenericsFoo<Double> douFoo=new GenericsFoo<Double>(new Double(33));
当然，也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型，但是你在使用该对象的时候，就需要强制转换了。比如：GenericsFoo douFoo=new GenericsFoo(new Double(33));
实际上，当构造对象时不指定类型信息的时候，默认会使用Object类型，这也是要强制转换的原因。

⑼ （Java泛型）为什么Object不能直接引用Integer内的值 （后面有源代码）

java的泛型实现机制就是这一要求的。泛型参数必须是一个类，即object类的子类。
但是java中，int属于原始数据类型，并不是一个类，也就无法使用于java泛型。
所以只能用integer类。

⑽ Java中泛型如果没有指定类型，为什么会把添加的类型转成object呢

java是面对对象的编程，所有的类都是直接或者间接继承object类。可以说object类为java中的根类(root class)
所以当泛型没有指定类型时，就会转成object类