做邪恶网站衱抓判多久安徽百度关键词优化

一、泛型的概念

泛型是JAVA中的一个重要的概念，它允许你在编译时指定数据类型，从而使得代码更加灵活，更加通用。通过泛型，你可以在通用代码上操作不同数据类型，使得代码更加具有通用性。

二、泛型的使用场景

1、泛型接口：

泛型接口允许你定义一个接口，该接口可以应用于不同的数据类型的对象。例如：List是一个接口，但是List可以应用于List、List等。

2、泛型类：

泛型类允许你定义一个类，该类可以应用于不同的数据类型的对象。例如：ArrayList是一个类，但是ArrayList可以应用于ArrayList、ArrayList等。

3、泛型方法：

泛型方法允许你定义一个方法，并在该方法返回值类型前边使用泛型限制，例如：List中的<T> T[] toArray(T[] var1);方法的定义。

4、泛型参数：

泛型参数用来限制方法参数的数据类型，通过泛型参数，可以灵活的处理不同数据类型的参数。例如：List.add可以接收Integer类型的数据，也可以接收String类型的数据。

三、泛型的应用

假设有一个打印场景，传入的打印内容是不确定的，需要根据实际场景去决定，那么此时就需要使用泛型来解决这个问题， 通过泛型，可以定义一个方法，让方法可以接收不同类型的参数

1.1、JavaGenerics.java

/**  * java中的泛型使用：  * 假设有一个打印场景，传入的打印内容是不确定的，需要根据实际场景去决定，那么此时就需要使用泛型来解决这个问题，  * 通过泛型，可以定义一个方法，让方法可以接收不同类型的参数  */  
public class JavaGenerics {  /**  * 测试打印入口：  * 如果不使用泛型，那么需要使用两个方法分别打印字符串和数值，如果想要  * 打印其他类型的时候，那么就需要再定义一个方法，这样就会造成代码冗余  */  @Test  public void testPrint() {  // 单独定义具体的类实现Integer打印  IntegerPrinter integerPrinter = new IntegerPrinter(123);  integerPrinter.print();  // 单独定义具体的类实现String打印  StringPrinter stringPrinter = new StringPrinter("Hello");  stringPrinter.print();  // 单独定义方法实现String打印  printString("Hello");  // 单独定义方法实现Integer打印  printInteger(100);  }  /**  * 测试打印入口：  * 使用了泛型之后，只需要定义一个方法，就可以同时打印字符串和数值，  * 这样就可以解决代码冗余的问题，并且，如果需要打印其他类型，只需要定义一个方法即可，不需要再定义其他方法，  *  */    @Test  public void testGenericsPrint() {  // 只要定义一个类实现，接受一个泛型T，通过传递的T的类型，就可以实现打印不同类型的数据  GenericsPrinter<String> stringGenericsPrinter = new GenericsPrinter<>("Hello");  stringGenericsPrinter.print();  GenericsPrinter<Integer> integerGenericsPrinter = new GenericsPrinter<>(123);  integerGenericsPrinter.print();  // 只要定义一个方法实现，接受一个泛型T，通过传递的T的类型，就可以实现打印不同类型的数据  printGenerics("Hello");  printGenerics(123);  // 使用通配符后，List中的数据类型可以不受限制，可以灵活处理，只要符合通配符的范围即可。  List<Integer> integers = new ArrayList<>();  integers.add(123);  integers.add(456);  printGenerics(integers);  List<String> string = new ArrayList<>();  string.add("123");  string.add("456");  printGenerics(string);  // 这里直接会报错，因为已经限制了GenericsPrinter1传入的泛型T为Number的子类或者本身  // GenericsPrinter1<String> stringGenericsPrinter1 = new GenericsPrinter1<>();  // 这里直接会报错，因为已经限制了GenericsPrinter2传入的泛型T为Number的子类或者本身并且必须是实现了Serializable的子类  // GenericsPrinter2<String> stringGenericsPrinter2 = new GenericsPrinter2<>();  // 第一个参数传入的泛型T必须为Number的子类或者本身并且必须是实现了Serializable的子类  // 第二个参数传入的泛型K没有限制，可以传递String类型也可以传递Integer  GenericsPrinter3<Integer, String> stringGenericsPrinter3 = new GenericsPrinter3<>(123, "hello word");  stringGenericsPrinter3.print();  }  /**  * 打印数值  *  * @param integer 打印数值内容  */  private void printInteger(Integer integer) {  System.out.println("Integer: " + integer);  }  /**  * 打印字符串  *  * @param string 打印字符串内容  */  private void printString(String string) {  System.out.println("String: " + string);  }  /**  * 打印内容：因为T在JAVA中并不是一个类型，只是一个占位符，  * 那么需要明确告诉JAVA这里的T是一个泛型，才能正常编译通过，  * 做法是在方法的返回值前边加上<T>。  *  * @param context 打印内容，这里的T也可以是任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型，  *          并且可以使用extend来进行限制类型。参考GenericsPrinter3的使用  */  private <T> void printGenerics(T context) {  System.out.println("context: " + context);  }  /**  * 打印内容：如果要打印这种List的情况，但是又不想限制List的类型,那么就使用  * 通配符<?>来表示，这样就可以打印List中的任意类型了。  *  * @param context 打印内容，使用通配符<?>来表示，这样就可以打印List中的任意类型了，  *                通配符也可以使用extend和super来表示范围，如：  *                <? extends Number>表示泛型为Number或Number子类的类型，  *                <? super Number>表示泛型为Number或Number父类的类型  */  private void printGenerics(List<?> context) {  System.out.println("context: " + context);  }  
}

1.2、StringPrinter.java

/**  * StringPrinter：专门用于打印字符串的类  */  
public class StringPrinter {  String string;  public StringPrinter(String string) {  this.string = string;  }  public void print() {  System.out.println(string);  }  
}

1.3、IntegerPrinter.java

/**  * IntegerPrinter：专门用于打印整数的类  */  
public class IntegerPrinter {  Integer integer;  public IntegerPrinter(Integer integer) {  this.integer = integer;  }  public void print() {  System.out.println(integer);  }  
}

1.4、GenericsPrinter.java

/**  *  泛型类：泛型类就是将泛型定义在类上，泛型类的类型参数只能被使用在类和接口中  *  * @param <T> 泛型  */  
public class GenericsPrinter<T> {  T context;  public GenericsPrinter(T context) {  this.context = context;  }  public void print() {  System.out.println(context);  }  
}  /**  * 有界限的泛型：限制传入的泛型类型必须继承自Number类  *  * @param <T> 泛型  */  
class GenericsPrinter1<T extends Number> {  T context;  public GenericsPrinter1(T context) {  this.context = context;  }  public void print() {  System.out.println(context);  }  
}  /**  * 有界限的泛型：限制传入的泛型类型必须继承自Number类和Serializable类  * 注意：Number & Serializable顺序不能错，因为不管泛型参数是抽象类还是接口都必须使用extends关键字，  * 否则编译器会报错，由于JAVA的单一继承性，抽象类必须在前边且只有一个，使用&连接多个接口。  *  * @param <T> 泛型  */  
class GenericsPrinter2<T extends Number & Serializable> {  T context;  public GenericsPrinter2(T context) {  this.context = context;  }  public void print() {  System.out.println(context);  }  
}  /**  * 有界限的泛型：可以传递多个泛型参数，  * 注意：Number & Serializable顺序不能错，因为不管泛型参数是抽象类还是接口都必须使用extends关键字，  * 否则编译器会报错，由于JAVA的单一继承性，抽象类必须在前边且只有一个，使用&连接多个接口。  *  * @param <T> 泛型，限制传入的泛型类型必须继承自Number类和Serializable类  * @param <K> 泛型，无限制  */  
class GenericsPrinter3<T extends Number & Serializable, K> {  T context;  K context1;  public GenericsPrinter3(T context, K context1) {  this.context = context;  this.context1 = context1;  }  public void print() {  System.out.println(context.intValue());  System.out.println(context);  System.out.println(context1);  }  
}