JDK5.0新特性系列---8.泛型编程

简介:

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

/**

*泛型编程关键掌握两点:

*1.在方法参数中使用通配符

*2.在方法的参数类型和返回类型中使用通用类型

*/

/**关键技术

*1.通配符问号(?)表示任意类型."List<?>"表示可以存放任意对象类型的List

*2.通配符可以接extendssuper,表示有限制的通配符."List<? extends Parent>"

* 声明的List能且仅能存放Parent及其子类的对象,"List<? super Child>"

* 声明的List仅能存放Child及其父类的对象

*3.通用类型是指不指定参数或者返回值的类型,常用一个大写的字母代表类型,

* 它能代表任何类型,需要在方法声明的返回值前用<>声明通用类型."public <T> String

* getName(T data)"的方法声明中,String前用<T>表示T是通用类型,它的data参数的类型是T,

* 表示能接收任意类型的参数,方法的返回值是String类型

*/

public class GeneralProgram {

/**使用问号"?*通配符,"?"代表任何类型,所以它的参数可以是任何类型的Collection*/

public static void printCollection(Collection<?> collect){

if(collect == null){

return;

}

for(Object obj : collect){

System.out.println(obj + " ");

}

System.out.println();

}

/**使用有限制的通配符"? extends",可以接受任何Parent及其子类的Collection*/

public static void printNames(Collection<? extends Parent> collect){

if(collect == null){

return;

}

for(Object obj : collect){

System.out.println(obj + " ");

}

System.out.println();

}

/**将一个任意类型的数组添加到列表里*/

public static <T> List<T> arrayToList(T[] datas){

if (datas == null){

return null;

}

List<T> list_T = new ArrayList<T>();

for(T x : datas){

list_T.add(x);

}

return list_T;

}

/**在一组parent对象中查找名字为nameParent对象*/

public static <T extends Parent> T findParent(T[] parents, String name){

if(parents == null){

return null;

}

T parent = null;

//依次遍历Parent对象数组

for(T x : parents){

//如果Parent对象的name与参数name匹配,则退出遍历

if(x.name.equals(name)){

parent = x;

break;

}

}

//返回

return parent;

}

public static void main(String[] args){

/***指定具体的类型***/

//声明一个用于装字符串的列表,该列表只能装字符串的对象

List<String> list_S = new ArrayList<String>();

list_S.add("first");

list_S.add("second");

list_S.add("third");

//不能装整数对象

Integer iObj = 10;

//list_S.add(iObj);//error!!

//从列表中取值时,不用作强制类型转换

String firstS = list_S.get(0);

String thirdS = list_S.get(2);

System.out.println("firstS: " + firstS + "; thirdS: " + thirdS);

/***泛型和继承***/

//String继承Object

String s = "sss";

Object o = s;

//List<String>不继承List<Object>

//List<Object> list_O = list_s;//error!!!!!!!!!

/***通配符***/

//调用具有"?"通配符的方法

List<Integer> list_I = new ArrayList<Integer>();

list_I.add(5555);

list_I.add(6666);

list_I.add(7777);

//该方法可以打印整型列表,也可以打印字符串列表

printCollection(list_I);

printCollection(list_S);

/***调用具有"?"通配符的方法***/

//只接受父类以及子类类型的列表

List<Parent> list_Parent = new ArrayList<Parent>();

list_Parent.add(new Parent("parentOne"));

list_Parent.add(new Parent("parentTwo"));

list_Parent.add(new Parent("parentThree"));

List<Child> list_Child = new ArrayList<Child>();

list_Child.add(new Child("childOne",20));

list_Child.add(new Child("childTwo",22));

list_Child.add(new Child("childThree",21));

printNames(list_Parent);

printNames(list_Child);

//不能接受其它类型的参数

//printNames(list_S);//error!

/***泛型方法***/

//arrayToList方法将任意类型的对象数组变成相应的列表

Integer[] iObjs = {55,66,77,88,99};

List<Integer> result_I = arrayToList(iObjs);//转换整型数组

printCollection(result_I);

String[] ss = {"temp","temptemp","hehe","he","hehehe"};

//转换字符串数组

List<String> result_S = arrayToList(ss);

printCollection(result_S);

//findParent方法在一组Parent对象中根据name查找Parent

Parent[] parents = {new Parent("abc"),new Parent("bcd"),newParent("def")};

Parent parent = findParent(parents, "bcd");

System.out.print("找到的bcd: "+parent);

Child[] children = {new Child("abc",22),new Child("bcd",23),newChild("def",22)};

Child child = findParent(children, "bcd");

System.out.print("找到的bcd: "+child);

//但是不能在字符串数组中进行查找

//String sss = findparent(ss,"temp");//error!

}

}

class Parent{

public String name;

public Parent(String name){

this.name = name;

}

public String toString(){

return "name = " + this.name;

}

}

class Child extends Parent{

public int age;

public Child(String name,int age){

super(name);

this.age = age;

}

public String toString(){

return super.toString() + "; age = " + age;

}

}




本文转自远哥博客园博客,原文链接:http://www.cnblogs.com/taven/archive/2011/12/17/2291462.html,如需转载请自行联系原作者

相关文章
|
16天前
|
安全 Java 编译器
JDK 10中的局部变量类型推断:Java编程的简化与革新
JDK 10引入的局部变量类型推断通过`var`关键字简化了代码编写,提高了可读性。编译器根据初始化表达式自动推断变量类型,减少了冗长的类型声明。虽然带来了诸多优点,但也有一些限制,如只能用于局部变量声明,并需立即初始化。这一特性使Java更接近动态类型语言,增强了灵活性和易用性。
95 53
|
1月前
|
Java 关系型数据库 MySQL
【编程基础知识】Eclipse连接MySQL 8.0时的JDK版本和驱动问题全解析
本文详细解析了在使用Eclipse连接MySQL 8.0时常见的JDK版本不兼容、驱动类错误和时区设置问题,并提供了清晰的解决方案。通过正确配置JDK版本、选择合适的驱动类和设置时区,确保Java应用能够顺利连接MySQL 8.0。
170 1
|
1月前
|
Java
【编程进阶知识】静态代理、JDK动态代理及Cglib动态代理各自存在的缺点及代码示例
本文介绍了三种Java代理模式:静态代理、JDK动态代理和Cglib动态代理。静态代理针对特定接口或对象,需手动编码实现;JDK动态代理通过反射机制实现,适用于所有接口;Cglib动态代理则基于字节码技术,无需接口支持,但需引入外部库。每种方法各有优缺点,选择时应根据具体需求考虑。
21 1
|
1月前
|
开发框架 Oracle Java
【编程基础知识】《Java 世界探秘:JRE、JDK 与 JDK 版本全解析》
JRE(Java Runtime Environment)是运行Java程序所需的环境,包含JVM和Java核心类库,适合普通用户使用。JDK(Java Development Kit)则是Java开发工具包,不仅包含JRE,还提供了编译器、调试器等开发工具,适用于开发者。两者的主要区别在于JDK用于开发,而JRE仅用于运行Java程序。JDK各版本不断引入新特性,如Java 8中的Lambda表达式和默认方法等。环境配置方面,Windows和Linux系统都有详细的步骤,确保Java程序能够顺利编译和运行。
40 1
|
2月前
|
容器
jdk8新特性-详情查看文档
jdk8新特性-详情查看文档
46 3
|
1月前
|
存储 安全 Java
JDK1.8 新的特性
JDK1.8 新的特性
21 0
|
2月前
|
Java 开发者
【Java编程新纪元】JDK 22:超级构造函数来袭,super(...) 前导语句改写编程规则!
【9月更文挑战第6天】JDK 22的超级构造函数特性是Java编程语言发展史上的一个重要里程碑。它不仅简化了代码编写,还提升了代码的可读性和维护性。我们有理由相信,在未来的Java版本中,还将有更多令人兴奋的新特性等待我们去发现和应用。让我们共同期待Java编程新纪元的到来!
|
2月前
|
Oracle Java 关系型数据库
【颠覆性升级】JDK 22:超级构造器与区域锁,重塑Java编程的两大基石!
【9月更文挑战第6天】JDK 22的发布标志着Java编程语言在性能和灵活性方面迈出了重要的一步。超级构造器和区域锁这两大基石的引入,不仅简化了代码设计,提高了开发效率,还优化了垃圾收集器的性能,降低了应用延迟。这些改进不仅展示了Oracle在Java生态系统中的持续改进和创新精神,也为广大Java开发者提供了更多的可能性和便利。我们有理由相信,在未来的Java编程中,这些新特性将发挥越来越重要的作用,推动Java技术不断向前发展。
|
2月前
|
编解码 安全 Java
jdk8新特性-接口和日期处理
jdk8新特性-接口和日期处理
|
3月前
|
Oracle Java 关系型数据库
JDK8到JDK29版本升级的新特性问题之未来JDK的升级是否会成为必然趋势,如何理解
JDK8到JDK29版本升级的新特性问题之未来JDK的升级是否会成为必然趋势,如何理解