<java核心技术>读书笔记2

摘要：如果需要收集参数化类型对象，只有使用警告这节讨论，向参数可变的方法传递一个泛型类型的实例。异常不能抛出或捕获泛型类的实例实际上，泛型类扩展也是不合法的。

java中每个类都是由它扩展而来，但是并不需要这样写：class Employee extends Object.如果没有明确指出超类，Object类就被认为是这个的超类。
可以使用Object类型的变量引用任何类型的对象Object obj=new Employee().
在java中，只有基本类型(int,boolean,...)不是对象，所有的数组类型，不管是对象数组还是基本类型的数组都扩展自Object类。

Employee[] staff=new Employee[10];
Object obj=staff;//ok
obj=new int[10];//ok

有时需要将int这样的基本类型转换为对象，所有基本对象都有一个与之对应的类。如int->Integer.这些类称为包装类（wrapper）.具体的，包括Integer,Long,Float,Double,Short,Byte,Character,Void,Boolean,前6个派生于它们公共的超类Number.
对象包装类是不可变的，一旦创建，就不允许更改包装在其中的值。
对象包装类还是final,不能定义它们的子类。
java5之后，调用list.add(3)将自动变换成list.add(Integer.valueOf(3)),这种变换称为自动装箱。相反的，将一个Integer对象赋值给一个int值时，会自动拆箱。

List list=new ArrayList();
list.add(3);
int n=list.get(0);//等同于list.get(0).intValue();

在算术表达式中，也可以自动装箱，自动拆箱。

Integer n=3;
n++;//拆箱->自增->装箱

==运算符用于比较包装器对象，只不过检测的是对象是否指向同一个存储区域。因此，下面比较不会成立

        Integer a=1000;
        Integer b=1000;
        System.out.println(a==b);//false

但是如果包装的值经常出现，==比较就有可能相等

        Integer a=100;
        Integer b=100;
        System.out.println(a==b);//true

这个和python类似

python并不是对创建的所有对象都会重新申请新的一块内存空间。作为一种优化，python会缓存不变的对象（如数值较小的数字，字符串，元组等）并对其进行复用。

因此，java设定了自动装箱规范

boolean

byte

char<=127

介于-128和127之间的short,int

被包装到固定的对象中。
上面例子a,b是100,第二次赋值时，java不会重新申请新的一块内存空间，存储100这个值。

接口特性

接口不是类，不能使用new运算符实例化一个接口

可以声明接口变量，但必须引用实现了接口的类对象

可以使用instanceof检查一个对象是否实现了某个特定的接口

接口可以继承接口InterfaceA extends InterfaceB

接口中不能包含实例变量或静态方法，却可以包含常量

public interface Interface {
    String name="aaa";//a public static final constant
}

常量会自动被设为public static final

尽管每个类只允许拥有一个超类，却可以实现多个接口class Concrete implements InterfaceA,InterfaceB

内部类方法可以访问该类所在的作用域中的数据，包括私有数据

内部类可以对同一个包中的其他类隐藏起来

当想要定义一个回调函数且不想写大量代码时，使用匿名内部类比较方便

泛型类：具有一个或多个类型变量的类。类型变量可以指定方法的返回类型以及类变量和局部变量的类型

public class Pair {
    T first;
    T second;
    Pair(){
        this.first=null;
        this.second=null;
    }
    Pair(T first,T second){
        this.first=first;
        this.second=second;
    }
    public T getFirst() {
        return first;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}

Pair类引入一个类型变量T,用尖括号(<>)括起来，并放在类名的后面。
泛型可以有多个类型变量``

public class Pair {
    ...
}

实例化Pair pair=new Pair(),这时类型变量T就会被替换成String.这时，泛型类就可以看做普通类。

泛型方法可以定义在普通类中。

public  T getMethod(T... a){}

类型变量放在修饰符（这里是public）的后面，返回类型的前面
调用class.getMethod()
如果是上面情况，大多数时候，方法调用可以省略类型参数。编译器有足够的信息推断出调用的方法。String[]与泛型类型T[]进行匹配，并推断出T一定是String.
但是，如果是下面代码

double result=class.getMethod(1.23,123,0);

编译器会自动将参数打包为1个Double和2个Integer对象，然后寻找这些类的共同超类型,最终找到两个这样的超类Number和Comparable,其本身也是泛型类型，这种情况下，只有将所有的参数写成double值。
如果想知道一个泛型方法最终推断出哪种类型，可以有目的的引入一个错误，看产生的错误信息，比如

class.getMethod("aaa",0,null);
//found:java.lang.Object&java.io.Serializable&java.util.Comparable...

意思是可以将结果赋给Object,Serializable或Comparable.

 T min(T[] a);

上面代码将T限制为实现了Comparable接口的类,这样min方法只能被实现了实现了Comparable接口的类(如String,Date类)的数组调用。
注意这里用的是extends关键字
extends BoundingType表示T应该是绑定类型的子类型（subtype），T和绑定类型可以是类，也可以是接口.选择extends关键字的原因是跟接近子类型的概念。
一个类型变量或通配符可以有多个限定，如T extends Serializable&Comparable.&隔开限定类型，,隔开类型变量。
由于对类是单继承，对接口多重继承，如果限定类型中有类又有接口，必须将类作为限定列表中的第一个。

大多数限制都是由类型擦除引起的，类型擦除可以参见Java泛型：类型擦除

不能用基本类型实例化类型参数。
没有Pair,只有Pair,因为类型擦除之后，类型参数变为Pair