Java泛型开源代码 深入理解java泛型详解
java中 泛型编写功能类求int ,float,double等类型的平均值，代码怎么写？
这个估计是不可能的，因为这个关系到精度的问题，比如说你传入的参数里面包含了整型和浮点型，那这样精度怎么算？还有，整型和浮点型都满足返回条件，那最后你是要返回整型还是浮点型？如果要求这些类型的平均值，那还是老老实实的用方法重载吧，反正最多也就三个方法。
成都创新互联专注于吴江企业网站建设,响应式网站设计,商城网站制作。吴江网站建设公司,为吴江等地区提供建站服务。全流程按需规划网站，专业设计，全程项目跟踪，成都创新互联专业和态度为您提供的服务
public static public static int avg(int[] array) {}
public static public static float avg(float[] array) {}
public static public static double avg(double[] array) {}
（Java泛型）为什么Object不能直接引用Integer内的值？？ （后面有源代码）
java的泛型实现机制就是这一要求的。泛型参数必须是一个类，即object类的子类。
但是java中，int属于原始数据类型，并不是一个类，也就无法使用于java泛型。
所以只能用integer类。
请教关于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设计源代码
上面 wuzhikun12同学写的不错，但我想还不能运行，并且还不太完善。我给个能运行的：（注意：文件名为：Test.java)
//要实现对象间的比较，就必须实现Comparable接口，它里面有个compareTo方法
//Comparable最好使用泛型，这样，无论是速度还是代码量都会减少
@SuppressWarnings("unchecked")
class Student implements ComparableStudent{
private String studentNo; //学号
private String studentName; //姓名
private double englishScore; //英语成绩
private double computerScore; //计算机成绩
private double mathScore; //数学成绩
private double totalScore; //总成绩
//空构造函数
public Student() {}
//构造函数
public Student(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
this.studentNo = studentNo;
this.studentName = studentName;
this.englishScore = englishSocre;
this.computerScore = computerScore;
this.mathScore = mathScore;
}
//计算总成绩
public double sum() {
this.totalScore = englishScore+computerScore+mathScore;
return totalScore;
}
//计算评测成绩
public double testScore() {
return sum()/3;
}
//实现compareTO方法
@Override
public int compareTo(Student student) {
double studentTotal = student.getTotalScore();
return totalScore==studentTotal?0:(totalScorestudentTotal?1:-1);
}
//重写toString方法
public String toString(){
return "学号："+this.getStudentNo()+" 姓名："+this.getStudentName()+" 英语成绩："+this.getEnglishScore()+" 数学成绩："+this.getMathScore()+" 计算机成绩："+this.getComputerScore()+" 总成绩："+this.getTotalScore();
}
//重写equals方法
public boolean equals(Object obj) {
if(obj == null){
return false;
}
if(!(obj instanceof Student)){
return false;
}
Student student = (Student)obj;
if(this.studentNo.equals(student.getStudentName())) { //照现实来说，比较是不是同一个学生，应该只是看他的学号是不是相同
return true;
} else {
return false;
}
}
/*以下为get和set方法，我个人认为，totalScore的set的方法没必要要，因为它是由其它成绩计算出来的
在set方法中，没设置一次值，调用一次sum方法，即重新计算总成绩
*/
public String getStudentNo() {
return studentNo;
}
public void setStudentNo(String studentNo) {
this.studentNo = studentNo;
sum();
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
sum();
}
public double getEnglishScore() {
return englishScore;
}
public void setEnglishScore(double englishScore) {
this.englishScore = englishScore;
sum();
}
public double getComputerScore() {
return computerScore;
}
public void setComputerScore(double computerScore) {
this.computerScore = computerScore;
sum();
}
public double getMathScore() {
return mathScore;
}
public void setMathScore(double mathScore) {
this.mathScore = mathScore;
sum();
}
public double getTotalScore() {
return totalScore;
}
}
//Student子类学习委员类的实现
class StudentXW extends Student {
//重写父类Student的testScore()方法
@Override
public double testScore() {
return sum()/3+3;
}
public StudentXW() {}
//StudentXW的构造函数
public StudentXW(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
super(studentNo,studentName,englishSocre,computerScore,mathScore);
}
}
//Student子类班长类的实现
class StudentBZ extends Student {
//重写父类Student的testScore()方法
@Override
public double testScore() {
return sum()/3+5;
}
public StudentBZ() {}
//StudentXW的构造函数
public StudentBZ(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
super(studentNo,studentName,englishSocre,computerScore,mathScore);
}
}
//测试类
public class Test {
public static void main(String[] args) {
//生成若干个student类、StudentXW类、StudentBZ类
Student student1 = new Student("s001","张三",70.5,50,88.5);
Student student2 = new Student("s002","李四",88,65,88.5);
Student student3 = new Student("s003","王五",67,77,90);
StudentXW student4 = new StudentXW("s004","李六",99,88,99.5);
StudentBZ student5 = new StudentBZ("s005","朱漆",56,65.6,43.5);
Student[] students = {student1,student2,student3,student4,student5};
for(int i = 0 ; istudents.length; i++){
double avgScore = students[i].testScore();
System.out.println(students[i].getStudentName()+"学生的评测成绩为："+ avgScore+"分");
}
}
}
运行结果为：
张三学生的评测成绩为：69.66666666666667分
李四学生的评测成绩为：80.5分
王五学生的评测成绩为：78.0分
李六学生的评测成绩为：98.5分
朱漆学生的评测成绩为：60.03333333333333分
网站标题：Java泛型开源代码 深入理解java泛型详解
文章链接：http://scyanting.com/article/dosjosh.html
