java收集碎片_Thinking in Java 笔记碎片

复用类

P135 垃圾收集器可能永远也无法被调用，即使被调用，它也可能以任何他想要的顺序来回收对象。因此最好除了内存回收以外，不要依赖垃圾回收器做任何事情。如果需要清理(如关闭文件等)，最好自己编写清理方法，且不要使用finalize()方法。

多态

多态的作用主要在于消除类型间的耦合关系

将一个方法调用和一个方法主体关联起来的过程谓之“绑定”

前期绑定：在程序执行以前就进行绑定，则是前期绑定，这一般由编译器和链接程序实现

后期绑定：在运行时根据对象的类型进行绑定，则是后期绑定，也称为动态绑定或运行时绑定

Java中除final方法(private方法也是某种意义上的final方法)和static方法外，其余方法均是后期绑定

注意：

“覆盖”私有方法：如果在子类中写一个与基类中的私有方法同名、同参且返回值相同(一模一样)的方法，那么编译器会认为这是子类的一个全新的方法，所以在将子类向上转型为基类，并调用该方法时，调用的将是基类中的方法

class Cycle extends Shape {

void f() {

OutUtil.print("I am the child class -- Cycle!");

}

}

public class Shape {

private void f() {

OutUtil.print("I am the base class -- Shape!");

}

public static void main(String[] args) {

Shape s = new Cycle();

s.f();

}

}

// Output:

I am the base class -- Shape!

域不具备多态性：当将一个子类型向上转型为基类型时，任何对域的访问操作都将由编译器解析，因此不是多态的。实际上，对于子类型，会为当前类和基类可访问(拥有访问权限)域分配不同的存储空间，当需要访问基类中的域时，需要使用关键词super.域名进行访问

静态方法不具备多态性：因为静态方法是与某一个类绑定的，而并非与类对象绑定的，而多态是针对对象而言的，所以静态方法也不具备多态性

class Super{

String ss = "String in Super";

static void staticf(){

OutUtil.print("staticf() in Super");

}

void commonf(){

OutUtil.print("commonf() in Super");

}

}

class Sub extends Super{

String ss = "String in Sub";

static void staticf(){

OutUtil.print("f() in Sub");

}

void commonf(){

OutUtil.print("commonf() in Sub");

}

}

public class MultiType {

// Thinking in Java P156 域和静态方法的多态性

public static void main(String[] args) {

Super sup = new Sub();

OutUtil.print(sup.ss);

sup.staticf();

sup.commonf();

}

}

//Output:

String in Super

staticf() in Super

commonf() in Sub

当需要对某些对象进行清理时，其清理顺序应该和初始化顺序相反。即对象的清理顺序应该和初始化顺序相反；字段则是与声明的顺序相反(因为字段的初始化顺序就是其声明顺序)；而对于类的继承而言，则应该先清理子类，然后再对基类进行清理。因为子类可能需要使用到基类的某些方法，如果先清理基类，则会导致那些方法无效。

通过引用计数释放含有共享变量的类：如果存在一个成员变量被一个或多个对象共享的情况，那么就需要好好处理这些对象的清理问题。在这种情况下，可以使用引用计数来跟踪仍旧在访问共享变量的对象数量，只有当引用计数变为0时，才清理这个共享变量(这里的清理并不一定是内存的清理，也可以是文件的关闭、网络的断开等，因为内存清理可以由JVM自动完成，可以不用考虑)

public class ReferenceCounting {

public static void main(String[] args) {

Compose[] composes = new Compose[5];

Share s = new Share();

for (int i = 0; i < 5; ++i){

composes[i] = new Compose(s);

}

for (int i = 0; i < 5; ++i){

composes[i].dispose();

}

}

}

class Share {

private int refCount = 0; // 引用计数器

private static long counter = 0; // 利用counter和id记录当前创建的Share实例数

private final long id = counter++;

public Share() {

OutUtil.print(this.toString());

}

public void addRef() {

refCount++;

}

public void dispose() {

// 方法内部需要将引用计数减1

if (--refCount == 0) {

OutUtil.print("dispose " + this);

}

}

@Override

public String toString() {

return "Share " + id;

}

}

class Compose {

private Share share;

private static long counter = 0;

private final long id = counter++;

public Compose(Share share) {

this.share = share;

share.addRef(); // 创建一个新对象时，需要将共享变量的引用计数加1

OutUtil.print(this.toString());

}

public void dispose(){

OutUtil.print("dispose " + this);

share.dispose();

}

@Override

public String toString() {

return "Compose " + id;

}

}

//Output:

Share 0

Compose 0

Compose 1

Compose 2

Compose 3

Compose 4

dispose Compose 0

dispose Compose 1

dispose Compose 2

dispose Compose 3

dispose Compose 4

dispose Share 0

构造器：应该使用尽可能简单的方法使对象进入正常状态，如果可以的话，应该尽可能避免调用其他方法。在构造器内唯一能够安全调用的方法是基类中的final方法。

协变返回类型：Java SE5允许协变返回类型，所谓协变返回类型是指子类覆盖基类的方法时，可以返回该基类返回类型的子类型，即更具体化

Java运行时多态性：

继承实现多态：即将子类对象的引用赋值给基类对象引用，从而实现多态；

接口实现多态：一个接口，多种实现，将接口实现类的对象引用赋值给接口对象的引用，以实现多态；