Genérico
Derivación genérica
Ejemplo: demostración de transformación descendente
package Project.Study.Genericity;
class Point{ //定义坐标类
private Object x; //可以保存任意数据
private Object y; //可以保存任意数据
public Object getX() {
return x;
}
public Object getY() {
return y;
}
public void setX(Object x) {
this.x = x;
}
public void setY(Object y) {
this.y = y;
}
}
public class Test {
public static void main(String args[]){
Point p=new Point(); //实例化Point类数据
p.setX("东经100度"); //设置坐标数据
p.setY(10); //设置坐标数据
System.out.println("x坐标："+p.getX()+"y坐标"+p.getY());
//根据设置好的坐标取出数据进行操作
String x=(String)p.getX(); //取出坐标数据
String y=(String)p.getY(); //取出坐标数据
System.out.println("x坐标："+x+"y坐标"+y);
}
}
//结果
//Exception in thread "main" java.lang.ClassCastException: class //java.lang.Integer cannot be cast to class java.lang.String //(java.lang.Integer and java.lang.String are in module java.base of //loader 'bootstrap')
// at Project.Study.Genericity.Test.main(Test.java:30)
//x坐标：东经100度y坐标10
Ejemplo: use genéricos para reducir las operaciones de transformación
package Project.Study.Genericity;
//此时的T在Point类定义上只表示一个标记，在使用时需要为其设置具体的类型
class Point<T>{
private T x; //此属性的类型不知道，由Point类使用时的动态决定
private T y; //此属性的类型不知道，由Point类使用时的动态决定
public T getX() {
return x;
}
public T getY() {
return y;
}
public void setX(T x) {
this.x = x;
}
public void setY(T y) {
this.y = y;
}
}
public class Test {
public static void main(String args[]){
Point<String> p=new Point<String>(); //实例化Point类数据，设置泛型为String
p.setX("东经100度");
p.setY("北纬20度");
System.out.println("x坐标："+p.getX()+"y坐标"+p.getY());
String x=p.getX(); //取出坐标数据，不再需要强制类型转换
String y=p.getY(); ////取出坐标数据，不再需要强制类型转换
System.out.println("x坐标："+x+"y坐标"+y);
}
}
//结果
//x坐标：东经100度y坐标10
//x坐标：东经100度y坐标10
Sugerencia: puede definir varias etiquetas genéricas en una clase.
class Point<P,R>{
public R fun(P p){
return null;
}
}
Cabe señalar que si desea utilizar genéricos, los tipos que puede adoptar solo pueden ser clases, es decir, no pueden ser tipos básicos, solo tipos de referencia.
Comodín
Ejemplo: uso del comodín "?"
package Project.Study.Genericity;
class Message<T>{
private T msg;
public void setMsg(T msg){
this.msg=msg;
}
public T getMsg() {
return msg;
}
}
public class Test1 {
public static void main(String args[]){
Message<Integer>message1=new Message<>();
Message<String>message2=new Message<>();
message1.setMsg(30);
message2.setMsg("Hello World");
fun1(message1); //引用传递
fun2(message2);
}
public static void fun1(Message<?> temp){ //不能设置，但是可以取出
System.out.println(temp.getMsg());
}
public static void fun2(Message temp){ //默认使用Object作为泛型类型，可以在方法中随意修改对象内容(即使类型不符合)，这种做法是不严谨的
temp.setMsg(100);
System.out.println(temp.getMsg());
}
}
//结果
//30
//100
Por el fun2 () anterior, se debe usar el comodín "?" Para restringir esta operación de modificación arbitraria de datos. Por lo tanto, el tipo genérico establecido por "?" Solo significa que se puede eliminar, pero no se puede configurar . Una vez que se establece el contenido, aparecerá un mensaje de error cuando se compila el programa.
"? Extiende clase": establece el límite superior del genérico, que se puede utilizar en los parámetros de declaración y método;
? extiende el número: significa que puede establecer un número o una subclase de número (entero, doble, ...)
Ejemplo: establecer un límite superior para genéricos
package Project.Study.Genericity;
class Message<T extends Number>{ //设置泛型上限，只能是Number或Number子类
private T msg;
public void setMsg(T msg){
this.msg=msg;
}
public T getMsg() {
return msg;
}
}
public class Test1 {
public static void main(String args[]){
Message<Integer>message1=new Message<>(); //Integer是Number子类
message1.setMsg(30);
fun1(message1); //引用传递
}
public static void fun1(Message<? extends Number> temp){ //定义泛型上限
System.out.println(temp.getMsg());
}
}
//结果
//30
"? Super class": establece el límite inferior de genéricos, utilizado en los parámetros del método;
? super String: significa que solo se puede establecer String o su objeto padre.
Ejemplo: establecer el límite inferior de genéricos
package Project.Study.Genericity;
class Message<T>{ //定义泛型
private T msg;
public void setMsg(T msg){
this.msg=msg;
}
public T getMsg() {
return msg;
}
}
public class Test1 {
public static void main(String args[]){
Message<String>message1=new Message<>();
message1.setMsg("Hello World"); //设置属性内容
fun1(message1); //引用传递
}
public static void fun1(Message<? super String> temp){ //定义泛型下限
System.out.println(temp.getMsg());
}
}
//结果
//Hello World
Interfaz genérica
En cualquier caso, si desea utilizar una interfaz, debe definir la subclase correspondiente y, para una subclase de interfaz genérica, existen las dos implementaciones siguientes.
Implementación uno: continúe estableciendo etiquetas genéricas en subclases
Ejemplo:
package Project.Study.Genericity;
interface IMessage<T>{ //定义泛型接口
public void print(T t);
}
class MessageImpl<S>implements IMessage<S>{ //在子类继续设置泛型，此泛型也作为接口中的泛型类型
public void print(S t){
System.out.println(t);
}
}
public class Test2 {
public static void main(String[] args){
IMessage<String>msg=new MessageImpl<String>();
msg.print("HelloWorld");
}
}
//结果
//HelloWorld
Método de implementación 2: no se establece ningún tipo genérico en la subclase, pero se define explícitamente un tipo genérico para la interfaz de clase principal.
package Project.Study.Genericity;
interface IMessage1<T>{
public void print(T t);
}
class MessageImpl1 implements IMessage1<String>{
public void print(String t){
System.out.println(t);
}
}
public class Test3 {
public static void main(String [] args){
IMessage1<String>msg=new MessageImpl1();
msg.print("HelloWorld");
}
}
//结果
//HelloWorld
Método genérico
package Project.Study.Genericity;
public class Test4 {
public static void main(String [] args){
String str=fun("HelloWorld");
System.out.println(str.length());
}
/**
* 此方法为泛型方法，T的类型由传入的参数类型决定
* 必须在方法返回值前明确定义泛型标记
* @param t 参数类型，同时也决定了返回值类型
* @param <T>
* @return 直接返回设置进来的内容
*/
public static <T>T fun(T t){
return t;
}
}
//结果
//10
