[收集]java最蛋疼、怪异的语法与类库设计

class TestMap<K extends Object, V extends Vector<? extends Vector<? extends Vector>>>
extends Hashtable<K, V> {

}

Vector<? extends Vector<? extends Vector>>只要是 ? extends 可以无穷无尽

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{

public void putAll(Map<? extends K, ? extends V> m) {
        int numKeysToBeAdded = m.size();
        if (numKeysToBeAdded == 0)
            return;

        /*
         * Expand the map if the map if the number of mappings to be added
         * is greater than or equal to threshold.  This is conservative; the
         * obvious condition is (m.size() + size) >= threshold, but this
         * condition could result in a map with twice the appropriate capacity,
         * if the keys to be added overlap with the keys already in this map.
         * By using the conservative calculation, we subject ourself
         * to at most one extra resize.
         */
        if (numKeysToBeAdded > threshold) {
            int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
            if (targetCapacity > MAXIMUM_CAPACITY)
                targetCapacity = MAXIMUM_CAPACITY;
            int newCapacity = table.length;
            while (newCapacity < targetCapacity)
                newCapacity <<= 1;
            if (newCapacity > table.length)
                resize(newCapacity);
        }

        for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry<? extends K, ? extends V> e = i.next();
            put(e.getKey(), e.getValue());
        }
    }

}HashMap里面的源码

传送门：NS的老帖一枚http://www.iteye.com/topic/412868

数组的最后一个元素是可以有逗号的

private static void testOverloading(int... args) {
	}

private static void testOverloading(Integer... args) {
	}

这两个方法可以共存，但无法调用

public static int sum(List<Integer> ints) {

		return 0;
	}

public static String sum(List<String> strings) {
		return "";
	}

上面两个方法同样可以共存，但无法调用。

我觉得还是泛型和autoboxing比较蛋疼

Integer[] a = new Integer[]{1};
int[] b = new int[]{1};
testOverloading(a);
testOverloading(b); 可以调用


public static int sum(List<Integer> ints) { 
 
        return 0; 
} 

public static String sum(List<String> strings) { 
      return ""; 
} 

两个方法不能同时存在

+1

搞清楚其原理和用途， 就不会觉得怪异，

比如一：


此处加括号是调用构造函数，并不怪异。
不但可以调用构造，还可以直接 匿名内部子类，示例 如下：

enum Color {
		R(0xff0000) {
			@Override
			public int r() {
				return 0x00ffff;
			}

			public void f() {}
		},
		G(0x00ff00), 
		B(0x0000ff);

		private int value;

		Color(int value) {
			this.value = value;
		}

		public int getValue() {
			return value;
		}

		public int r() {
			return 0xFFFFFF ^ this.value;
		}
	}

 

 

奇葩 Java 代码片段

 

再详细说下吧，可能我的说法有误。
数组形式确实是可以调用的。
但按道理说，下面的代码同样可以调用，但实际却不能。
testOverloading(1, 2);
testOverloading(new Integer(1), new Integer(2));


而下面这两个方法，是可以编译通过的。你可以试试用javac编译器（Eclipse的ECJ编译器可能会拒绝编译这段代码）
public static int sum(List<Integer> ints) { 
 
        return 0; 
} 

public static String sum(List<String> strings) { 
      return ""; 
}