Java泛型
泛型就是指在对象建立时不指定类中属性的具体类型，而由外部在声明及实例化对喜爱时指定类型。
在泛型的指定中无法指定基本数据类型的，必须设置成一个类，这样在设置一个数字时就必须使用包装类。
class Point<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
public class Generics_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
// Point<Integer> p = new Point<Integer>(); //里面的var类型为Integer类型
// p.setVar(30); //设置数字，自动装箱
// System.out.println(p.getVar()*2); //计算结果，按数字取出
Point<String> p = new Point<String>(); //里面的var类型为Integer类型
p.setVar("张三"); //设置数字，自动装箱
System.out.println(p.getVar().length()); //计算结果，按数字取出
}
}
泛型的构造方法
class Point<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
public Point(T var) { //构造方法
super();
this.var = var;
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
public class Generics_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
// Point<Integer> p = new Point<Integer>(); //里面的var类型为Integer类型
// p.setVar(30); //设置数字，自动装箱
// System.out.println(p.getVar()*2); //计算结果，按数字取出
// Point<String> p = new Point<String>(); //里面的var类型为Integer类型
// p.setVar("张三"); //设置数字，自动装箱
// System.out.println(p.getVar().length()); //计算结果，按数字取出
Point<String> p = new Point<String>("张三");
System.out.println("内容："+p.getVar());
}
}
指定多个泛型类型
class Point<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
public Point(T var) { //构造方法
super();
this.var = var;
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
class Notepad<K,V>{ //此处T可以是任意的标识符号，T是type的简称
private K key; //此变量的类型由外部决定
private V value; //此变量的类型由外部决定
public Notepad(K key, V value) { //构造方法
super();
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
public class Generics_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
// Point<Integer> p = newdd Point<Integer>(); //里面的var类型为Integer类型
// p.setVar(30); //设置数字，自动装箱
// System.out.println(p.getVar()*2); //计算结果，按数字取出
// Point<String> p = new Point<String>(); //里面的var类型为Integer类型
// p.setVar("张三"); //设置数字，自动装箱
// System.out.println(p.getVar().length()); //计算结果，按数字取出
// Point<String> p = new Point<String>("张三");
// System.out.println("内容："+p.getVar());
Notepad<String,Integer> t = new Notepad<String,Integer>("张三",18);
System.out.println(t.getKey());
System.out.println(t.getValue());
}
}
通配符
class Point<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
public Point(T var) { //构造方法
super();
this.var = var;
}
public String toString(){ //覆写Object类中的toString()方法
return this.var.toString();
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
class Notepad<K,V>{ //此处T可以是任意的标识符号，T是type的简称
private K key; //此变量的类型由外部决定
private V value; //此变量的类型由外部决定
public Notepad(K key, V value) { //构造方法
super();
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
public class Generics_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Point<String> p = new Point<String>("张三");
fun(p);
}
public static void fun(Point<?> point){ //使用泛型接收Point的对象
System.out.println("内容：" + point);
}
}
受限泛型
在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。
范围上限使用extends关键字声明，标识参数化的类型可能是所指定的类型或者是此类型的子类。
范围下限使用super关键字声明，标识参数化的类型可能是所指定的类型，或者是此类型的父类型，或是Object类。
范围上限
import java.awt.datatransfer.FlavorTable;
class info<T extends Number>{ //在声明的地方指定泛型的上限范围
//class info<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
public info(T var) { //构造方法
super();
this.var = var;
}
public String toString(){ //覆写Object类中的toString()方法
return this.var.toString();
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
public class Generics_extends_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
info<Float> i1 = new info<Float>(10.1f); //声明并实例化Float类型的泛型对象
info<Integer> i2 = new info<Integer>(10); //声明并实例化Integer类型的泛型对象
fun(i1); //是数字可以传递
fun(i2); //是数字可以传递
}
public static void fun(info<?> temp){ //使用泛型接收info的对象
// public static void fun(info<? extends Number> temp){ //使用泛型接收info的对象
System.out.println("temp:" + temp);
}
}
范围下限
import java.awt.datatransfer.FlavorTable;
//class info<T extends Number>{ //在声明的地方指定泛型的上限范围
class info<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
public info(T var) { //构造方法
super();
this.var = var;
}
public String toString(){ //覆写Object类中的toString()方法
return this.var.toString();
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
public class Generics_extends_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
// info<Float> i1 = new info<Float>(10.1f); //声明并实例化Float类型的泛型对象
// info<Integer> i2 = new info<Integer>(10); //声明并实例化Integer类型的泛型对象
info<Object> i1 = new info<Object>(new Object()); //声明并实例化Object类型的泛型对象
info<String> i2 = new info<String>("张三"); //声明并实例化String类型的泛型对象
fun(i1); //是数字可以传递
fun(i2); //是数字可以传递
}
// public static void fun(info<?> temp){ //使用泛型接收info的对象
// public static void fun(info<? extends Number> temp){ //使用泛型接收info的对象
public static void fun(info<? super String> temp){ //使用泛型接收info的对象
System.out.println("temp:" + temp);
}
}
泛型接口
定义泛型接口
定义子类方式<1>——在子类的定义上声明泛型类型
interface Info_1<T>{
public T getVar();
}
class InfoImp<T> implements Info_1<T>{
private T var; //定义属性
public InfoImp(T var) { //构造方法
super();
this.var = var;
}
public void setVar(T var) {
this.var = var;
}
@Override
public T getVar() {
// TODO 自动生成的方法存根
return this.var;
}
}
public class Generics_Interface_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
InfoImp<String> p = new InfoImp<String>("张三");
System.out.println("内容："+p.getVar());
}
}
定义子类方式<2>——直接在接口中指定具体类型
interface Info_1<T>{
public T getVar();
}
class InfoImp implements Info_1<String>{//定义泛型接口的子类，指定类型为String
//class InfoImp<T> implements Info_1<T>{ //定义泛型接口的子类
// private T var; //定义属性
private String var; //定义属性
// public InfoImp(T var) { //构造方法
public InfoImp(String var) { //构造方法
super();
this.var = var;
}
// public void setVar(T var) {
public void setVar(String var) {
this.var = var;
}
@Override
// public T getVar() {
public String getVar() {
// TODO 自动生成的方法存根
return this.var;
}
}
public class Generics_Interface_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
InfoImp p = new InfoImp("张三");
System.out.println("内容："+p.getVar());
}
}
定义泛型方法
class Demo_Generics{
public <T> T fun(T t){ //可以接收任意类型的数据
return t;
}
}
interface Info_1<T>{
public T getVar();
}
class InfoImp implements Info_1<String>{//定义泛型接口的子类，指定类型为String
//class InfoImp<T> implements Info_1<T>{ //定义泛型接口的子类
// private T var; //定义属性
private String var; //定义属性
// public InfoImp(T var) { //构造方法
public InfoImp(String var) { //构造方法
super();
this.var = var;
}
// public void setVar(T var) {
public void setVar(String var) {
this.var = var;
}
@Override
// public T getVar() {
public String getVar() {
// TODO 自动生成的方法存根
return this.var;
}
}
public class Generics_Interface_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
// InfoImp p = new InfoImp("张三");
// System.out.println("内容："+p.getVar());
Demo_Generics d = new Demo_Generics();
String str = d.fun("张三"); //传递字符串
int i = d.fun(30); //传递数字，自动装箱
System.out.println(str);
System.out.println(i);
}
}
通过泛型方法返回泛型类实例
class info<T extends Number>{ //在声明的地方指定泛型的上限范围
//class info<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
// public info(T var) { //构造方法
// super();
// this.var = var;
// }
public String toString(){ //覆写Object类中的toString()方法
return this.var.toString();
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
public class Generics_extends_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
info<Integer> i = fun(30); //传递整数到fun()方法
System.out.println(i.getVar());
}
public static <T extends Number> info<T> fun (T param){ //fun返回的参数类型是info<T>
info<T> temp = new info<T>(); //根据传入的数据类型实例化info对象
temp.setVar(param); //将传递的内容设置到info类中的var属性之中
return temp; //返回实例化对象
}
}
//class info<T extends Number>{ //在声明的地方指定泛型的上限范围
class info<T>{ //此处T可以是任意的标识符号，T是type的简称
private T var; //此变量的类型由外部决定
// public info(T var) { //构造方法
// super();
// this.var = var;
// }
public String toString(){ //覆写Object类中的toString()方法
return this.var.toString();
}
public T getVar() { //返回值的类型由外部决定
return var;
}
public void setVar(T var) { //设置的类型由外部指定
this.var = var;
}
}
public class Generics_extends_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
info<String> i1 = new info<String>(); //设置String为泛型类型
info<String> i2 = new info<String>(); //设置String为泛型类型
i1.setVar("HELLO"); //设置内容
i2.setVar("张三"); //设置内容
add(i1,i2);
}
public static <T> void add(info<T> i1,info<T> i2){
System.out.println(i1.getVar()+""+i2.getVar());
}
}
泛型数组
程序从fun1()方法返回一个泛型数组，在fun1()方法接收参数时使用了可变参数传递方式，然后将fun1()返回的泛型数组内容交给fun2()方法进行输出。
public class Generics_array_demo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Integer i[] = fun1(1,2,3,4,5); //返回泛型数组
fun2(i); //输出数组内容
}
public static <T> T[] fun1(T...arg){ //接收可变参数，返回泛型数组
return arg; //返回泛型数组
}
public static <T> void fun2(T param[]){
System.out.println("接收泛型数组："); //接收泛型数组
for(T t:param){
System.out.println(t+"、");
}
System.out.println();
}
}
泛型应用
一个人有联系方式、基本信息等，这些信息的类型可以通过泛型进行声明，然后传给Person
interface Generics_array_interface{ //定义一个标识接口，此接口没有定义任何方法
}
class Contact implements Generics_array_interface{ //实现Generics_array_interface接口
private String address; //联系地址
private String telephone; //联系方式
private String zipcode; //邮政编码
public Contact(String address, String telephone, String zipcode) { //构造方法
super();
this.address = address;
this.telephone = telephone;
this.zipcode = zipcode;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
public String toString(){ //覆写Object类中的toString()方法
return "联系方式："+"\n"+"联系电话："+this.telephone+"联系地址："+this.address+"邮政编码："+this.zipcode;
}
}
class Introduction implements Generics_array_interface{
private String name;
private String sex;
private int age;
public Introduction(String name, String sex, int age) { //构造方法
super();
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString(){ //覆写Object类中的toString()方法
return "基本信息："+"\n"+"姓名："+this.name+"性别："+this.sex+"年龄："+this.age;
}
}
class Person_ <T extends Generics_array_interface>{
private T info;
public Person_(T info) { //构造方法
super();
this.info = info;
}
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
@Override
public String toString() { //覆写Object类中的toString()方法
return this.info.toString();
}
}
public class Generics_array_demo {
public static void main(String[] args) {
// Integer i[] = fun1(1,2,3,4,5); //返回泛型数组
// fun2(i); //输出数组内容
Person_ <Contact> per = null; //声明Person_对象，同时指定Contact类型
per = new Person_<Contact>(new Contact("北京市","010010101010","100876"));//实例化Person_对象，同时设置信息
System.out.println(per);
}
// public static <T> T[] fun1(T...arg){ //接收可变参数，返回泛型数组
// return arg; //返回泛型数组
// }
//
// public static <T> void fun2(T param[]){
// System.out.println("接收泛型数组："); //接收泛型数组
// for(T t:param){
// System.out.println(t+"、");
// }
// System.out.println();
// }
}
本文只发表于博客园和tonglin0325的博客，作者：tonglin0325，转载请注明原文链接：https://www.cnblogs.com/tonglin0325/p/5257309.html
