public class GenericClass {
private static class Pair{
private U first;
private V second;
public Pair(U first, V second) {
this.first = first;
this.second = second;
}
public U getFirst() {
return first;
}
public V getSecond() {
return second;
}
}
public static void main(String[] args){
Pairpair = new Pair<>("zhangsan", 23);
}
}
为什么Java不直接使用普通的Object类呢 ?
public class GenericClass2 {
private static class Pair{ // Generic Class
private Object first;
private Object second;
public Pair(Object first, Object second) {
this.first = first;
this.second = second;
}
public Object getFirst() {
return first;
}
public Object getSecond() {
return second;
}
}
public static void main(String[] args){
Pair pair = new Pair("zhangsan", 23);
String name = (String) pair.getFirst();
Integer age = (Integer) pair.getSecond();
}
}
public class GenericMethod {
public static int indexOf(T[] arr, T ele){ // Generic Method
for(int i = 0; i < arr.length; i++){
if(arr[i].equals(ele))
return i;
}
return -1;
}
public static void main(String[] args){
System.out.println(indexOf(new Integer[]{1, 3, 5, 7}, 5));
System.out.println(indexOf(new String[]{"zhangsan", "lisi", "wangwu"}, "lisi"));
}
}
实际上泛型类和泛型方法没有联系:
//泛型类的泛型和泛型方法的泛型没有一点关系
public class GenericClassMethod {
public void testMethod(T t){
System.out.println(t.getClass().getName());
}
public T testMethod1(T t){
return t;
}
public static void main(String[] args){
GenericClassMethodgcm = new GenericClassMethod<>();
gcm.testMethod("generic");
Integer res = gcm.testMethod1(new Integer(10));
System.out.println(res);
}
}
// java.lang.String
// 10
三、泛型接口
接口也可以是泛型的,例如,Java中的Comparable和Comparator:
public interface Comparable {
public int compareTo(T o);
}
public interface Comparator {
int compare(T o1, T o2);
boolean equals(Object obj);
}
ublic class GenericExtends2 {
// 要进行元素的比较,要求元素必须实现Comparable接口
// 所以给类型参数设置了一个上边界Comparable,T 必须实现Comparable接口
public static T getMax(T[] arr){
T max = arr[0];
for(int i = 0; i < arr.length; i++){
if(arr[i].compareTo(max) > 0){
max = arr[i];
}
}
return max;
}
// 不过上面这么写会有警告 因为Comparable是一个泛型接口,它也需要一个类型参数,所以下面的写法比较好
// 理解: T是一种数据类型,必须实现Comparable,且必须可以与相同类型的元素进行比较
public static > T getMax2(T[] arr){
T max = arr[0];
for(int i = 0; i < arr.length; i++){
if(arr[i].compareTo(max) > 0){
max = arr[i];
}
}
return max;
}
}
public static void swap(ArrayList arr, int i, int j){
Object tmp = arr.get(i);
arr.set(i, arr.get(j)); // can't change the value
arr.set(j, tmp);
}
再看一个例子:在方法传递参数的时候,不能往参数中添加元素:
public class GenericExtends4 {
private static class Fruit {}
private static class Apple extends Fruit{}
private static class Pear extends Fruit{}
private static class FuShiApple extends Apple{}
static class Clazz{ //创建的类必须是Fruit的子类//为了自己类中使用这个类
}
public static void main(String[] args) {
Clazzt = new Clazz<>(); // <= 关系
Clazzt2 = new Clazz<>();
Clazzt3 = new Clazz<>();
Clazzt4= new Clazz<>();
//调用方法
List list1 = new ArrayList<>();
add(list1);
List list2 = new ArrayList<>();
add(list2);
List list3 = new ArrayList<>();
add(list3);
List list4 = new ArrayList(); //存放Apple以及它的子类
add(list4);
List list5 = new ArrayList<>();
add(list5);
//?为什么错误 : 因为 ? 等同于? extends Object :不是<= Fruit的 下面两个是一样的
Listlist6 = new ArrayList<>();
Listlist7 = new ArrayList<>();
//add(list6); // err
//add(list7); // err
}
// 为了保证向下兼容的一致性,不能添加元素
public static void add(List list) {
/** 不能往里面加这样的对象 不能用于添加数据
list.add(new Fruit());
list.add(new Apple());
list.add(new Pear());
*/
list.add(null);
}
}
// S和D要么相同,要么S是D的子类,否则类型不兼容,有编译错误
public static void copy(ArrayList dest, ArrayList src){
for(int i=0; i void copy2(ArrayList dest, ArrayList src){
for(int i=0; i
3)、第三条限制: 如果返回值依赖于类型参数,也不能用通配符
//不能使用通配符,只能用类型参数,因为要返回
public static > T max(ArrayList arr){
T max = arr.get(0);
for(int i = 1; i < arr.size(); i++){
if(arr.get(i).compareTo(max)>0){
max = arr.get(i);
}
}
return max;
}
public class GenericSuper2 {
private static class Fruit {}
private static class Apple extends Fruit{}
private static class Pear extends Fruit{}
private static class FuShiApple extends Apple{}
static class Clazz{ //创建的类必须是Fruit的子类//为了自己类中使用这个类
}
public static void main(String[] args) {
Listlist1 = new ArrayList<>();
add(list1);
Listlist2 = new ArrayList<>();
add(list2);
List
public static > void sort(List list)
public static void sort(List list, Comparator c)
public static void copy(List dest, List src)
public static T max(Collection coll, Comparator comp)
public class GenericWipe {
public static void main(String[] args){
List slist = new ArrayList<>();
List ilist = new ArrayList<>();
System.out.println(slist.getClass() == ilist.getClass());
}
}
利用javascript读取表单数据,可以利用以下三种方法获取:
1、通过表单ID属性:var a = document.getElementByIdx_x_x("id");
2、通过表单名称属性:var b = document.getElementsByName("name");
3、直接通过表单名字获取:var c = form.content.
什么是Spring Data Mongo
Spring Data MongoDB项目对访问MongoDB的Java客户端API进行了封装,这种封装类似于Spring封装Hibernate和JDBC而提供的HibernateTemplate和JDBCTemplate,主要能力包括
1. 封装客户端跟MongoDB的链接管理
2. 文档-对象映射,通过注解:@Document(collectio
The insertion algorithm for 2-3 trees just described is not difficult to understand; now, we will see that it is also not difficult to implement. We will consider a simple representation known