Java编程思想第四版读书笔记

序言

本文是自己读Java编程思想的读书笔记，并非全内容记录，只记录了本人感兴趣的东西，并且由于功力尚浅，可能有些言论有问题，还请各位看官能留言指出…

5.5 清理：终结处理和垃圾回收

手敲代码：

public class Book {
    boolean checkOut = false;

    Book(boolean checkOut){
        this.checkOut = checkOut;
    }
    void checkIn(){
        this.checkOut = false;
    }

    protected  void finalize(){
        if(checkOut){
            System.out.println("Error:checked out");
        }
    }
}

class TerminationCondition{
    public static void main(String[] args) {
        Book book = new Book(true);
        book.checkIn();
        new Book(true);
        System.gc();
    }
}

执行结果：
在这里插入图片描述
结论：
1.垃圾回收机制是在内存不够用的情况下才会进行垃圾回收。
2.利用本地化方法调用了c/c++等语言时需要用finalize再掉其对应的内存回收方法
3.finalize()方法可以做对象终结条件验证，验证该对象是否满足终结条件。
4.什么时候用finalize()方法？尽量不要用。

6 访问权限控制

1.包访问权限
默认访问权限没有任何关键词，但是通常是指包访问权限，意味着该成员对这个包下的其他类可见，但对这个包之外的所有类，这个成员却是private的。
注意：有些人有时候定义类属性的时候喜欢不用修饰，却自认为这个属性是private的，这个是错误的。（其实以前我也认为不修饰就默认是private的囧~~~）
Book里面有个name属性，是默认权限；
在这里插入图片描述
同包下的MainRun类中可以直接访问Book.name属性：

不同包下面的MainRun则不能访问Book.name属性：

2.public：接口访问权限
使用public修饰的成员声明自己对每个人是可用的。
3.private:你无法访问
除包含该成员的类之外，其他任何类都无法访问这个成员。
在这里插入图片描述 4.protected:继承访问权限
我总结上面的话就是，protected定义的对象只有之类里面和同个包下面才能访问；
为了形象的描述上面这句话，看下面这个demo：

MathBook继承Book：

public class Book {
    protected void read(){
        System.out.println("book --- read");
    }
}

与Book处于不同包下的MathBook可以调用Book.read()方法：
在这里插入图片描述
与Book处于不同包下的MainRun不可以调用Book.read()方法：
与Book处于相同包下的MainRun可以调用Book.read()方法

我真的需要向上转型么？

在这里插入图片描述

空白final

在这里插入图片描述

看下上面这个例子，这就是空白final，可以定义，但是要保证使用前他会被初始化；

final方法

在这里插入图片描述

final类

在这里插入图片描述

扫描二维码关注公众号，回复： 11040992 查看本文章

初始化及类的加载

note：
1.一个加载器只会加载一次类，在第一次使用的时候进行加载；
2.代码执行顺序：Java一个demo看懂代码代码执行顺序

构造器内部的多态方法行为

在这里插入图片描述
这就很有意思了。

内部类

在这里插入图片描述

回调

在这里插入图片描述

interface Incrementable{
    void increment();
}

class Callee1 implements  Incrementable{
    private int i = 0;

    public void increment() {
        i++;
        System.out.println(i);
    }
}

class MyIncrement{
    public void increment(){
        System.out.println("other opt");
    }

    static void f(MyIncrement myIncrement){
        myIncrement.increment();
    }
}

class Callee2 extends MyIncrement {
    private int i = 0;

    public void increment() {
        super.increment();
        i++;
        System.out.println(i);
    }

    private class Closure implements Incrementable {

        public void increment() {
            Callee2.this.increment();
        }
    }

    Incrementable getCallBackReference() {
        return new Closure();
    }
}
class Caller{
    private Incrementable callbackResference;
    Caller(Incrementable incrementable){
        callbackResference = incrementable;
    }
    void go(){callbackResference.increment();}
}
class Callbacks{
    public static void main(String[] args) {
        Callee1 c1 = new Callee1();
        Callee2 c2 = new Callee2();
        MyIncrement.f(c2);
        Caller caller1 = new Caller(c1);
        Caller caller2 = new Caller(c2.getCallBackReference());
        caller1.go();
        caller1.go();
        caller2.go();
        caller2.go();
    }
}