java泛化是什么意思，JAVA泛化及为什么需要泛化
各位老铁们好，相信很多人对java泛化是什么意思都不是特别的了解，因此呢，今天就来为大家分享下关于java泛化是什么意思以及JAVA泛化及为什么需要泛化的问题知识，还望可以帮助大家，解决大家的一些困惑，下面一起来看看吧！
JAVA泛化及为什么需要泛化
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
比如，有一种类型为List,此时该List可以是任意类型的列表，如Integer,String等等。
如果把List类型改为List<Integer>，则此时只表示整型的列表。
这就是所谓的将操作的数据类型指定为一个参数
那么这么做有什么好处呢？
比如原来我们有如下的程序：
ListmyIntList=newLinkedList();//1
myIntList.add(newInteger(0));//2
Integerx=(Integer)myIntList.iterator().next();//3
在第三行中进行了强制类型转换。这个类型转换不仅仅带来了混乱，它还可能产生一个运行时错误(run time error)，因为程序员可能会犯错。
程序员如何才能明确表示他们的意图，把一个list中的内容限制为一个特定的数据类型呢？这是generics背后的核心思想。这是上面程序片断的一个泛型版本:
List<Integer>myIntList=newLinkedList<Integer>();//1
myIntList.add(newInteger(0));//2
Integerx=myIntList.iterator().next();//3
注意变量myIntList的类型声明。它指定这不是一个任意的List，而是一个Integer的List，写作：List<Integer>。我们说List是一个带一个类型参数的泛型接口(a generic interface that takes a type parameter)，本例中，类型参数是Integer。我们在创建这个List对象的时候也指定了一个类型参数。
另一个需要注意的是第3行没了类型转换。
什么是java中的泛型
JAVA中<t>是泛型的意思
意思是Tree这个类里面需要用到另外一个类，但是又不能确定要用到的那个类的具体类型，所以暂时用T来代替，当具体的程序知道要用到的那个类型是什么的时候就用那个类型来代替T，就ok了。例如我需要实例化一个Tree类，需要用到的那个类是String，那么我就可以这么来实例化Tree<String>()。
扩展资料第一是泛化。可以用T代表任意类型Java语言中引入泛型是一个较大的功能增强不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了，这带来了很多好处。
第二是类型安全。泛型的一个主要目标就是提高ava程序的类型安全，使用泛型可以使编译器知道变量的类型限制，进而可以在更高程度上验证类型假设。如果不用泛型，则必须使用强制类型转换，而强制类型转换不安全，在运行期可能发生ClassCast Exception异常，如果使用泛型，则会在编译期就能发现该错误。
第三是消除强制类型转换。泛型可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。
第四是向后兼容。支持泛型的Java编译器（例如JDK1.5中的Javac）可以用来编译经过泛型扩充的Java程序（Generics Java程序），但是现有的没有使用泛型扩充的Java程序仍然可以用这些编译器来编译。
参考资料来源：百度百科-java泛型
java中<T>问题
Jdk5.0新特性Generic Types（泛型）
2007-04-27 PChome.net类型:转载来源:中国IT实验室作者:未知责编:宝良
1.介绍
2.定义简单Java泛型
其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Generics<K,V>，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子：
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
这只是个例子，不过看看是不是创建一个用类型作为参数的类，参数是K，V，传入的“值”是String类型。这个类他没有特定的待处理型别，以前我们定义好了一个类，在输入参数有所固定，是什么型别的有要求，但是现在编写程序，完全可以不制定参数的类型，具体用的时候来确定，增加了程序的通用性，像是一个模板。
3.泛型通配符
首先，下面是一个例子，作用是打印出一个集合中的所有元素，我们首先用老版本jdk1.4的编码规则，代码如下：
void printColleciton(Collection c){
iterator i= c.iterator();
for(k= 0; k< c.size();k++){
System.out.pritnln(i.next();
}
然后，我们用jdk5.0泛型来重写上面这段代码（循环的语法是新版本的语法）：
void printCollection(Colleciton<Object> c){
for(Object e: c){
System.out.print(e);
}
}
这个新版本并不比老版本的好多少，老版本可以用任意一种集合类型作为参数来调用，而新版本仅仅持有Collection<Object>类型，Colleciton<Object>并不是任意类型的Collection的超类。
那么什么是所有Colleciton类型的超类型呢？它是Collection<?>这样一个类型，读作“未知Colleciton”。它的意思是说Colleciton的元素类型可以匹配任意类型，我们把它称作通配符类型，我们这样写：
void printCollection(Colleciton<?> c){
for(Object e: c){
System.out.println(e);
}
}
现在我们用任意类型的集合来调用它了，需要注意的是内部方法printColleciton(),我们任可以从c中来读出元素，并且这些元素是Object类型，而且是安全的，因为无论集合中是什么类型，它总包括Object，但是将任意对象加到集合中是不安全的：
Colleciton<?> c= new ArrayList<String>();
c.add(new Object());//编译时错误
由于我们不知道c持有的是什么类型的元素，我们不能加object到集合中去。add()方法用类型E作为参数，（集合的元素类型）当真正的参数类型是？的时候，它代表的是一些未知类型。任何传递给add()方法的参数必须是这个未知类型的子类型。由于我们不知道未知类型，所以我们传递给它任何东西。主要的例外是null,它是每一个类型的成员。
另一方面，假定给一个List<?>，我们调用get()并且充分利用结果。结果类型是未知类型。但是我总是知道它是一个Object，因此分配一个从get()取出来的结果到一个object的变量是安全的，或者作为一个参数传递到一个需要object类型的地方。
3.1有限制的通配符
考虑一个画图的应用程序，这个程序能够画长方形、圆等类型，为了在程序中表示这样的图形，你可以定义一个类型的层次结构：
public abstract class Shape{
public abstract void draw(Canvas c);
}
public class Circle extends Shape{
private int x,y,radius;
public void draw(Canvas c){}
}
public class Rectangle extends Shape{
private int x,y,width,height;
public void draw(Canvas c){
}
}
//这些类能被画在画布上：
public class Canvas{
public void draw(Shape s){
s.draw(this);
}
}
任何画图的动作的都包含一些图形，假设他们被表示在一个list中，在Canvas中它将会有一个很方便的方法来画他们：
public void drawAll(List<Shape> shapes){
for(Shape s:shapes){
s.draw(this);
}
}
现在类型规则说，方法drawAll()只能在真正的Shape类型的List上被调用，而它的子类无法调用，例如List<Circle>上被调用。这是很不幸的。由于所有的方法确实从List中读出Shape，所以它仅能在List<Object>上被调用，下面我们改后的代码可以在任意类型的Shape上被调用：
public void drawAll(List<? extends Shape>{}
这里有一个很小的不同是，我们已经用List<? extends Shape>替换了List<Object>，现在drawAll()方法可以接受任意的Shape的子类了，我们当然可以在List<Circle>上调用。
<? extends Class>是一种限制通配符类型，它可以接受所有<Class>以及Class的子类型。然而调用代价是，只读访问，无法向shapes中添加元素。像通常一样，使用通配符带来的灵活性将付出代价，例如，下面是不允许的：
public void addRectangle(List<? extends Shape> shapes){
shapes.add(0,new Rectangle());//编译时错误
}
限制性通配符的一个例子是，是一个人口普查的例子，我们假设数据是由一个名字映射一个人，名字是字符串，人（可以是Person,或是它的子类Driver）,Map<k,v>是一个泛型的例子，它拥有两个参数，表示为一个KEY和value的映射MAP
再次注意正规参数的命名规则，K代表key,V代表value
public class Census{
public static void addRegistry(Map<String? extends Person> Registry){}
}
Map<String,Driver> allDrivers=;
census.addResigtry(allDrivers);
编写泛型类要注意：
1)在定义一个泛型类的时候，在“<>”之间定义形式类型参数，例如：“class TestGen<K,V>”，其中“K”,“V”不代表值，而是表示类型。
2)实例化泛型对象的时候，一定要在类名后面指定类型参数的值（类型），一共要有两次书写。例如：
TestGen<String,String> t=new TestGen<String,String>()；
3)泛型中<K extends Object>,extends并不代表继承，它是类型范围限制。
4.泛型与数据类型转换
4.1.消除类型转换
上面的例子大家看到什么了，数据类型转换的代码不见了。在以前我们经常要书写以下代码，如：
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中我们完全可以这么做，如：
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。果然很方便。
4.2自动解包装与自动包装的功能
从上面有没有看到有点别扭啊，h.get(new Integer(123))这里的new Integer(123);好烦的，在JDK5.0之前我们只能忍着了，现在这种问题已经解决了，请看下面这个方法。我们传入一个int这一基本型别，然后再将i的值直接添加到List中，其实List是不能储存基本型别的，List中应该存储对象，这里编译器将int包装成Integer，然后添加到List中去。接着我们用List.get(0);来检索数据，并返回对象再将对象解包装成int。恩，JDK5.0给我们带来更多方便与安全。
public void autoBoxingUnboxing(int i){
ArrayList<Integer> L= new ArrayList<Integer>();
L.add(i);
int a= L.get(0);
System.out.println("The value of i is"+ a);
}
4.3限制泛型中类型参数的范围
也许你已经发现在TestGen<K,V>这个泛型类,其中K,V可以是任意的型别。也许你有时候呢想限定一下K和V当然范围，怎么做呢？看看如下的代码：
class TestGen2<K extents String,V extends Number>
{
private V v=null;
private K k=null;
public void setV(V v){
this.v=v;
}
public V getV(){
return this.v;
}
public void setK(K k){
this.k=k;
}
public V getK(){
return this.k;
}
public static void main(String[] args)
{
TestGen2<String,Integer> t2=new TestGen2<String,Integer>();
t2.setK(new String("String"));
t2.setV(new Integer(123));
System.out.println(t2.getK());
System.out.println(t2.getV());
}
}
上边K的范围是<=String，V的范围是<=Number，注意是“<=”,对于K可以是String的，V当然也可以是Number，也可以是Integer,Float,Double,Byte等。看看下图也许能直观些请看上图A是上图类中的基类，A1，A2分别是A的子类，A2有2个子类分别是A2_1，A2_2。
然后我们定义一个受限的泛型类class MyGen<E extends A2>,这个泛型的范围就是上图中兰色部分。
这个是单一的限制，你也可以对型别多重限制，如下：
class C<T extends Comparable<? super T>& Serializable>
我们来分析以下这句，T extends Comparable这个是对上限的限制，Comparable< super T>这个是下限的限制，Serializable是第2个上限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。
5.泛型方法
考虑写一个持有数组类型对象和一个集合对象的方法，把数组里的所有对象都放到
集合里。第一个程序为：
static void fromArrayToColleciton(Object[]a,Collection<?> c){
for(Object o: a){
c.add(o);//编译时错误
}
}
到现在为止，你可能学会避免开始的错误而去使用Collection<Object>作为集合参数的类型，你可能会意识到使用Colleciton<?>将不会工作。
解决这个问题的方法是使用泛型方法，GENERIC METHODS，就像类型声明、方法声明一样，就是被一个或更多的类型参数参数化。
static<T> void fromArrayToCollection(T[]a,Collection<T> c){
for(T o:a){
c.add(o);//正确
}
}
我们可以用任意类型的集合调用这个方法，他的元素类型是数组元素类型的超类型。
Object[] oa= new Object[100];
Collection<Object> co= new ArrayList<Object>();
fromArrayToCollection(oa,co);//T被认为是Object类型
String[] sa= new String[100];
Colleciton<String> cs= new ArrayList<String>();
fromArrayToCollection(sa,cs);//T被认为是String类型
fromArrayToCollection(sa,co);//T被认为是Object类型
Integer[] is= new Integer[100];
Float[] fa= new Float[100];
Number[] na= new Number[100];
Collection<Number> cn= new ArrayList<Number>();
fromArrayToCollection(is,cn);//Number
fromArrayToCollection(fa,cn);//Number
fromArrayToCollection(na,cn);//Number
fromArrayToCollection(na,co);//Object
fromArrayToCollection(na,cs);//编译时错误
我们不必给一个泛型方法传递一个真正的类型参数,编译器会推断类型参数.一个问题出现了,什么时候使用泛型方法,什么时候使通配符类型,为了回答这些问题,我们从Colleciton库中看一下几个方法：
interface Collection<E>{
public boolean containsAll(Collection<?> c);
public boolean addAll(Collection<? extends E> c);
}
使用泛型方法的形式为：
interface Collection<E>{
public<T> boolean containsAll(Collection<T> c);
public<T extends E> boolean addAll(Collection<T> c);
}
无论如何，在ContainAll和addAll中，类型参数T仅被使用一次。返回类型不依赖于类型参数，也不依赖方法中的任何参数。这告诉我类型参数正被用于多态，它的影响仅仅是允许不同的实参在不同的调用点被使用。
泛型方法允许类型参数被用于表达在一个或更多参数之间或者方法中的参数、返回类型的依赖。如果没有如此依赖，泛型方法就不能被使用。可能一前一后来联合使用泛型和通配符，这里有个例子：
class Collections{
public static<T> void copy(List<T> dest,List<? extends T> src){
}
}
注意两个参数之间的依赖，任何从原list的对象复制，必须分配一个目标LIST元素的类型T,于是Src的元素类型可能是任何T的子类型。我们不必在意在COPY的表达中，表示依赖使用一个类型参数，但是是使用一个通配符。
下面我们不使用通配符来重写上面的方法：
class Collections{
public static<T，S extends T>
void copy(List<T> dest,List<S> src){
}
}
这非常好，但是第一个类型参数既在dst中使用，也在第二个类型参数中使用，S本身就被使用了一次。在类型src中,没有什么类型依赖它。这是一个标志我们可以用通配符来替换它。使用通配符比显示的声明类型参数更加清楚和精确。所以有可能推荐使用通配符。
通配符也有优势，可以在方法之外来使用，作为字段类型、局部变量和数组。
这里有一个例子。
返回到我们画图的例子，假设我们要保持一个画图请求的历史，我们可以在Shape类内部用一个静态变量来保持历史。用drawAll()存储它到来的参数到历史字段。
static List<List<? extends Shape>> history=
new ArrayList<List<? extends Shape>>();
public void drawAll(List<? extends Shape> shapes){
history.addLast(shapes);
for(Shape s: shapes){
s.draw(this);
}
}
uml是什么意思
UML建模技术是一种建模语言，指用模型元素来组建整个系统的模型，模型元素包括系统中的类、类和类之间的关联、类的实例相互配合实现系统的动态行为等。
UML提供了多种图形可视化描述模型元素，同一个模型元素可能会出现在多个图中对应多个图形元素，人们可以从多个视图来考察模型。
扩展资料：
UML是面向对象开发中一种通用的图形化建模语言，它定义良好、易于表达、功能强大且普遍适用。
面向对象的分析主要在加强对问题空间和系统任务的理解、改进各方交流、与需求保持一致和支持软件重用等4个方面表现出比其他系统分析方法更好的能力，成为主流的系统分析方法。
UML的出现既统一了Booch、OMT、OOSE，以及其他方法，又统一了面向对象方法中使用的符号，并且在提出后不久就被OMG接纳为其标准之一。
从而改变了数十种面向对象的建模语言相互独立且各有千秋的局面，使得面向对象的分析技术有了空前发展。
它本身成为现代软件工程环境中对象分析和设计的重要工具，被视为面向对象技术的重要成果之一。
参考资料：
百度百科-UML建模技术
关于java泛化是什么意思到此分享完毕，希望能帮助到您。