《Think in Java》閱讀筆記·第二卷

阿新 • • 發佈：2019-01-02

內部類

從外部類的非靜態方法之外的任意位置建立某個內部類的物件，都需要以外部類.內部類的格式指明物件型別

內部類擁有外圍類的所有元素的訪問權

外圍類物件建立一個內部類物件時，此內部類物件會祕密地捕獲一個指向那個外圍類物件的引用。
在外圍類靜態方法中建立內部類物件原始碼如下：

public class InnerClass {
    class InnerClass1{
        public InnerClass1() {
            int i1=1;
            System.out.println("InnerClass1");
        }
        public 
 void f1() {
            System.out.println("InnerClass1_f1");
        }
    }
    class InnerClass2{
        int i2=2;
        public InnerClass2() {
            System.out.println("InnerClass2");
        }
        public void f2() {
            System.out.println("InnerClass2_f2");
        }
    }
    public 
 InnerClass1 getInnerClass1() {
        return new InnerClass1();
    }
    public static final void main(String...args) {
        InnerClass ic=new InnerClass();
        InnerClass.InnerClass1 i1=ic.getInnerClass1();
        i1.f1();

        InnerClass.InnerClass2 i2=ic.new InnerClass2();
        i2.f2();
    }
}

InnerClass1
InnerClass1_f1
InnerClass2
InnerClass2_f2

匿名內部類

匿名類版：

new NoNameClass(){
    public void f3() {
        System.out.println("f3");
    }
}

完整版：

    interface INoNameClass{
        public void f3();
    }
    class NoNameClass implements INoNameClass{
        public void f3() {
            System.out.println("f3");
        }
    }
    public static final void main(String...args) {
        InnerClass ic=new InnerClass();
        INoNameClass innc=ic.new NoNameClass();
    }

注意：

    abstract class NoNameClass2{
        public NoNameClass2(int i){
            System.out.println("構造器："+i);
        }
        public abstract void f2();
        //{System.out.println("{     }");}
    }
    public static final void main(String...args) {
        InnerClass ic=new InnerClass();
        ic.new NoNameClass2(53){
            {System.out.println("{     }");}
            public void f2() {
                System.out.println("f2");
            }
        };
    }

構造器：53
{ }

    abstract class NoNameClass2{
        public NoNameClass2(int i){
            System.out.println("構造器："+i);
        }
        public abstract void f2();
        //{System.out.println("{     }");}
    }
    public static final void main(String...args) {
        InnerClass ic=new InnerClass();
        ic.new NoNameClass2(53){
            {System.out.println("{     }");}
            public void f2() {
                System.out.println("f2");
            }
        };
    }

{ }
構造器：53

匿名內部類若想要訪問外部物件，則該物件需要加final

匿名內部類不能訪問外部類方法中的區域性變數，除非該變數被宣告為final型別
　　1. 這裡所說的“匿名內部類”主要是指在其外部類的成員方法內定義的同時完成例項化的類，若其訪問該成員方法中的區域性變數，區域性變數必須要被final修飾。原因是編譯器實現上的困難：內部類物件的生命週期很有可能會超過區域性變數的生命週期。
　　2. 區域性變數的生命週期：當該方法被呼叫時，該方法中的區域性變數在棧中被建立，當方法呼叫結束時，退棧，這些區域性變數全部死亡。而內部類物件生命週期與其它類物件一樣：自建立一個匿名內部類物件，系統為該物件分配記憶體，直到沒有引用變數指向分配給該物件的記憶體，它才有可能會死亡（被JVM垃圾回收）。所以完全可能出現的一種情況是：成員方法已呼叫結束，區域性變數已死亡，但匿名內部類的物件仍然活著。
　　3. 如果匿名內部類的物件訪問了同一個方法中的區域性變數，就要求只要匿名內部類物件還活著，那麼棧中的那些它要所訪問的區域性變數就不能“死亡”。
　　4. 解決方法：匿名內部類物件可以訪問同一個方法中被定義為final型別的區域性變數。定義為final後，編譯器會把匿名內部類物件要訪問的所有final型別區域性變數，都拷貝一份作為該物件的成員變數。這樣，即使棧中區域性變數已經死亡，匿名內部類物件照樣可以拿到該區域性變數的值，因為它自己拷貝了一份，且與原區域性變數的值始終保持一致（final型別不可變）。

只有該區域性變數為不可變時，即為final時才能保證資料的可靠性。

巢狀類

普通內部類不能包含靜態欄位和方法，而巢狀類可以
巢狀類與static欄位和方法都是一編譯便存在，並且記憶體地址不再變化，直到gc回收。

介面內部的類

public class Staticer implements IStaticer{
    @Override
    public void fun() {
    }
    public static final void main(String...args) {
        IStaticer is=new Staticer();
        is.fun();
    }
}

IStaticer_fun

內部類的作用

當存在抽象類時實現多重繼承

public class Multipler extends Multipler1{
    private AMultipler newClass() {
        return new AMultipler(){
            @Override
            public void f1() {
                System.out.println("AMultipler_f1");
            }
        };
    }
    public static final void main(String[] args) {
        Multipler m=new Multipler();
        m.f2();
        AMultipler am=m.newClass();
        am.f1();
    }
}
class Multipler1{
    public void f2() {
        System.out.println("Multipler_f2");
    }
}
abstract class AMultipler{
    public abstract void f1();
}

Multipler_f2
AMultipler_f1

控制框架是一類特殊的應用程式框架，用來解決響應事件的需求

主要用來響應事件的系統被稱做事件驅動系統

回撥

類A呼叫類B的方法b，然後類B的方法b呼叫類A的方法a

interface ICallBacker{
    public void fun();
}
class CallBacker2 implements ICallBacker{
    @Override
    public void fun() {
        System.out.println("CallBacker2_ICallBackers_fun");
    }
}
class CallBacker1{
    public void fun() {
        System.out.println("CallBacker1_fun");
    }
    private class InnerClass implements ICallBacker{
        public void fun() {
            System.out.println("CallBacker1_ICallBackers_fun");
            CallBacker1.this.fun();
        }
    }
    public InnerClass getInnerClass(CallBacker1 cb) {
        return cb.new InnerClass();
    }
}
public class CallBacker{
    public static final void main(String...args) {
        CallBacker1 cb1=new CallBacker1();
        ICallBacker ic1=cb1.getInnerClass(cb1);
        ic1.fun();
        ICallBacker ic2=new CallBacker2();
        ic2.fun();
    }
}

CallBacker1_ICallBackers_fun
CallBacker1_fun
CallBacker2_ICallBackers_fun

在內部類InnerClass的fun方法中提供了一個CallBacker1鉤子進行回撥。

內部類的繼承

由於內部類含有指向外圍類的引用，應以以下方式使用繼承

public class InnerExtend extends InnerExtend1.InnerExtend2{
    public InnerExtend(InnerExtend1 ie1) {
        //super();
        ie1.super();
    }
    public static final void main(String...args) {
        InnerExtend1 ie1=new InnerExtend1();
        InnerExtend ie=new InnerExtend(ie1);
    }
}
class InnerExtend1{
    public InnerExtend1() {
        System.out.println("InnerExtend1");
    }
    class InnerExtend2{
        public InnerExtend2() {
            System.out.println("InnerExtend2");
        }
    }
}

InnerExtend1
InnerExtend2

若將ie1.super()改成super()會報以下錯誤：

No enclosing instance of type InnerExtend1 is available due to some intermediate constructor invocation

容器

各容器介面關係

注意：List介面位於java.util包中，而在java.awt 包中也有一個List類

Set：只有元素不存在才會新增

TreeSet：按照值大小的順序進行排序
LinkedHashSet：按照新增的順序進行排序
HashSet：無序散亂地分佈

List：不考慮重複，會按照新增順序進行排序

容器選擇：

要進行大量的隨機訪問：ArrayList
要從表中間插入或刪除元素：LinkedList
各種Queue佇列以及棧的行為，可由LinkedList構建
注意：
不應該適用vector，Hashtable和stack等過時的類

    public static final void main(String...args) {
        Vector v=new Vector();
        System.out.print("showSet: ");
        v.showSet();
        System.out.println();
        System.out.print("showList: ");
        v.showList();
    }
    private void showList() {
        Collection<Integer> cl=new ArrayList<Integer>();
        Collection<Integer> cls=new ArrayList<Integer>();
        cls.addAll(Arrays.<Integer>asList(1,2,3,4,5));
        Collections.addAll(cls, 6,7,8,9,10);
        cl.add(1);
        cl.add(1);
        cl.add(2);
        cl.add(3);
        cl.add(8);
        cl.add(5);
        for(Integer i:cl) {
            System.out.print(i+" ");
        }
        System.out.print("|");
        for(Integer i:cls) {
            System.out.print(i+" ");
        }
    }
    private void showSet() {
        Collection<Integer> cl=new LinkedHashSet<Integer>();
        Collection<Integer> clt=new TreeSet<Integer>();
        cl.add(1);
        cl.add(1);
        cl.add(2);
        cl.add(3);
        cl.add(8);
        cl.add(5);
        clt.addAll(Arrays.asList(1,7,3,6,3));
        for(Integer i:cl) {
            System.out.print(i+" ");
        }
        System.out.print("|");
        for(Integer i:clt) {
            System.out.print(i+" ");
        }
    }

showSet: 1 2 3 8 5 |1 3 6 7
showList: 1 1 2 3 8 5 |1 2 3 4 5 6 7 8 9 10

在後續會探究各集合之間的演算法實現和效能區別

容器與迭代器

注：點線框表示介面，實線框表示類，空心箭頭的點線表示類實現了介面，實心箭頭表示某個類可以生產箭頭所指向類的物件。

迭代器

迭代器為輕量級物件也屬於一種設計模式

不必為數量和型別操心：

    private void showIterator() {
        List<Integer> l=new ArrayList<Integer>();
        for(int i=0;i<5;i++) {
            l.add(i);
        }
        Iterator<Integer> i=l.iterator();
        Set<Integer> s=new HashSet<Integer>();
        for(int j=0;j<5;j++) {
            s.add(j);
        }
        display(s.iterator());
        display(l.iterator());
        i=l.iterator();
        while(i.hasNext()) {
            i.next();
            i.remove();
        }
        System.out.println(l.toString());
    }
    private void display(Iterator i) {
        while(i.hasNext()) {
            System.out.print(i.next()+" ");
        }
        System.out.print("\n");
    }

0 1 2 3 4
0 1 2 3 4
[]

注意：迭代器物件要先呼叫一次next才是list容器中的第一個資料

一種只適用於List容器可雙向遍歷的迭代器

棧（疊加棧）

一個後進先出（LIFO）容器
用LinkedList實現棧儲存：

public class Stacker {
    public static final void main(String...args) {
        String str="";
        MyStack ms=new MyStack();
        List<String> l=new ArrayList<String>(Arrays.asList("+","U","+","n","+","x","-","-"));;
        System.out.println(l.toString());
        Iterator i=l.iterator();
        while(i.hasNext()) {
            str=(String) i.next();
            if(str.equals("+")) {
                ms.push(i.next());
            }
            else if(str.equals("-")) {
                ms.pop();
            }
        }
        System.out.println(ms.toString());
    }
}
class MyStack<T>{
    public MyStack() {  
    }
    LinkedList<T> stack=new LinkedList<T>();
    public void push(T t) {
        stack.add(t);
    }
    public T pop() {
        //先進後出特性
        return stack.removeLast();
    }
    public boolean isEmpty() {
        return stack.isEmpty();
    }
    public String toString() {
        return stack.toString();
    }
}

[+, U, +, n, +, x, -, -]
[x]

佇列

一個典型的先進先出（FIFO）的容器

LinkedList向上轉型為Queue實現佇列

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class Queuer {
    static void printer(Queue q) {
        while(q.peek()!=null) {
            //先進先出特性
            System.out.print(q.remove()+" ");
        }
        System.out.println();
    }
    public static final void main(String...args) {
        Random rand=new Random(53);
        Queue q=new LinkedList<Integer>();
        int r=0;
        for(int i=0;i<10;i++) {
            r=rand.nextInt(20);
            q.offer(r);
            System.out.print(r+" ");
        }
        System.out.println();
        printer(q);
    }
}

16 7 16 1 8 15 12 2 10 0
16 7 16 1 8 15 12 2 10 0

PriorityQueue的使用

import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
public class Queuer {
    public static final void main(String...args) {
        comparatorer();
    }
    private static void comparatorer() {
        Comparator<Oer> comparator=new Comparator<Oer>() {
            @Override
            public int compare(Oer o1, Oer o2) {
                // TODO Auto-generated method stub
                if(o1.getPriority()>o2.getPriority()) {
                    //o2
                    return -1;
                }
                else if(o2.getPriority()>o1.getPriority()) {
                    //o1
                    return 1;
                }
                return 0;
            }
        };
        Oer o1=new Oer("o1",4);
        Oer o2=new Oer("o2",53);
        PriorityQueue<Oer> pq=new PriorityQueue<Oer>(2,comparator);
        pq.offer(o1);
        pq.offer(o2);
        System.out.println(pq.toString());
    }
}
class Oer{
    private int priority;
    private String name;
    public Oer(String name,int priority) {
        this.priority=priority;
        this.name=name;
    }
    @Override
    public String toString(){
        return name;
    }
    public int getPriority() {
        return priority;
    }
}

[o2, o1]

通過繼承AbstractCollection重寫迭代類

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Collectioner {
    public static final void main(String...args) {
        List<Integer> list=new ArrayList<Integer>();
        list.addAll(Arrays.asList(1,2,3,4,5));
        Collectioner_child cc=new Collectioner_child(list);
        Iterator<Integer> i=cc.iterator();
        System.out.println(i.next());
    }
}
class Collectioner_child extends AbstractCollection{
    List<Integer> list;
    public Collectioner_child(List<Integer> list) {
        this.list=list;
    }
    @Override
    public Iterator iterator() {
        // TODO Auto-generated method stub
        return new Iterator() {
            private int index;
            @Override
            public boolean hasNext() {
                // TODO Auto-generated method stub
                return index < list.size();
            }
            @Override
            public Object next() {
                // TODO Auto-generated method stub
                return list.get(index++);
            }
        };
    }
    @Override
    public int size() {
        // TODO Auto-generated method stub
        return list.size();
    }
}

1

如果直接繼承Collection介面需要實現大量的方法，而繼承實現過Collection方法的AbstrctCollection抽象類只需要再實現兩個抽象方法即可
通過該例項可進一步理解迭代器的使用。

自定義foreach規則

第一種（新建一個繼承於ArrayList的自定義迭代器類）

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class Iteratorer {
    public Iteratorer() {

    }
    public static final void main(String...args) {
        List<String> list=new ArrayList<String>(Arrays.asList("12","33","22"));
        MyIterator<String> mi=new MyIterator<String>(list);
        for(String i:mi) {
            System.out.print(i+" ");
        }
        System.out.print("\n");
        for(String i:mi.reversed()) {
            System.out.print(i+" ");
        }
        System.out.println();
        //java 8中的迭代迴圈
        mi.reversed().forEach(System.out::print);
    }

}
class MyIterator<T> extends ArrayList<T>{
    public MyIterator(List<T> list) {
        super(list);
    }
    public Iterable<T> reversed() {
        return new Iterable<T>() {
            @Override
            public Iterator<T> iterator() {
                // TODO Auto-generated method stub
                return new Iterator<T>() {
                    int current=size()-1;
                    @Override
                    public boolean hasNext() {
                        // TODO Auto-generated method stub
                        return current>-1;
                    }
                    @Override
                    public T next() {
                        // TODO Auto-generated method stub
                        return get(current--);
                    }
                };
            }
        };
    }   
}

12 33 22
22 33 12
223312

第二種（直接在主類實現Iterator和Iterable介面）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Iterator2 implements Iterator<String>,Iterable<String>{
    private List<String> list;
    private int size;
    public static final void main(String...ags) {
        Iterator2 i2=new Iterator2();
        i2.list=new ArrayList<String>();
        i2.list.addAll(Arrays.asList("a","v","c","d"));
        i2.size=i2.list.size();
        for(String s:i2) {
            System.out.print(s+" ");
        }
    }

    @Override
    public Iterator<String> iterator() {
        // TODO Auto-generated method stub
        return this;
    }

    @Override
    public boolean hasNext() {
        // TODO Auto-generated method stub
        return size>0;
    }

    @Override
    public String next() {
        // TODO Auto-generated method stub
        return list.get(--size);
    }

}

d c v a

《Think in Java》閱讀筆記·第二卷

內部類從外部類的非靜態方法之外的任意位置建立某個內部類的物件，都需要以外部類.內部類的格式指明物件型別內部類擁有外圍類的所有元素的訪問權外圍類物件建立一個內部類物件時，此內部類物件會祕密地捕獲一個指向那個外圍類物件的引用。在外圍類靜態方法中建

【Think in java讀書筆記】序列化

轉換 window 讀書筆記對象序列執行輕量 body 調用 Java的對象序列化將那些實現了Serializable接口的對象轉換成一個字節序列，並能夠在以後將這個字節序列完全恢復成為原來的對象。序列化機制能自動彌補不同操作系統之間的差異，也就是說在Window

Think In Java讀書筆記：內部類覆蓋及其初始化

圖片 10.10 clas 構造 col 向上轉型 pan center 類初始化　　本文相關章節：第十章內部類 10.10 內部類可以被覆蓋嗎　　在讀至本節第二個範例代碼時（及下方的代碼），我對輸出結果中的第一個“Egg.Yolk()”很不理解，為什麽它會第一個地方

think in java 讀書筆記

imp 優先級拼接別名現象乘除方法垃圾原則 java 第三章操作符 3.1 更簡單的打印語句原:System.out.println("打印"); 簡單:print("我是更簡單的"); =======需要導包 :import static net.mi

Think in Java反芻筆記(6)---HashMap的工作原理-hashcode和equals原理的再次深入

前言首先再次強調hashcode （==）和equals的真正含義（我記得以前有人會說，equals是判斷物件內容，hashcode是判斷是否相等之類）： equals：是否同一個物件例項。注意，是“例項”。比如String s = new String("test");

Think in Java反芻筆記(5)---介面之策略設計模式

在Think in Java 的第九章介面中在9.3（完全解耦）節中看到一個程式碼，貼出來如下： import java.util.*;

《Java程式設計思想》《Think in Java》筆記

前言這本書不適合初學者，這本書適合已經學過Java框架並做過一兩個專案的同學來看，這本書對基礎知識的理解非常透徹。我在看的時候常常有一種醍醐灌頂的感覺，常常為“原來是這樣子的！”而激動，確實是一本非常好的書。我在看書時將書本我覺得重點的內容原封不動的摘錄下來，給想看重點的

Think In Java 學習筆記

1. 判斷什麼時候該用繼承，什麼時候該用組合？如果想利用新類內部一個現有類的特性，而不想使用它的介面，通常應選擇合成。為判斷自己到底應該選用合成還是繼承，一個最簡單的辦法就是考慮是否需要從新類上溯造型回基礎類。若必須上溯，就需要繼承。但如果不需要上溯造型，就應提醒自己防

Thinking in Java閱讀筆記（一）

第一章：物件導論抽象化的過程組合語言僅對底層的實體機器進行少量抽象化。許多所謂命令式程式語言（Fortran、BASIC、C），則在組合語言之上再抽象化。此類語言大幅改進了組合語言，但他們所做的主要是機器本身的抽象化，你依舊無法逃脫“以電腦結構進行問思考”的命運，因而

#Thinking in Java閱讀筆記# 第四章控制執行流程

迭代：while/do-while/for迴圈，在迭代語句的主體部分，可用break/continue控制迴圈的流程。 break：跳出迭代，且不執行餘下部分 continue：跳出當前迭代，執行下一次迴圈無限迴圈：while(true)/for(;;)

《Think in Java》閱讀筆記·第三卷

通過異常處理錯誤異常情形：是指阻止當前方法或作用域繼續執行的問題。監控區域：一段可能產生異常的程式碼區域，即try區域。異常處理程式：處理異常的地點，即catch區域。異常處理的兩種模型終止模型：一旦丟擲異常，將無法返回產生異常處。恢

《Think In Java》閱讀筆記 ·第一卷

過載基本型別的過載當傳入較小精確度的數值時，會呼叫擁有最接近該精確度形參的方法。當傳入較大精確度的數值時，需要至少窄化轉換成所有過載方法中最大精確度的數值，否則編譯器將報錯。不能通過方法的返回值來區分過載方法構造器的過載在構造器中可以呼叫

《TCP IP 詳解卷1：協議》閱讀筆記 - 第二章

網上能夠類別 ipv 範圍歸類標識符一次重要閱讀須知：筆記為閱讀《TCP IP 詳解卷1：協議》後摘抄的一些知識點，其間也有加入一些根據英文原版的自己翻譯和結合網上知識後的理解，所以有些段落之間並不能夠串聯上或者知識點與書上略有差別(基本差別不大，參考的資料屬

think in java第十五章關於網路程式設計的讀書筆記

對於java的網路程式設計書中討論的全部歸納起來有Socket的使用，DatagramSocket的使用，java與CGI的配合使用，java連線資料庫以及java中呼叫遠端方法。首先是Socket的使用，對於服務端來說，應該宣告的是ServerSo

工廠模式（think in java中的設計模式）

org 我們 import lac otf 返回值類型 int ava 工廠模式：工廠模式是利用工廠類的工廠方法創建對象的一種設計模式，目的是創建對象，但是很多時候創建對象我們會考慮很多其他因素~~~~比如限定輸入，限定返回值是否某個，比如在創建的過程中進行一些判斷，通過

叠代器模式（think in java中的設計模式）

一個 div 封裝 imp 叠代器方法 println rri 數字叠代器模式：用來叠代一個容器集合數組的一種模式。可能大家很多時候是用for循環進行叠代的，但是實際上for循環內部不能使用remove方法，但是叠代器可以，這是因為叠代器內部進行了該方法的邏輯處理。同樣

模板方法模式（think in java中的設計模式）

方法 bst pac code pri ack 單點 size clas 模板方法模式：模板方法模式顧名思義就是一種構造模塊化的設計模式。將一次行為分為多種行為，靈活的調用不同模塊進行工作。比如在飯店吃飯，分為：點菜，吃飯，買單等行為無論什麽飯店大致都是這三種行為。因此我們

【轉】我為什麽把think in java 讀了10遍

很好這樣的是的就會十分基礎網絡的確找工作我在想寫這篇博文之前，就曾經對我媳婦（她是做web前端的）講，我把think in java看了幾次幾次，媳婦那時就用很羨慕和莫名的眼神看著我說，你真有毅力，我當時就蒙了，我以為她會說，你現在基礎一定很好，很強大之類

Java泛型Generic - Thinking in Java讀書筆記

asp som 但是 oid 而且 containe nbsp 來替 note 1.什麽是泛型？泛型就是可適用於很多的類，它實現了參數化類型type parameter的概念，參數化類型指可使用多種類型。多態是一種泛化機制。例如方法 A(Base b){}//Base

Java中未給定初始值的基礎資料型別為什麼不能輸出　——Thinking in Java學習筆記（二）

在java程式設計思想第二章節中有這麼一個練習題：定義一個類，給定兩個無初始值的int和char型別的數值，輸出兩個數的值，驗證int和char的初始值。我第一次是這麼做的： public static void main(String[] args) { int i; char

《Think in Java》閱讀筆記·第二卷

內部類

內部類擁有外圍類的所有元素的訪問權

匿名內部類

匿名內部類若想要訪問外部物件，則該物件需要加final

巢狀類

介面內部的類

內部類的作用

控制框架是一類特殊的應用程式框架，用來解決響應事件的需求

回撥

內部類的繼承

容器

Set：只有元素不存在才會新增

List：不考慮重複，會按照新增順序進行排序

容器選擇：

迭代器

棧（疊加棧）

佇列

PriorityQueue的使用

通過繼承AbstractCollection重寫迭代類

自定義foreach規則

相關推薦