Thinking in Java 第四版完整版第八章練習題多型

Thinking in Java 第四版完整版第八章練習題，記錄一下(jdk1.8.0)

/**
 * 練習1：建立一個Cycle類，它具有子類Unicycle、Bicycle和
 * Tricycle。演示每一個型別的示例都可以經由ride()方法向上
 * 轉型為Cycle。
 * @author admin11
 * @date 2018年3月28日
 */
class Cycle {}

class Unicycle extends Cycle {}

class Bicycle extends Cycle {}

class Tricycle extends Cycle {}

public 
 class Exercise801 {
    public static void ride(Cycle cycle) {}

    public static void main(String[] args) {
        ride(new Unicycle());
        ride(new Bicycle());
        ride(new Tricycle());
    }
}

/**
 * 練習2：在幾何圖形的示例中新增@Override註解。
 * @author admin11
 * @date 2018年3月28日
 */
 public class 
 Shape {
    public void draw() {}
    public void erase() {}
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }
}

public class 
 Square extends Shape{
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Square.erase()");
    }
}

public class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("Triangle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Triangle.erase()");
    }
}

import java.util.Random;

public class RandomShapeGenerator {
    private Random rand = new Random(47);
    public Shape next() {
        switch (rand.nextInt(3)) {
        default:
        case 0:
            return new Circle();
        case 1:
            return new Square();
        case 2:
            return new Triangle();
        }
    }
}

public class Shapes {
    private static RandomShapeGenerator gen = new RandomShapeGenerator();
    public static void main(String[] args) {
        Shape[] s = new Shape[9];
        for (int i = 0; i < s.length; i++) {
            s[i] = gen.next();
        }
        for (Shape shape : s) {
            shape.draw();
        }
    }
}

這裡寫圖片描述

/**
 * 練習3：在基類Shapes.java中新增一個新方法，用於列印一條訊息，
 * 但匯出類中不要覆蓋這個方法。請解釋發生了什麼。現在，在其中一個匯出
 * 類中覆蓋該方法，而在其他的匯出類中不予覆蓋，觀察又有什麼發生。最後，
 * 在所有的匯出類中覆蓋這個方法。
 * @author admin11
 * @date 2018年3月28日
 */
public class Shape {
    public void draw() {}
    public void erase() {}
    public void testPrint() {
        System.out.println("shape.testPrint()");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Circle.testPrint()");
    }
}

public class Square extends Shape{
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Square.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Square.testPrint()");
    }
}

public class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("Triangle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Triangle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Triangle.testPrint()");
    }
}

import java.util.Random;

public class RandomShapeGenerator {
    private Random rand = new Random(47);
    public Shape next() {
        switch (rand.nextInt(3)) {
        default:
        case 0:
            return new Circle();
        case 1:
            return new Square();
        case 2:
            return new Triangle();
        }
    }
}

public class Shapes {
    private static RandomShapeGenerator gen = new RandomShapeGenerator();
    public static void main(String[] args) {
        Shape[] s = new Shape[9];
        for (int i = 0; i < s.length; i++) {
            s[i] = gen.next();
        }
        for (Shape shape : s) {
            shape.draw();
            shape.testPrint();
        }
    }
}

這裡寫圖片描述

/**
 * 練習4：向Shapes.java中新增一個新的Shape型別，並在main()
 * 方法中驗證：多型對新型別的作用是否與在舊型別中的一樣。
 * @author admin11
 * @date 2018年3月28日
 */
class Shape {
    public void draw() {}
    public void erase() {}
    public void testPrint() {
        System.out.println("shape.testPrint()");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Circle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Circle.testPrint()");
    }
}

class Square extends Shape{
    @Override
    public void draw() {
        System.out.println("Square.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Square.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Square.testPrint()");
    }
}

class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("Triangle.draw()");
    }
    @Override
    public void erase() {
        System.out.println("Triangle.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("Triangle.testPrint()");
    }
}

class newShape extends Shape{
    @Override
    public void draw() {
        System.out.println("newShape.draw()");
    }
    @Override
    public void erase() {
        System.out.println("newShape.erase()");
    }
    @Override
    public void testPrint() {
        System.out.println("newShape.testPrint()");
    }
}

public class Exercise804 {
    public static void main(String[] args) {
        Shape[] sp = {new Circle(), new Square(),
                new Triangle(), new newShape()};
        for (Shape shape : sp) {
            shape.draw();
            shape.erase();
            shape.testPrint();
        }
    }
}

這裡寫圖片描述

/**
 * 練習5：以練習1為基礎，在Cycle中新增wheels()方法，它將返回
 * 輪子的數量。修改ride()方法，讓它呼叫wheels()方法，並驗證
 * 多型起作用了。
 * @author admin11
 * @date 2018年3月28日
 */
class Cycle {
    public String wheels() {
        return "Cycle wheels : none";
    }
}

class Unicycle extends Cycle {
    @Override
    public String wheels() {
        return "Unicycle wheels : 4";
    }
}

class Bicycle extends Cycle {
    @Override
    public String wheels() {
        return "Bicycle wheels : 2";
    }
}

class Tricycle extends Cycle {
    @Override
    public String wheels() {
        return "Tricycle wheels : 3";
    }
}

public class Exercise805 {
    public static void ride(Cycle cycle) {
        System.out.println(cycle.wheels());
    }
    public static void main(String[] args) {
        Cycle[] c = {new Unicycle(), new Bicycle(),
                new Tricycle()};
        for (Cycle cycle : c) {
            ride(cycle);
        }
    }
}

這裡寫圖片描述

/**
 * 練習6：修改Music3.java,使what()方法成為根Object的
 * toString()方法。試用System.out.println()方法列印
 * Instrument物件（不用向上轉型）。
 * @author admin11
 * @date 2018年3月28日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    void play(Note n) {
        System.out.println("Instrument.play() " + n);
    }
    @Override
    public String toString() {
        return "Instrument";
    }
    void adjust() {
        System.out.println("Adjusting Instrument");
    }
}

class Wind extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Wind.play() " + n);
    }
    @Override
    public String toString() {
        return "Wind";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Wind");
    }
}

class Percussion extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }
    @Override
    public String toString() {
        return "Percussion";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

class Stringed extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }
    @Override
    public String toString() {
        return "Stringed";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

class Brass extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Brass.play() " + n);
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }
    @Override
    public String toString() {
        return "Woodwind";
    }
}

public class Exercise806 {
    static Instrument[] orchestra = {
            new Wind(),
            new Percussion(),
            new Stringed(),
            new Brass(),
            new Woodwind()
    };

    public static void printAll(Instrument[] e) {
        for (Instrument instrument : e) {
            System.out.println(instrument);
        }
    }

    public static void main(String[] args) {
        printAll(orchestra);
    }
}

這裡寫圖片描述

/**
 * 練習7：向Music3.java新增一個新的型別Instrument,
 * 並驗證多型性是否作用於所新增的新型別。
 * @author admin11
 * @date 2018年3月28日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    void play(Note n) {
        System.out.println("Instrument.play() " + n);
    }
    @Override
    public String toString() {
        return "Instrument";
    }
    void adjust() {
        System.out.println("Adjusting Instrument");
    }
}

class Wind extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Wind.play() " + n);
    }
    @Override
    public String toString() {
        return "Wind";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Wind");
    }
}

class Percussion extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }
    @Override
    public String toString() {
        return "Percussion";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

class Stringed extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }
    @Override
    public String toString() {
        return "Stringed";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

class Brass extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Brass.play() " + n);
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }
    @Override
    public String toString() {
        return "Woodwind";
    }
}

class Electronic extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Electronic.play() " + n);
    }
    @Override
    public String toString() {
        return "Electronic";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Electronic");
    }
}

public class Exercise807 {

    public static void main(String[] args) {
        Instrument[] orchestra = {
                new Wind(),
                new Percussion(),
                new Stringed(),
                new Brass(),
                new Woodwind(),
                new Electronic()
        };

        for (Instrument instrument : orchestra) {
            instrument.play(Note.MIDDLE_C);
            instrument.adjust();
            System.out.println(instrument);
        }
    }
}

這裡寫圖片描述

import java.util.Random;
/**
 * 練習8：修改Music3.java,使其可以像Shapes.java中的方式
 * 那樣隨機建立Instrument物件。
 * @author admin11
 * @date 2018年3月28日
 */
enum Note {
    MIDDLE_C, C_SHARP, B_FLAT;
}

class Instrument {
    void play(Note n) {
        System.out.println("Instrument.play() " + n);
    }
    @Override
    public String toString() {
        return "Instrument";
    }
    void adjust() {
        System.out.println("Adjusting Instrument");
    }
}

class Wind extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Wind.play() " + n);
    }
    @Override
    public String toString() {
        return "Wind";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Wind");
    }
}

class Percussion extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }
    @Override
    public String toString() {
        return "Percussion";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

class Stringed extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }
    @Override
    public String toString() {
        return "Stringed";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

class Brass extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Brass.play() " + n);
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }
    @Override
    public String toString() {
        return "Woodwind";
    }
}

class Electronic extends Instrument {
    @Override
    void play(Note n) {
        System.out.println("Electronic.play() " + n);
    }
    @Override
    public String toString() {
        return "Electronic";
    }
    @Override
    void adjust() {
        System.out.println("Adjusting Electronic");
    }
}

class InstrumentGenerator {
    public Instrument next() {
        switch (new Random().nextInt(6)) {
        default:
        case 0:
            return new Wind();
        case 1:
            return new Percussion();
        case 2:
            return new Stringed();
        case 3:
            return new Brass();
        case 4:
            return new Woodwind();
        case 5:
            return new Electronic();
        }
    }
}

public class Exercise808 {
    public static void main(String[] args) {
        InstrumentGenerator gen = new InstrumentGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(gen.next());
        }
    }
}

這裡寫圖片描述

/**
 * 練習9：建立Rodent（齧齒動物）:Mouse(老鼠),Gerbil(鼴鼠),
 * Hamster(大頰鼠),等等這樣一個的繼承層次結構。在基類中，提供對所
 * 有的Rodent都通用的方法，在匯出類中，根據特定的Rodent型別覆蓋
 * 這些方法，以便它們執行不同的行為。建立一個Rodent陣列，填充不同
 * 的Rodent型別，然後呼叫基類方法，觀察發生什麼情況。
 * @author admin11
 * @date 2018年3月28日
 */
class Rodent {
    public void eat() {
        System.out.println("eat...");
    }
    public void sleep() {
        System.out.println("sleep...");
    }
}

class Mouse extends Rodent{
    @Override
    public void eat() {
        System.out.println("Mouse eat...");
    }
    @Override
    public void sleep() {
        System.out.println("Mouse sleep...");
    }
}

class Gerbil extends Rodent {
    @Override
    public void eat() {
        System.out.println("Gerbil eat...");
    }
    @Override
    public void sleep() {
        System.out.println("Gerbil sleep...");
    }
}

class Hamster extends Rodent {
    @Override
    public void eat() {
        System.out.println("Hamster eat...");
    }
    @Override
    public void sleep() {
        System.out.println("Hamster sleep...");
    }
}

public class Exercise809 {
    public static void main(String[] args) {
        Rodent[] rd = {
                new Mouse(),
                new Gerbil(),
                new Hamster()
        };
        for (Rodent rodent : rd) {
            rodent.eat();
            rodent.sleep();
        }
    }
}

這裡寫圖片描述

10.

/**
 * 練習10：建立一個包含兩個方法的基類。在第一個方法中可以呼叫第二個
 * 方法。然後產生一個繼承自該基類的匯出類，且覆蓋基類中的第二個方法。
 * 為該匯出類建立一個物件，將它向上轉型到基型別並呼叫第一個方法，解
 * 釋發生的情況。
 * @author admin11
 * @date 2018年3月28日
 */
class TwoMethods {
    public void m1() {
        System.out.println("Inside m1, calling m2");
        m2();
    }
    public void m2() {
        System.out.println("Inside m2");
    }
}

public class Exercise810 extends TwoMethods{
    public void m2() {
        System.out.println("Inside Exercise810.m2");
    }
    public static void main(String[] args) {
        TwoMethods t = new Exercise810();
        t.m1();
        // 呼叫匯出類的m1()方法，m1()方法呼叫了m2,
        // m2在匯出類被重寫了
    }
}

這裡寫圖片描述

11.

/**
 * 練習11：向Sandwich.java中新增Pickle類。
 * @author admin11
 * @date 2018年3月30日
 */
class Meal {
    Meal() {
        System.out.println("Meal()");
    }
}

class Bread {
    Bread() {
        System.out.println("Bread()");
    }
}

class Cheese {
    Cheese() {
        System.out.println("Cheese()");
    }
}

class Lettuce {
    Lettuce() {
        System.out.println("Lettuce");
    }
}

class Lunch extends Meal {
    Lunch() {
        System.out.println("Lunch()");
    }
}

class PortableLunch extends Lunch {
    PortableLunch() {
        System.out.println("PortableLunch()");
    }
}

class Pickle {
    Pickle() {
        System.out.println("Pickle()");
    }
}

public class Sandwich extends PortableLunch {
    private Bread b = new Bread();
    private Cheese c = new Cheese();
    private Lettuce l = new Lettuce();
    private Pickle p = new Pickle();
    public Sandwich() {
        System.out.println("Sandwich()");
    }
    public static void main(String[] args) {
        new Sandwich();
    }
}

這裡寫圖片描述

12.

/**
 * 練習12：修改練習9，使其能夠演示基類和匯出類的初始化順序。然後
 * 向基類和匯出類中新增成員物件，並說明構建期間初始化發生的順序。
 * @author admin11
 * @date 2018年3月30日
 */
class Member {
    public Member(String id) {
        System.out.println("Member constructor " + id);
    }
}

class Rodent2 {
    Member m1 = new Member("r1"),
            m2 = new Member("r2");
    public Rodent2() {
        System.out.println("Rodent constructor");
    }
    public void hop() {
        System.out.println("Rodent hopping");
    }
    public void scurry() {
        System.out.println("Rodent scurrying");
    }
    public void reproduce() {
        System.out.println("Making more Rodents");
    }
    public String toString() {
        return "Rodent";
    }
}

class Mouse2 extends Rodent2 {
    Member m1 = new Member("m1"),
            m2 = new Member("m2");
    public Mouse2() {
        System.out.println("Mouse2 constructor");
    }
    public void hop() {
        System.out.println("Mouse2 hopping");
    }
    public void scurry() {
        System.out.println("Mouse2 scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Mice");
    }
    @Override
    public String toString() {
        return "Mouse";
    }
}

class Gerbil2 extends Rodent2 {
    Member m1 = new Member("g1"),
            m2 = new Member("g2");
    public Gerbil2() {
        System.out.println("Gerbil2 constructor");
    }
    @Override
    public void hop() {
        System.out.println("Gerbil2 hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Gerbil2 scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Gerbils");
    }
    @Override
    public String toString() {
        return "Gerbil";
    }
}

class Hamster2 extends Rodent2 {
    Member m1 = new Member("h1"),
            m2 = new Member("h2");
    public Hamster2() {
        System.out.println("Hamster constructor");
    }
    @Override
    public void hop() {
        System.out.println("Hamster hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Hamster scurrying");
    }
    @Override
    public void reproduce() {
        System.out.println("Making more Hamsters");
    }
    @Override
    public String toString() {
        return "Hamster";
    }
}

public class Exercise812 {
    // 先初始化基類的成員變數，呼叫基類的構造方法；
    // 然後初始化匯出類的成員變數，呼叫匯出類的構造方法。
    public static void main(String[] args) {
        new Hamster2();
    }
}

這裡寫圖片描述

13.

/**
 * 練習13：在ReferenceCounting.java中新增一個finalize()
 * 方法，用來校驗終止條件。
 * @author admin11
 * @date 2018年3月30日
 */
class Shared {
    private int refcount = 0;
    private static int counter = 0;
    private int id = counter++;
    public Shared() {
        System.out.println("Creating " + this);
    }
    public void addRef() {
        refcount++;
    }
    protected void dispose() {
        if(--refcount == 0) {
            System.out.println("Disposing " + this);
        }
    }
    protected void finalize() {
        if(refcount != 0) {
            System.out.println("Error: object is not properly cleaned-up!");
        }
    }
    @Override
    public String toString() {
        return "Shared" + id;
    }
}

class Composing {
    private Shared shared;
    private static int counter = 0;
    private int id = counter++;
    public Composing(Shared shared) {
        System.out.println("Creating " + this);
        this.shared = shared;
        this.shared.addRef();
    }
    protected void dispose() {
        System.out.println("disposing" + this);
        shared.dispose();
    }
    @Override
    public String toString() {
        return "Composing " + id;
    }
}

public class Exercise813 {
    public static void main(String[] args) {
        Shared shared = new Shared();
        Composing[] composing = { new Composing(shared),
            new Composing(shared),  new Composing(shared),
            new Composing(shared), new Composing(shared)
        };
        for (Composing c : composing) {
            c.dispose();
        }
        System.gc();
        new Composing(new Shared());
        System.gc();
    }
}

這裡寫圖片描述

14.

/**
 * 練習14：修改練習12，使得其某個成員物件變為具有引用計數的共享物件，
 * 並證明它可以正確執行。
 * @author admin11
 * @date 2018年3月30日
 */
class NonSharedMember {
    public NonSharedMember(String id) {
        System.out.println("Non shared member constructor " + id);
    }
}

class SharedMember {
    private int refcount;
    public void addRef() {
        System.out.println("Number of references " + ++refcount);
    }
    protected void dispose() {
        if(--refcount == 0) {
            System.out.println("Disposing " + this);
        }
    }
    public SharedMember() {
        System.out.println("Shared member constructor");
    }
    @Override
    public String toString() {
        return "Shared member";
    }
}

class Rodent3 {
    private SharedMember m;
    NonSharedMember m1 = new NonSharedMember("r1"),
            m2 = new NonSharedMember("r2");
    public Rodent3(SharedMember sm) {
        System.out.println("Rodent constructor");
        m = sm;
        m.addRef();
    }
    public void hop() {
        System.out.println("Rodent hopping");
    }
    public void scurry() {
        System.out.println("Rodent scurrying");
    }
    public void reproduce() {
        System.out.println("Making more Rodents");
    }
    public void dispose() {
        System.out.println("Disposing " + this);
        m.dispose();
    }
    @Override
    public String toString() {
        return "Rodent";
    }
}

class Mouse3 extends Rodent3 {
    NonSharedMember m1 = new NonSharedMember("m1"),
            m2 = new NonSharedMember("m2");
    public Mouse3(SharedMember sm) {
        super(sm);
        System.out.println("Mouse constructor");
    }
    @Override
    public void hop() {
        System.out.println("Mouse hopping");
    }
    @Override
    public void scurry() {
        System.out.println("Mouse scurring");
    }
    @Override
    public  
 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    Thinking in Java 第四版完整版 第九章練習題 介面
       
  
  
  
  Thinking in Java 第四版完整版 第九章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 package com.test.c09;
/**
 * 練習1：修改第八章練習9中的Rodent,使其成為一個抽象類。只要有可能，
 * 就將Rodent的方法宣告為抽象 

  
 

    

    
    Thinking in Java 第四版完整版 第八章練習題 多型
       
  
  
  
  Thinking in Java 第四版完整版 第八章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 /**
 * 練習1：建立一個Cycle類，它具有子類Unicycle、Bicycle和
 * Tricycle。演示每一個型別的示例都可以經由ride()方法向上
 *  

  
 

    

    
    Thinking in Java 第四版完整版 第七章練習題 複用類
       
  
  
  
  Thinking in Java 第四版完整版 第七章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 /**
 * 練習1：建立一個簡單的類。在第二個類中，將一個引用定義為第一個類
 * 的物件。運用惰性初始化來例項化這個物件。
 * @author admin11
 *  

  
 

    

    
    Thinking in Java 第四版完整版 第五章練習題 初始化與清理
       
  
  
  
  Thinking in Java 第四版完整版 第五章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 /**
 * 練習1：建立一個類，它包含一個未初始化的String引用。驗證該引用被Java初始化成了null。
 * @author admin11
 * @date 2 

  
 

    

    
    Thinking in Java 第四版完整版 第六章練習題 訪問許可權控制
       
  
  
  
  Thinking in Java 第四版完整版 第六章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 package com.test.c06;

/**
 * 練習1:在某個包中建立一個類，在這個類所處的包的外部建立該類的一個例項。
 * @author admin11
 

  
 

    

    
    Thinking in Java 第四版完整版 第四章練習題
       
  
  
  
  Thinking in Java 第四版完整版 第四章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 /**
 * 練習1：寫一個程式，列印從1到100的值。
 * @author admin11
 * @date 2018年3月1日
 */
public class Ex 

  
 

    

    
    Thinking in Java 第四版完整版 第三章練習題
       
  
  
  
  Thinking in Java 第四版完整版 第三章練習題，記錄一下(jdk1.8.0) 
  
 1. 
 import java.util.*;
//import static net.mindview.util.Print.*;

/**
 * 練習1：使用“簡短的”和正常的 

  
 

    

    
    Thinking in Java 第四版完整版 第二章練習題
       
  
  
  
  Thinking in Java 第四版完整版 第二章練習題，記錄一下(jdk1.8.0_111) 
  
 1. 
 /**
 * 練習1: 建立一個類，它包含一個int域和一個char域，它們都沒有被初始化，將它們的值打印出來，以驗證Java執行了預設初始化。
 * @autho 

  
 

    

    
    thinking in java (十四) ----- 集合之Stack
       
 
 stack很簡單，繼承與Vector 
  
  stack介紹 
  
 
  stack簡介 
 
 stack是棧，特性是先進後出（FILO） 
 java中的stack是繼承自Vector（向量佇列）由於Vector是陣列實現的，這就意味著stack也是通過陣列實現的 ，而非連結串列。 
  

  
 

    

    
    Java程式設計思想第四版讀書筆記——第五章 初始化與清理
      
                第五章 初始化與清理





1 用構造器確保初始化



使用構造器（condructor），在建立物件時初始化。分為帶引數的初始化和不帶引數的初始化。





2 方法過載



型別提升（向上提升）：int — long — float — double

     

  
 

    

    
    Java程式設計思想第四版讀書筆記——第九章 介面
      
                這章介紹了介面卡設計模式和策略設計模式。

第九章  介面



介面和內部類為我們提供了一種將介面與實現分離的更加結構化的方法。



1、抽象類和抽象方法



public abstract void f();

建立抽象類是希望通過這個通用介面操縱一系列類。如果一個類 

  
 

    

    
    Java程式設計思想第四版讀書筆記——第十二章 通過異常處理錯誤
      
                
第十二章 通過異常處理錯誤
Java的基本理念是“結構不佳的程式碼不能執行”。
Java中異常處理的目的在於通過使用少於目前數量的程式碼來簡化大型、可靠的程式的生成，並且通過這種方式可以使程式設計師增加自信。

1、概念
因為異常機制將保證能夠捕獲這個錯誤，所以不用小心翼翼 

  
 

    

    
    Java程式設計思想第四版讀書筆記——第四章 控制執行流程
      
                
Java程式設計思想第四版第四章讀書筆記——控制執行流程。因為有些C++和android開發基礎，所以基礎知識筆記就不寫了，記些特別的需要注意的地方。


第四章 控制執行流程

1.true和false

Java不允許我們將一個數字作為布林值使用，雖然這在C和C++裡是 

  
 

    

    
    Hadoop權威指南-大資料的儲存與分析第四版——學習筆記——第2章——1
       
  
  
 MapReduce 
 適合處理半結構化的資料 
 MapReduce任務階段 
 Map階段+Reduce階段 Key-Value作為輸入輸出 實現兩個函式：map(),reduce() 
 Map階段 
 輸入的Key：文字中的偏移量 輸入的value：文字 輸出的k-v給reduce處 

  
 

    

    
    讀書筆記： 鳥哥基礎篇第四版（第一、二章 磁碟劃分)
      
							
							
							
主要內容：

Linux硬體的命名
MBR和GPT分割槽的區別， 對應分割槽槽的命名，primary, extended, logical分割槽
掛載點


Chap1 Linux 是什麼與如何學習
1.1 Linux是什麼
1.1.1 作業系統位置

向下管 

  
 

    

    
    《現代作業系統（中文第四版）》筆記  第一章 引論
      
							
							
							既然買了《現代作業系統》（《Modern Operating System》）這本書，那就好好學習一下吧，這是第一篇讀書筆記。

第一章 引論

計算機系統總的來說分為軟體和硬體，如下圖所示。多數計算機有兩種執行模式：核心態和使用者態。軟體中最基礎的部分是作業系 

  
 

    

    
    Java程式設計思想 第八章：多型
       
  
  
 OOP語言中，多型是封裝、繼承之後的第三種基本特徵。 
 封裝：通過合併特徵和行為來建立新的資料型別，“實現隱藏”通過細節“私有化”把介面和實現分離 
 繼承：以複用介面方式從已有型別用extends關鍵字建立新型別，並允許向上轉型 
 多型：消除型別之間的耦合關係(分離做什麼和怎麼做)，基 

  
 

    

    
    “全棧2019”Java第五十八章：多型中方法返回型別可以是子類型別
      難度 
初級 
學習時間 
10分鐘 
適合人群 
零基礎 
開發語言 
Java 
開發環境 
 
 JDK v11 
 IntelliJ IDEA v2018.3 
 
文章原文連結 
“全棧2019”Java第五十八章：多型中方法返回型別可以是子類型別 
下一章 
“全棧2019”Java第五十九章：抽 

  
 

    

    
    Thinking in Java（第四版）—— 第二章 一切皆對象
      ati   靜態   數據類型   thinking   short   str   變量   屬於   字符    一.對象保存的位置

寄存器（cpu）
棧（變量）
堆（對象）
靜態域（static）
常量池（string）
非內存區池   

二.基本數據類型
   整數型 byte short int 

  
 

    

    
    Thinking in Java 4th（Java程式設計思想第四版）文件、原始碼、習題答案
      
 　　Thinking in Java 4th 中、英文兩版pdf文件，書中原始碼及課後習題答案。連結：https://pan.baidu.com/s/1BKJdtgJ3s-_rN1OB4rpLTQ 密碼：2zc4 
 　　http://greggordon.org/java/tij4/solutions.

Thinking in Java 第四版完整版第八章練習題多型

Thinking in Java 第四版完整版第九章練習題介面

Thinking in Java 第四版完整版第八章練習題多型

Thinking in Java 第四版完整版第七章練習題複用類

Thinking in Java 第四版完整版第五章練習題初始化與清理

Thinking in Java 第四版完整版第六章練習題訪問許可權控制

Thinking in Java 第四版完整版第四章練習題

Thinking in Java 第四版完整版第三章練習題

Thinking in Java 第四版完整版第二章練習題

thinking in java (十四) ----- 集合之Stack

Java程式設計思想第四版讀書筆記——第五章初始化與清理

Java程式設計思想第四版讀書筆記——第九章介面

Java程式設計思想第四版讀書筆記——第十二章通過異常處理錯誤

Java程式設計思想第四版讀書筆記——第四章控制執行流程

Hadoop權威指南-大資料的儲存與分析第四版——學習筆記——第2章——1

讀書筆記：鳥哥基礎篇第四版（第一、二章磁碟劃分)

《現代作業系統（中文第四版）》筆記第一章引論

Java程式設計思想第八章：多型

“全棧2019”Java第五十八章：多型中方法返回型別可以是子類型別

Thinking in Java（第四版）—— 第二章一切皆對象

Thinking in Java 4th（Java程式設計思想第四版）文件、原始碼、習題答案

Thinking in Java 第四版完整版 第八章練習題 多型

相關推薦

Thinking in Java 第四版完整版第八章練習題多型