微冷...
微冷...

java泛型（二） 泛型的内部原理：类型擦除以及类型擦除带来的问题

一、Java泛型的实现方法：类型擦除

前面已经说了，Java 的泛型是伪泛型。为什么说 Java 的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出（type erasure）。

Java 中的泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器编译的时候去掉。这个过程就称为类型擦除。

如在代码中定义的 List 和 List 等类型，在编译后都会变成 List。JVM 看到的只是 List，而由泛型附加的类型信息对 JVM 来说是不可见的。Java 编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是 Java 的泛型实现方法与 C++ 模版机制实现方式之间的重要区别。

可以通过两个简单的例子，来证明 Java 泛型的类型擦除。

例 1
public class Test4 {
	public static void main(String[] args) {
		ArrayList<String> arrayList1 = new ArrayList<String>();
		arrayList1.add("abc");
		ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
		arrayList2.add(123);
		System.out.println(arrayList1.getClass() == arrayList2.getClass());
	}
}

在这个例子中，我们定义了两个 ArrayList 数组，不过一个是 ArrayList 泛型类型，只能存储字符串。一个是 ArrayList< Integer>泛型类型，只能存储整型。最后，我们通过 arrayList1 对象和 arrayList2 对象的 getClass 方法获取它们的类的信息，最后发现结果为 true。说明泛型类型String 和 Integer 都被擦除掉了，只剩下了原始类型。

例 2
public class Test4 {
	public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
		ArrayList<Integer> arrayList3 = new ArrayList<Integer>();
		arrayList3.add(1);//这样调用add方法只能存储整型，因为泛型类型的实例为Integer
		//通过反射向arrayList3对象中存储字符串"asd"
		arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");
		for (int i = 0; i < arrayList3.size(); i++) {
			System.out.println(arrayList3.get(i));
	}
}

在程序中定义了一个 ArrayList 泛型类型实例化为 Integer 的对象，如果直接调用 add 方法，那么只能存储整型的数据。不过当我们利用反射调用 add 方法的时候，却可以存储字符串。这说明了Integer 泛型实例在编译之后被擦除了，只保留了原始类型。

二、类型擦除后保留的原始类型

在上面，两次提到了原始类型，什么是原始类型？原始类型（raw type）就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。 无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除（crased），并使用其限定类型（无限定的变量用Object）替换。

例 3
class Pair<T> {
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T  value) {
        this.value = value;
    }
}

Pair 的原始类型为：

class Pair {
	private Object value;
	public Object getValue() {
		return value;
	}
	public void setValue(Object  value) {
		this.value = value;
	}
}

因为在 Pair 中，T 是一个无限定的类型变量，所以用 Object 替换。其结果就是一个普通的类，如同泛型加入 Java 编程语言之前已经实现的那样。在程序中可以包含不同类型的 Pair，如Pair 或 Pair。但是，擦除类型后它们就成为原始的 Pair 类型了，原始类型都是 Object。

从上面的那个例2中，我们也可以明白 ArrayList 被擦除类型后，原始类型也变成了Object，所以通过反射我们就可以存储字符串了。

如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。比如 Pair 这样声明：

例 4
public class Pair<T extends Comparable & Serializable> { ... }

那么原始类型就是 Comparable。

注意： 如果 Pair 这样声明 public class Pair ，那么原始类型就用 Serializable 替换，而编译器在必要的时要向 Comparable 插入强制类型转换。为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾。

要区分原始类型和泛型变量的类型：

在调用泛型方法的时候，可以指定泛型，也可以不指定泛型。

在不指定泛型的情况下，泛型变量的类型为该方法中的几种参数变量类型的同一个父类的最小级，直到Object。

在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。

public class Test2 {
	public static void main(String[] args) {
		/**不指定泛型的时候*/
		int i = Test2.add(1, 2); //这两个参数都是Integer，所以T为Integer类型
		Number f = Test2.add(1, 1.2);//这两个参数一个是Integer，一个是Double，所以取同一父类的最小级，为Number
		Object o = Test2.add(1, "asd");//这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object
 
         /**指定泛型的时候*/
		int a = Test2.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
		int b = Test2.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Double
		Number c = Test2.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Double
	}
	
	//这是一个简单的泛型方法
	public static <T> T add(T x, T y){
		return y;
	}
}

其实在泛型类中，不指定泛型的时候，也差不多，只不过这个时候的泛型类型为 Object。比如ArrayList 中，如果不指定泛型，那么这个 ArrayList 中可以放任意类型的对象。

举例：

public static void main(String[] args) {
	ArrayList arrayList = new ArrayList();
	arrayList.add(1);
	arrayList.add("121");
	arrayList.add(new Date());
}

三、类型擦除引起的问题及解决方法

因为种种原因，Java 不能实现真正的泛型，只能使用类型擦除来实现伪泛型，这样虽然不会有类型膨胀的问题，但是也引起了许多新的问题。所以，Sun 对这些问题作出了许多限制，避免我们犯各种错误。

1、先检查，再编译，以及检查编译的对象和引用传递的问题

既然说类型变量会在编译的时候擦除掉，那为什么我们往 ArrayList arrayList = new ArrayList(); 所创建的数组列表 arrayList 中，不能使用 add 方法添加整型呢？不是说泛型变量 Integer 会在编译时候擦除变为原始类型 Object 吗？为什么不能存别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？

Java是如何解决这个问题的呢？Java编译器是通过先检查代码中泛型的类型，然后再进行类型擦除，在进行编译的。

举个例子说明：

public static  void main(String[] args) {
	ArrayList<String> arrayList = new ArrayList<String>();
	arrayList.add("123");
	arrayList.add(123);//编译错误
}

在上面的程序中，使用 add 方法添加一个整型，在 Eclipse 中，直接就会报错，说明这就是在编译之前的检查。因为如果是在编译之后检查，类型擦除后，原始类型为 Object，是应该运行任意引用类型的添加的。可实际上却不是这样，这恰恰说明了关于泛型变量的使用，是会在编译之前检查的。

那么，这么类型检查是针对谁的呢？我们先看看参数化类型与原始类型的兼容：

以 ArrayList 举例子，以前的写法：

ArrayList arrayList = new ArrayList();

现在的写法：

ArrayList<String>  arrayList = new ArrayList<String>();

如果是与以前的代码兼容，各种引用传值之间，必然会出现如下的情况：

ArrayList<String> arrayList1 = new ArrayList(); //第一种情况

ArrayList arrayList2 = new ArrayList<String>();//第二种情况

这样是没有错误的，不过会有个编译时警告。

不过在第一种情况，可以实现与完全使用泛型参数一样的效果，第二种则完全没效果。

因为，本来类型检查就是编译时完成的。new ArrayList(); 只是在内存中开辟一个存储空间，可以存储任何的类型对象。而真正涉及类型检查的是它的引用，因为我们是使用它引用 arrayList1 来调用它的方法，比如说调用 add() 方法，所以 arrayList1 引用能完成泛型类型的检查，而引用 arrayList2 没有使用泛型，所以不行。

举例子：

public class Test10 {
	public static void main(String[] args) {
		ArrayList<String> arrayList1 = new ArrayList();
		arrayList1.add("1");//编译通过
		arrayList1.add(1);//编译错误
		String str1 = arrayList1.get(0);//返回类型就是String
		
		ArrayList arrayList2 = new ArrayList<String>();
		arrayList2.add("1");//编译通过
		arrayList2.add(1);//编译通过
		Object object = arrayList2.get(0);//返回类型就是Object
		
		new ArrayList<String>().add("11");//编译通过
		new ArrayList<String>().add(22);//编译错误
		String string = new ArrayList<String>().get(0);//返回类型就是String
	}
}

通过上面的例子，我们可以明白，类型检查就是针对引用的，谁是一个引用，用这个引用调用泛型方法，就会对这个引用调用的方法进行类型检测，而无关它真正引用的对象。

从这里，我们可以再讨论下泛型中参数化类型为什么不考虑继承关系。

在 Java 中，像下面形式的引用传递是不允许的：

ArrayList<String> arrayList1 = new ArrayList<Object>();//编译错误
ArrayList<Object> arrayList1 = new ArrayList<String>();//编译错误

我们先看第一种情况，将第一种情况拓展成下面的形式：

ArrayList<Object> arrayList1 = new ArrayList<Object>();
arrayList1.add(new Object());
arrayList1.add(new Object());
ArrayList<String> arrayList2 = arrayList1;//编译错误

实际上，在第 4 行代码的时候，就会有编译错误。那么，我们先假设它编译没错。那么当我们使用arrayList2 引用用 get() 方法取值的时候，返回的都是 String 类型的对象（上面提到了，类型检测是根据引用来决定的。），可是它里面实际上已经被我们存放了 Object 类型的对象，这样，就会有ClassCastException了。所以为了避免这种极易出现的错误，Java 不允许进行这样的引用传递。（这也是泛型出现的原因，就是为了解决类型转换的问题，我们不能违背它的初衷）。

在看第二种情况，将第二种情况拓展成下面的形式：

ArrayList<String> arrayList1 = new ArrayList<String>();
arrayList1.add(new String());
arrayList1.add(new String());
ArrayList<Object> arrayList2 = arrayList1;//编译错误

没错，这样的情况比第一种情况好的多，最起码，在我们用 arrayList2 取值的时候不会出现ClassCastException，因为是从String转换为Object。可是，这样做有什么意义呢，泛型出现的原因，就是为了解决类型转换的问题。我们使用了泛型，到头来，还是要自己强转，违背了泛型设计的初衷。所以 Java 不允许这么干。再说，你如果又用 arrayList2 往里面 add() 新的对象，那么到时候取得时候，我怎么知道我取出来的到底是 String 类型的，还是 Object 类型的呢？

所以，要格外注意，泛型中的引用传递的问题。

2、自动类型转换

因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？看下 ArrayList 和 get 方法：

public E get(int index) {
	RangeCheck(index);
	return (E) elementData[index];
}

可以看到，在 return 之前，会根据泛型变量进行强转。

写了个简单的测试代码：

public class Test {
	public static void main(String[] args) {
		ArrayList<Date> list = new ArrayList<Date>();
		list.add(new Date());
		Date myDate = list.get(0);
	}
}

然后反编了下字节码，如下所示：

public class Test {
  public Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."":()V
       7: astore_1
       8: aload_1
       9: new           #4                  // class java/util/Date
      12: dup
      13: invokespecial #5                  // Method java/util/Date."":()V
      16: invokevirtual #6                  // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
      19: pop
      20: aload_1
      21: iconst_0
      22: invokevirtual #7                  // Method java/util/ArrayList.get:(I)Ljava/lang/Object;
      25: checkcast     #4                  // class java/util/Date
      28: astore_2
      29: return
}

看第22 ，它调用的是 ArrayList.get() 方法，方法返回值是 Object，说明类型擦除了。然后第25，它做了一个 checkcast 操作，即检查类型 #4， 在上面找#4引用的类型，他是 9: new #4 // class java/util/Date，是一个Date类型，即做Date类型的强转。所以不是在get方法里强转的，是在你调用的地方强转的。

附关于checkcast的解释：

checkcast checks that the top item on the operand stack (a reference to an object or array) can be cast to a given type. For example, if you write in Java:

return ((String)obj);

then the Java compiler will generate something like:

aload_1 ; push -obj- onto the stack
checkcast java/lang/String ; check its a String
areturn ; return it

checkcast is actually a shortand for writing Java code like:

if (! (obj == null || obj instanceof <class>)) {
throw new ClassCastException();
}
// if this point is reached, then object is either null, or an instance of
//  or one of its superclasses.

3、类型擦除与多态的冲突和解决方法

现在有这样一个泛型类：

class Pair<T> {
	private T value;
	public T getValue() {
		return value;
	}
	public void setValue(T value) {
		this.value = value;
	}
}

然后我们想要一个子类继承它：

class DateInter extends Pair<Date> {
	@Override
	public void setValue(Date value) {
		super.setValue(value);
	}
	@Override
	public Date getValue() {
		return super.getValue();
	}
}

在这个子类中，我们设定父类的泛型类型为Pair。在子类中，我们覆盖了父类的两个方法，我们的原意是这样的：将父类的泛型类型限定为Date，那么父类里面的两个方法的参数都为Date类型，代码如下所示：

public Date getValue() {
	return value;
}
public void setValue(Date value) {
	this.value = value;
}

所以，我们在子类中重写这两个方法一点问题也没有，实际上，从他们的 @Override 标签中也可以看到，一点问题也没有，实际上是这样的吗？

分析：

实际上，类型擦除后，父类的的泛型类型全部变为了原始类型 Object，所以父类编译之后会变成下面的样子：

class Pair {
	private Object value;
	public Object getValue() {
		return value;
	}
	public void setValue(Object  value) {
		this.value = value;
	}
}

再看子类 DateInter 的两个重写的方法的类型：

@Override
public void setValue(Date value) {
	super.setValue(value);
}
@Override
public Date getValue() {
	return super.getValue();
}

先来分析 setValue 方法，父类的类型是 Object，而子类的类型是 Date，参数类型不一样，这普通的继承关系中，根本就不会是重写，而是重载。

我们在一个main方法测试一下：

public static void main(String[] args) throws ClassNotFoundException {
	DateInter dateInter = new DateInter();
	dateInter.setValue(new Date());                
    dateInter.setValue(new Object());//编译错误
}

如果是重载，那么子类中有两个 setValue 方法，一个是参数 Object 类型，一个是 Date 类型，可是我们发现，根本就没有这样的一个子类继承自父类的 Object 类型参数的方法。所以说，确实是重写了，而不是重载了。

为什么会这样呢？原因是这样的，我们传入父类的泛型类型是 Date，Pair，我们的本意是将泛型类变为如下：

class Pair {
	private Date value;
	public Date getValue() {
		return value;
	}
	public void setValue(Date value) {
		this.value = value;
	}
}

然后在子类中重写参数类型为 Date 的那两个方法，实现继承中的多态。可是由于种种原因，虚拟机并不能将泛型类型变为 Date，只能将类型擦除掉，变为原始类型 Object。这样，我们的本意是进行重写，实现多态。可是类型擦除后，只能变为了重载。这样，类型擦除就和多态有了冲突。JVM 知道你的本意吗？知道！！！可是它能直接实现吗，不能！！！如果真的不能的话，那我们怎么去重写我们想要的 Date 类型参数的方法啊。

于是 JVM 采用了一个特殊的方法，来完成这项功能，那就是桥方法。

首先，我们用 javap -c className 的方式反编译下 DateInter 子类的字节码，结果如下：

class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {
  com.tao.test.DateInter();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method com/tao/test/Pair."":()V
       4: return
 
  public void setValue(java.util.Date);  //我们重写的setValue方法
    Code:
       0: aload_0
       1: aload_1
       2: invokespecial #16                 // Method com/tao/test/Pair.setValue:(Ljava/lang/Object;)V
       5: return
 
  public java.util.Date getValue();    //我们重写的getValue方法
    Code:
       0: aload_0
       1: invokespecial #23                 // Method com/tao/test/Pair.getValue:()Ljava/lang/Object;
       4: checkcast     #26                 // class java/util/Date
       7: areturn
 
  public java.lang.Object getValue();     //编译时由编译器生成的桥方法
    Code:
       0: aload_0
       1: invokevirtual #28                 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法;
       4: areturn
 
  public void setValue(java.lang.Object);   //编译时由编译器生成的桥方法
    Code:
       0: aload_0
       1: aload_1
       2: checkcast     #26                 // class java/util/Date
       5: invokevirtual #30                 // Method setValue:(Ljava/util/Date;   去调用我们重写的setValue方法)V
       8: return
}

从编译的结果来看，我们本意重写 setValue 和 getValue 方法的子类，竟然有4个方法，其实不用惊奇，最后的两个方法，就是编译器自己生成的桥方法。可以看到桥方法的参数类型都是 Object，也就是说，子类中真正覆盖父类两个方法的就是这两个我们看不到的桥方法。而打在我们自己定义的setvalue 和 getValue 方法上面的 @Oveerride 只不过是假象。而桥方法的内部实现，就只是去调用我们自己重写的那两个方法。所以，虚拟机巧妙的使用了桥方法，来解决了类型擦除和多态的冲突。

不过，要提到一点，这里面的 setValue 和 getValue 这两个桥方法的意义又有不同。setValue 方法是为了解决类型擦除与多态之间的冲突，而 getValue 却有普遍的意义，怎么说呢，如果这是一个普通的继承关系，那么父类的 getValue 方法如下：

public Object getValue() {
	return super.getValue();
}

而子类重写的方法是：

public Date getValue() {
	return super.getValue();
}

其实这在普通的类继承中也是普遍存在的重写，这就是协变。

并且，还有一点也许会有疑问，子类中的桥方法 Object getValue() 和 Date getValue() 是同时存在的，可是如果是常规的两个方法，他们的方法签名是一样的。如果是我们自己编写 Java 代码，这样的代码是无法通过编译器的检查的，但是虚拟机却是允许这样做的，因为虚拟机通过参数类型和返回类型来确定一个方法，所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情，然后交给虚拟器去区分。

4、泛型类型变量不能是基本数据类型

不能用类型参数替换基本类型。就比如，没有 ArrayList，只有 ArrayList。因为当类型擦除后，ArrayList 的原始类型变为 Object，但是 Object 类型不能存储 double 值，只能引用 Double 的值。

5、运行时类型查询

举个例子：

ArrayList<String> arrayList = new ArrayList<String>();

因为类型擦除之后，ArrayList 只剩下原始类型，泛型信息 String 不存在了。那么，运行时进行类型查询的时候使用下面的方法是错误的：

if(arrayList instanceof ArrayList<String>)

Java 限定了这种类型查询的方式，比如下面的判断是合法的：

if(arrayList instanceof ArrayList<?>) //true

？ 是通配符的形式 ，将在后面一篇中介绍。

6、异常中使用泛型的问题

1. 不能抛出也不能捕获泛型类的对象。事实上，泛型类扩展 Throwable 都不合法。例如下面的定义将不会通过编译：
public class Problem<T> extends Exception{......}

为什么不能扩展 Throwable，因为异常都是在运行时捕获和抛出的，而在编译的时候，泛型信息全都会被擦除掉。那么，假设上面的编译可行。那么，在看下面的定义：

try{
}catch(Problem<Integer> e1){
...
}catch(Problem<Number> e2){
...
}

类型信息被擦除后，那么两个地方的 catch 都变为原始类型 Object。也就是说，这两个地方的 catch 变的一模一样，就相当于下面的这样：

try{
}catch(Problem<Object> e1){
...
}catch(Problem<Object> e2){
...
}

这个当然就是不行的。就好比，catch 两个一模一样的普通异常，不能通过编译一样：

try{
}catch(Exception e1){
...
}catch(Exception  e2){//编译错误
...
2. 不能在 catch 子句中使用泛型变量
public static <T extends Throwable> void doWork(Class<T> t){
	try{
        ...
    }catch(T e){ //编译错误
        ...
    }
}

因为泛型信息在编译的时候已经变为原始类型，也就是说上面的 T 会变为原始类型 Throwable，那么如果可以在 catch 子句中使用泛型变量，那么，下面的定义呢：

public static <T extends Throwable> void doWork(Class<T> t){
	try{
          ...
	}catch(T e){ //编译错误
          ...
	}catch(IndexOutOfBoundsException e){
	}                         
}

根据异常捕获的原则，一定是子类在前面，父类在后面。那么上面就违背了这个原则。即使你在使用该静态方法的时候 T 是 ArrayIndexOutofBoundsException，在编译之后还是会变成 Throwable，Throwable 是 IndexOutOfBoundsException 的超类，违背了异常捕获的原则。所以 Java 为了避免这样的情况，禁止在 catch 子句中使用泛型变量。

但是在异常声明中可以使用类型变量。下面方法是合法的：

public static<T extends Throwable> void doWork(T t) throws T {
     try{
         ...
     }catch(Throwable realCause){
         t.initCause(realCause);
         throw t; 
     }
}

7、数组（这个不属于类型擦除引起的问题）

不能声明参数化类型的数组。如：

Pair<String>[] table = new Pair<String>[10]; //ERROR

这是因为擦除后，table 的类型变为 Pair[]，可以转化成一个 Object[]。

Object[] objarray = table;

数组可以记住自己的元素类型，下面的赋值会抛出一个 ArrayStoreException 异常。

objarray[0] = "Hello"; //ERROR

对于泛型而言，擦除降低了这个机制的效率。下面的赋值可以通过数组存储的检测，但仍然会导致类型错误。 出于这些原因，不允许创建参数化类型的数组。

objarray[0] = new Pair<Employee>();

提示：如果需要收集参数化类型对象，直接使用 ArrayList:ArrayList> 最安全且有效。

8、泛型类型的实例化

不能实例化泛型类型。如下面语句是错误的，类型擦除会使这个操作变成 new Object()。

first = new T(); //ERROR

同样，我们也不能建立一个泛型数组：

public <T> T[] minMax(T[] a) {
     T[] mm = new T[2]; //ERROR
     ...
}

类似的，擦除会使这个方法总是构造一个 Object[2] 数组。但是，可以用反射构造泛型对象和泛型数组。利用反射，调用 Array.newInstance：

public static <T extends Comparable> T[] minmax(T[] a) {
	
	T[] mm = (T[])Array.newInstance(a.getClass().getComponentType(), 2);
	...
    // 以替换掉以下代码
    // Obeject[] mm = new Object[2];
    // return (T[]) mm;
}

9、类型擦除后的冲突

1.当泛型类型被擦除后，创建条件不能产生冲突。如果在Pair 类中添加下面的 equals 方法：

class Pair<T> {
	public boolean equals(T value) {
		return null;
	}	
}

考虑一个 Pair。从概念上，它有两个 equals 方法：

boolean equals(String); //在Pair中定义
boolean equals(Object); //从object中继承

但是，这只是一种错觉。实际上，擦除后方法 boolean equals(T) 变成了方法 boolean equals(Object)，这与 Object.equals 方法是冲突的！当然，补救的办法是重新命名引发错误的方法。

2.泛型规范说明提及到了另一个原则“要支持擦除的转换，需要强制一个类或者类型变量不能同时成为两个接口的子类，而这两个子类是同一接口的不同参数化。”

比如，下面的代码是非法的：

//定义父类Calendar
class Calendar implements Comparable<Calendar>{ ... }

//定义子类GregorianCalendar 
class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...} //ERROR

GregorianCalendar 会实现 Comparable 和 Compable，这是同一个接口的不同参数化实现。这一限制与类型擦除的关系并不很明确。如下非泛型版本是合法的：

//定义父类Calendar
class Calendar implements Comparable { ... }

//定义子类GregorianCalendar 
class GregorianCalendar extends Calendar implements Comparable {...} //ERROR

10、泛型在静态方法和静态类中的问题

泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数的。

举例说明：

public class Test2<T> {  
	public static T one;   //编译错误  
    public static T show(T one){ //编译错误  
        return null;  
    }  
}

因为泛型类中的泛型参数的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。但是要注意区分下面的一种情况：

public class Test2<T> {  
    public static <T> T show(T one) {//这是正确的  
        return null;  
    }  
}

因为这是一个泛型方法，在泛型方法中使用的 T 是自己在方法中定义的 T，而不是泛型类中的 T。

原文链接，侵删。

你可能感兴趣的:(Java基础)

  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • JAVA相关知识 M_灵均 javajvm开发语言
    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了 m0_65322636 程序员架构移动开发android
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
  • Java基础一 十一路客 java开发语言
    哔哩哔哩Java开发工程师面试该如（）何准备？-知乎一.JavaOOP面试题(1)什么是B/S架构?什么是C/S架构Java都有那些开发平台?B/S(Browser/Server)，浏览器/服务器程序C/S(Client/Server)，客户端/服务端，桌面应用程序1、C/S和B/S各有优势，C/S在图形的表现能力上以及运行的速度上肯定是强于B/S模式的，不过缺点就是他需要运行专门的客户端，而且更
  • Java 学习路线：语言、框架、中间件与数据库 高危型 java
    Java是一门功能强大、应用广泛的编程语言，适用于企业级应用、Web开发、大数据处理、Android开发等各种场景。这里为大家介绍了一下我认为较为合适的学习路线一、Java基础1.1Java语言基础1.1.1安装JDK和IDE安装JDK：下载JDK：访问Oracle官网，下载最新的JavaDevelopmentKit（JDK）。安装JDK：按照操作系统要求安装JDK并配置环境变量。Windows上
  • java基础-线程间通信方式 问道飞鱼 Java开发技术java开发语言
    文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
  • Java并发复习 vd_vd Java并发安全容器java开发语言
    Java基础1.为什么要使用并发编程？一般我们工作的电脑都有多核，我们创建多个线程，然后操作系统可以将多个线程分配给不同的CPU去执行，每个CPU执行一个线程，这样就提高了CPU使用效率。在网络购物中，我们买了一个东西的同时，需要减库存，生成订单等等这些操作，就可以进行拆分利用多线程的技术完成。面对复杂业务模型，并行程序串行会比程序更适应业务需求，而并发编程更能吻合这种业务拆分。->充分利用多核C
  • Android 高频面试必问之Java基础 2401_86022611 android面试java
    常用的JVM调参如下表：|参数|作用描述||—|—||-XX:MetaspaceSize|分配给Metaspace（以字节计）的初始大小。如果不设置的话，默认是20.79M，这个初始大小是触发首次MetaspaceFullGC的阈值，例如-XX:MetaspaceSize=256M||-XX:MaxMetaspaceSize|分配给Metaspace的最大值，超过此值就会触发FullGC，此值默认
  • Java基础day08ArrayList和继承 没有信仰的小白
    ArrayList类对象数组数组长度是固定，无动态扩容java.util.ArrayList集合类，更方便image无参构造函数image基本格式,Jdk7之后右侧尖括号可以留空，但是必须保留ArrayListlist=newArrayList<>();成员方法添加元素publicbooleanadd(Ee)获取元素publicEget(intindex)集合中的元素publicintsize()
  • java基础系列02--面向对象 addin_gao
    java面向对象封装(encapsulation)继承(inheritance)多态(polymorphism)成员变量和局部变量的区别：在类中的位置不同:成员变量：在类中方法外局部变量：在方法定义中或者方法声明上在内存中的位置不同:成员变量：在堆内存(成员变量属于对象,对象进堆内存)局部变量：在栈内存(局部变量属于方法,方法进栈内存)生命周期不同:成员变量：随着对象的创建而存在，随着对象的消失而
  • Java基础全程学习笔记（二） 网路侠客 java学习笔记开发语言
    第06章：面向对象-基础#面向对象内容的三条主线：>类及类的内部成员：属性、方法、构造器;代码块、内部类>面向对象的三大特征：封装性、继承性、多态性>其它关键字的使用：package、import、this、super、static、final、abstract、interface等1.理解：面向过程vs面向对象#简单的语言描述二者的区别>面向过程：以`函数`为组织单位。是一种“`执行者思维`”，
  • Java基础：什么是多态 试着奔跑的菜鸟 javajava开发语言
    什么是多态多态是面向对象的三大特性之一（另外两个是封装和继承），指的是同一个方法能执行不同的行为，在代码上的体现是：声明为父类的对象，可以被不同的实现类赋值，其中实现类必须继承或者实现父类接口，然后程序在运行时会执行实现类的方法。//如ArrayList和LinkedList都实现了List接口classArrayListimplementsList{}classLinkedListimpleme
  • java基础之继承 Absinthe_苦艾酒 java开发语言
    1.一个子类只能有一个直接父类（一个父类可以多个子类）2.private修饰符和void不能继承、不同包不能继承代码如下：父类packagebegan;//定义一个父类publicclassPet01{//属性publicStringname;//方法publicvoidrun(Stringname){System.out.println(name+"running");}}子类packagebe
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结 lzhlizihang java设计模式
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
  • Java学习路线：从零基础到高级开发者的完整指南 何遇mirror java
    初学者入门指南1.环境搭建安装JDK:下载并安装最新版本的JDK（JavaDevelopmentKit）。配置环境:设置JAVA_HOME环境变量，并将bin目录添加到PATH中。选择IDE:使用Eclipse、IntelliJIDEA或其他任何你喜欢的Java集成开发环境。2.Java基础知识HelloWorld:编写你的第一个Java程序。基本语法:学习变量、数据类型（原始类型、包装类型）、运
  • Java 学习路线：适合小白的超细学习路线及实例代码 Dreams°123 后端javaeclipsejvmspringtomcatideintellij-idea
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
  • Java基础：单例模式，Spring源码中有哪些单例模式 生活诙谐号 Java基础Spring源码设计模式单例模式javaspring
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
  • 多线程 03：知识补充，静态代理与 Lambda 表达式的相关介绍，及其在多线程方面的应用 蟾宫曲 Java多线程java开发语言多线程静态代理Lambdaintellij-idea
    一、概述记录时间[2024-08-16]前置知识：Java基础篇；Java面向对象多线程01：Java多线程学习导航，线程简介，线程相关概念的整理多线程02：线程实现，创建线程的三种方式，通过多线程下载图片案例分析异同（Thread，Runnable，Callable）Java多线程学习主要模块包括：线程简介；线程实现；线程控制；线程状态；线程同步；线程通信问题；拓展高级主题。本文是针对多线程的相
  • Java基础之Java中的8种基本数据类型 w乐生 乐生的Java之路java
    一，8种基本数据类型1，byte：8位1字节，取值范围：2-7----27-12，shot：16位2字节，取值范围：2-15----215-13，int：32位4字节，取值范围：2-31----231-14，long：64位8字节，取值范围：2-63----263-15，float：32位4字节，取值范围：-2-31----231-16，double：64位8字节，取值范围：-2-63----26
  • Java学习路线 纣王家子迎新 javajava学习
    一、Java基础阶段‌Java语言基础‌：数据类型与变量：了解Java中的基本数据类型（如int、float、double等）和引用数据类型，掌握变量的声明、初始化和使用。运算符与表达式：学习Java中的算术运算符、关系运算符、逻辑运算符等，以及它们的使用规则和优先级。流程控制：掌握条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue
  • 2024上学期--实验室学习计划 m0_66357705 javascript前端vue.js
    阶段周次学习内容实践内容时间安排新增内容/重点基础巩固1-2周Java基础，多线程，TCP/IP网络编程相关练习和小的编程项目每天学习2小时，实践1小时Java20及以上版本新特性学习框架深入学习3-6周Spring，SpringBoot相关练习和小的编程项目每天学习3小时，实践1.5小时学习SpringCloud和微服务架构基础前端技术提升7-8周Vue2，Vue3相关练习和小的编程项目每天学习
  • Java基础——深入理解Java中的多线程（超级详细，值得你看） 2401_84558508 作者\/java开发语言
    开发中优先选择实现Runnable方式原因：实现的方式没有类的单继承性的局限性实现的方式更适合来处理多个线程共享数据的情况相同点：都需要重写run()，将线程要执行的代码声明在run()方法中线程的生命周期解决线程安全问题；使用同步代码块packagecom.haust.java;/*出现线程安全问他的解决方法：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程参与进来，也操作完
  • 庖丁解java(一篇文章学java) 庖丁解java java开发语言
    (大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文.关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(一个
  • Java基础 -- 05反射reflect mmlz00 Java基础Java基础反射reflectProxy动态代理
    目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
  • 从零开始学习Java的100个课程 陈在天box java大数据开发语言
    哈喽大家好，今天给大家推荐的是从零开始学习Java的100个课程，接下来我会每天更新两篇课程经验供大家参考学习；以下是为大家设计的从零开始学习Java的100个课程：一、Java基础语法Java开发环境搭建安装JDK配置环境变量编写并运行第一个Java程序基本数据类型整数类型（byte、short、int、long）浮点类型（float、double）字符类型（char）布尔类型（boolean）
  • java基础知识 阿拉伯的劳伦斯292 java开发语言
    1.java简介跨平台性：Java语言的“一次编写，到处运行”特性是这一语言的重要优势,java程序编译成字节码，可以在安装了Java虚拟机（JVM，javavirtualmachine）的不同操作系统上运行面向对象：java是一门完全的面向对象编程语言，支持继承，抽象，封装和多态的特性内存管理：java通过垃圾回收器（GarbageCollector）自动管理内存，这就不用开发者手动释放内存了，
  • 2025届美团秋招笔试题 今天不coding python算法开发语言
    题型及时间90分钟单选10+算法3单选包括Java基础八股文、设计模式、计算机网络、sql语句算法1题目描述小美准备登录美团，需要输入密码，小美忘记了密码,只记得密码可能是n个字符串中的一个。小美会按照密码的长度从小到大依次尝试每个字符串，对于相同长度的字符串，小美随机尝试，并且相同的密码只会尝试一次。小美想知道，她最少需要尝试多少次才能登录成功，最多需要尝试多少次才能登录成功。小美不会重新尝试已
  • gee mysql数据库_MySQL weixin_39955142 geemysql数据库
    集合如果你有更好的想法请在评论区留下您的答案，一起交流讨论说说常见的集合有哪些？答：主要分List、Set、Map、Queue四类，其中包含ArrayList、LinkedList、HashSet、TreeSet、HashMapComparable和Comparator接口的区别？答：其两...»smart-rick2021-02-15JAVA基础面向对象有哪些特征？答：继承、封装、多态JDK与J
  • 2019-03-26Day02 java基础语法01 summericy
    Day02java基础语法1.关键字：被Java语言赋予特殊含义的单词特点：字母小写注意void是一种特殊的数据类型（空类型）标识符:给类，接口，方法，变量起名字使用的序列组成:大小写，数字下划线_美元符号$特点;1.不以数字开头2.不能是Java关键字3.严格区分大小写最好见名知义常见规则包（其实就是文件夹，解决相同类名）划分命名空间，包名+类名单级:全部小写多级：全部小写且域名要反转类和接口一
  • tomcat基础与部署发布 暗黑小菠萝 Tomcat java web
    从51cto搬家了，以后会更新在这里方便自己查看。 做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 一、Tomcat安装     安装方式：①运行.exe安装包      &n
  • 网站架构发展的过程 ayaoxinchao 数据库应用服务器网站架构
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
  • [信息与安全]数据库的备份问题 comsci 数据库
          如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题   如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢?    是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢?  &n
  • 使用maven tomcat plugin插件debug关联源代码 商人shang mavendebug查看源码tomcat-plugin
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 *配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
  • 大访问量高并发 oloz 大访问量高并发
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 要列出几点解决方案： 01、优化你的代码和查询语句，合理使用索引 02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 03、采用服务器集群、负载均衡分担大访问量高并发压力 04、数据读写分离 05、合理选用框架，合理架构(推荐分布式架构)。
  • cache 服务器 小猪猪08 cache
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 　　1.Cache   是怎么样工作的? 　　Cache   是分配在服务器上
  • mysql存储过程 香水浓 mysql
    Description:插入大量测试数据 use xmpl; drop procedure if exists mockup_test_data_sp; create procedure mockup_test_data_sp( in number_of_records int ) begin declare cnt int; declare name varch
  • CSS的class、id、css文件名的常用命名规则 agevs JavaScriptUI框架Ajaxcss
      CSS的class、id、css文件名的常用命名规则     (一)常用的CSS命名规则 　　头：header 　　内容：content/container 　　尾：footer 　　导航：nav 　　侧栏：sidebar 　　栏目：column 　　页面外围控制整体布局宽度：wrapper 　　左右中：left right
  • 全局数据源 AILIKES javatomcatmysqljdbcJNDI
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
  • MYSQL的随机查询的实现方法 baalwolf mysql
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
  • JAVA的getBytes()方法 bijian1013 javaeclipseunixOS
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！      String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： byte[] b_gbk = "
  • AngularJS中操作Cookies bijian1013 JavaScriptAngularJSCookies
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。         幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
  • [Maven学习笔记五]Maven聚合和继承特性 bit1129 maven
    Maven聚合   在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块： 1. 模型和数据持久化层user-core, 2. 业务逻辑层user-service以 3. web展现层user-web， user-service依赖于user-core user-web依赖于user-core和use
  • 【JVM七】JVM知识点总结 bit1129 jvm
      1. JVM运行模式 1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler
  • linux下查看nginx、apache、mysql、php的编译参数 ronin47
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 1、nginx [root@361way ~]# /App/nginx/sbin/nginx -V nginx: nginx version: nginx/
  • unity中运用Resources.Load的方法？ brotherlamp unity视频unity资料unity自学unityunity教程
    问：unity中运用Resources.Load的方法？ 答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 1、unity实时替换的物体即是依据环境条件
  • 线段树-入门 bylijinnan java算法线段树
    /** * 线段树入门 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i] * * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18 * @author lijinna
  • 全选与反选 chicony 全选
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>全选与反选</title>
  • vim一些简单记录 chenchao051 vim
    mac在/usr/share/vim/vimrc linux在/etc/vimrc   1、问：后退键不能删除数据，不能往后退怎么办？       答：在vimrc中加入set backspace=2   2、问：如何控制tab键的缩进？       答：在vimrc中加入set tabstop=4 (任何
  • Sublime Text 快捷键 daizj 快捷键sublime
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
  • php 引用(&)详解 dcj3sjt126com PHP
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容  复制代码代码如下: <?  $a="ABC";  $b =&$a;  echo
  • SVN中trunk,branches,tags用法详解 dcj3sjt126com SVN
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
  • 对软件设计的思考 e200702084 设计模式数据结构算法ssh活动
    软件设计的宏观与微观    软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
  • 同步、异步、阻塞、非阻塞 geeksun 非阻塞
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。   同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。   异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 实现：
  • Reverse SSH Tunnel 反向打洞實錄 hongtoushizi ssh
    實際的操作步驟： # 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port ssh -NfR 12345:localhost:22 [email protected] # 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器 ssh localhost -p 1
  • Hibernate中的缓存 Josh_Persistence 一级缓存Hiberante缓存查询缓存二级缓存
    Hibernate中的缓存   一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
  • 对象关系行为模式之延迟加载 home198979 PHP架构延迟加载
    形象化设计模式实战     HELLO!架构   一、概念 Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。     二、实现延迟加载 实现Lazy Load主要有四种方法：延迟初始化、虚
  • xml 验证 pengfeicao521 xmlxml解析
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 public static void testPattern() { // 含有非法字符的串 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
  • div设置半透明效果 spjich css半透明
    为div设置如下样式：   div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}        说明： 1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
  • 你真的了解单例模式么？ w574240966 java单例设计模式jvm
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。   一，单例模式的5中写法。（回字的四种写法，哈哈。）     1，懒汉式           （1）线程不安全的懒汉式 public cla