2. 程式人生 > >Java程式設計思想第七章複用類練習題解答

Java程式設計思想第七章複用類練習題解答

阿新 • • 發佈：2018-12-05

練習題解答

練習1

建立一個簡單的類。第二個類中，將一個引用定義為第一個類的物件。運用惰性初始化來例項化 這個物件。

package ch7;

class Enginee{
    Enginee(){
        System.out.println("Hello world");
    }
}

public class Exercise1{
    Enginee enginee;
    public String toString(){
        if (enginee == null){
            enginee = new Enginee();
        }
        return "Enginee:" + enginee;
    }

    public static void main(String[] args) {
        Exercise1 exercise1 = new Exercise1();
        System.out.println(exercise1.toString());
    }
}

練習2

從Detergent中繼承產生一個新的類。覆蓋scrub()並新增一個名為sterilize()的新方法。

package ch7;
//extends

class Cleaner{
    private String s = "Cleaner";
    public void append(String a){ s+= a;}
    public void dilute(){ append(" dilute()");}
    public void apply() {append(" apply()");}
    public void scrub(){append(" scrub()");}
    public String toString(){ return s;}

    public static void main(String[] args) {
        Cleaner x = new Cleaner();
        x.dilute(); x.apply(); x.scrub();
        System.out.println(x);
    }
}

/**
 *
 */
class Detergent extends Cleaner{
    public void scrub() {
        append(" Detergent.scrub()");
        super.scrub();
    }

    //add method to the interface
    public void foam(){ append(" foam()");}
    //Test new class
    public static void main(String[] args) {
        Detergent x = new Detergent();
        x.dilute();
        x.apply();
        x.scrub();
        x.foam();
        System.out.println(x);
        System.out.println(" Testing base class:");
        Cleaner.main(args);
    }
}

public class Ex2 extends Detergent{
    @Override
    public void scrub() {
        System.out.println("Ex2.scrub()");
        super.scrub();
    }

    public void sterilize(){
        System.out.println(" Ex2.sterilize()");
    }

    public static void main(String[] args) {
        Ex2 ex2 = new Ex2();
        ex2.scrub();
        ex2.sterilize();
        ex2.apply();
        System.out.println(ex2);
    }
    
}
/**output:
 * Ex2.scrub()
 *  Ex2.sterilize()
 * Cleaner Detergent.scrub() scrub() apply()
 *
 * Process finished with exit code 0
 * 
 * **/

練習3

即使你不為Cartoon(這裡為Ex3)建立構造器，編譯器也為會你合成一個預設的構造器，該構造器將呼叫基類的構造器

package ch7;

class Art{
    Art(){
        System.out.println("Art constructor");
    }
}

class Drawing extends Art{
    Drawing(){
        System.out.println("Drawing constructor");
    }
}

public class Ex3 extends Drawing{
    public static void main(String[] args) {
        Ex3 ex3 = new Ex3();
    }
}
/**
output:
Art constructor
Drawing constructor

Process finished with exit code 0
**/

練習4

在練習3的基礎上改一改，修改後如下：

package ch7;

class Art{
    Art(){
        System.out.println("Art constructor");
    }
}

class Drawing extends Art{
    Drawing(){
        System.out.println("Drawing constructor");
    }
}

public class Ex3 extends Drawing{
    Ex3(){
        System.out.println("Ex3 constructor");
    }
    public static void main(String[] args) {
        Ex3 ex3 = new Ex3();
        //test
        new Drawing();
    }
}
/**
 * Art constructor
 * Drawing constructor
 * Ex3 constructor
 * Art constructor
 * Drawing constructor
 *
 * Process finished with exit code 0
 * **/

練習5

package ch7;

/**
class A { A(){ System.out.println("A()");} }

class B extends A { B(){ System.out.println("B()");} }

class C extends A {
    B b = new B(); // will then construct another A and then a B
    public static void main(String[] args) {
        System.out.println("C.A");
        C c = new C(); // will construct an A first
    }
}**/



class A{
    A(){
        System.out.println("fA");
    }
}

class B extends A{
    B(){
        System.out.println("fB");
    }
}

class C extends A{
    void fC(){
        B b = new B();
        System.out.println("fC");
    }
}

public class Ex5 {
    B b = new B();
    public static void main(String[] args) {
        Ex5 ex5 = new Ex5();
    }
}
/**output:
 * fA
 * fB
 *
 * Process finished with exit code 0
 * **/

練習6

class Game {
	Game(int i) {
		 System.out.println("Game constructor");
	}	
}

class BoardGame extends Game {
	BoardGame(int i) {
		//  System.out.println("BoardGame constructor"); // call to super must be first
			// statement in constructor 
		super(i); // else: "cannot find symbol: constructor Game()
		 System.out.println("BoardGame constructor");
	}
}

public class Chess extends BoardGame {
	Chess() {
		super(11);
		 System.out.println("Chess constructor");
	}
	public static void main(String[] args) {
		Chess x = new Chess();
	}
}
/**output:
 * Game constructor
 * BoardGame constructor
 * Chess constructor
 *
 * Process finished with exit code 0
 * **/

練習7

package ch7;

class A{
    A(int i){
        System.out.println("fA");
    }
}

class B extends A{
    B(int i){
        super(i);
        System.out.println("fB");
    }
}

class C extends A{
    C(){
        super(11);
        System.out.println("fC");
    }
    B b = new B(11);
    public static void main(String[] args) {
        C ex5 = new C();
    }
}

/**
 * fA
 * fA
 * fB
 * fC
 *
 * Process finished with exit code 0
 * **/

練習8

package ch7;

class Base{
    Base(String s, Integer i){
        System.out.println("String: " + s + ", Integer:" + String.valueOf(i));
    }
}

class ExportBase extends Base{
    ExportBase(){
        super("String", 3);
        System.out.println(" ExportBase default");
    }

    ExportBase(String s, Integer i){
        super(s, i);
        System.out.println(" ExportBase String:" + s + ", Integer: " + String.valueOf(i));
    }

    public static void main(String[] args) {
        ExportBase exportBase = new ExportBase();
        ExportBase exportBase2 = new ExportBase("String", 4);
    }
}
/**
 * output:
 * String: String, Integer:3
 *  ExportBase default
 * String: String, Integer:4
 *  ExportBase String:String, Integer: 4
 *
 * Process finished with exit code 0
 * 
 * **/

練習9

package ch7;

class Component1{
    Component1(){
        System.out.println("Component1 constructor");
    }
}
class Component2{
    Component2(){
        System.out.println("Component2 constructor");
    }
}
class Component3{
    Component3(){
        System.out.println("Component3 constructor");
    }
}

class Root {
    Component1 cp1 = new Component1();
    Component2 cp2 = new Component2();
    Component3 cp3 = new Component3();
    Root(){
        System.out.println("Root constructor");
    }
}

class Stem extends Root{
    Component1 cp1 = new Component1();
    Component2 cp2 = new Component2();
    Component3 cp3 = new Component3();
    Stem(){
        System.out.println("Stem constructor");
    }
    public static void main(String[] args) {
        Stem stem = new Stem();
    }
}
/**
 Component1 constructor
 Component2 constructor
 Component3 constructor
 Root constructor
 Component1 constructor
 Component2 constructor
 Component3 constructor
 Stem constructor

 Process finished with exit code 0
 * **/

練習10

package ch7;

class Component1{
    Component1(String s){
        System.out.println("Component1 constructor: " + s);
    }
}
class Component2{
    Component2(String s){
        System.out.println("Component2 constructor: " + s);
    }
}
class Component3{
    Component3(String s){
        System.out.println("Component3 constructor: " + s);
    }
}

class Root {
    Component1 cp1 = new Component1("Component1");
    Component2 cp2 = new Component2("Component2");
    Component3 cp3 = new Component3("Component3");
    Root(){
        System.out.println("Root constructor");
    }
}

class Stem extends Root{
    Component1 cp1 = new Component1("Component1");
    Component2 cp2 = new Component2("Component2");
    Component3 cp3 = new Component3("Component3");
    Stem(){
        System.out.println("Stem constructor");
    }
    public static void main(String[] args) {
        Stem stem = new Stem();
    }
}
/**
 Component1 constructor: Component1
 Component2 constructor: Component2
 Component3 constructor: Component3
 Root constructor
 Component1 constructor: Component1
 Component2 constructor: Component2
 Component3 constructor: Component3
 Stem constructor

 Process finished with exit code 0
 * **/

練習11

package ch7;

class class1{
    private String s;

    public void setS(String s) {
        this.s = s;
    }
    public String getS(String s) {
        return s;
    }

    void up(String s){
        System.out.println("class1-up: " + s);
    }

    void down(String s){
        System.out.println("class1-down: " + s);
    }

    void left(String s){
        System.out.println("class1-left: " + s);
    }

    void right(String s){
        System.out.println("class1-right: " + s);
    }
}

class Detergent1 {
    class1 cla1 = new class1();
    void up(String s){
        System.out.println("Detergent1-up: " + s);
    }

    void down(String s){
        System.out.println("Detergent1-down: " + s);
    }

    void left(String s){
        System.out.println("Detergent1-left: " + s);
    }

    void right(String s){
        System.out.println("Detergent1-right: " + s);
    }
    public static void main(String[] args) {
        String s = "mainString";
        Detergent1 detergent1 = new Detergent1();
        detergent1.down(s);
    }
}
/**output:
 * Detergent1-down: mainString

 Process finished with exit code 0**/

public class Ex11 {
}

練習12

練習13

package ch7;

class cls1{
    public String f(){
        System.out.println("no return");
        return "no return";
    }

    public String f(String s){
        System.out.println( "no return, String:" + s);
        return "no return, String:" + s;
    }

    public String f(char s){
        System.out.println( "no return, char: " + s);
        return "no return, char: " + s;
    }
}

class overloading extends cls1{
    public String f(Integer integer){
        System.out.println( "no return, Integer:" + String.valueOf(integer));
        return "no return, Integer:" + String.valueOf(integer);
    }

    public static void main(String[] args) {
        overloading ol = new overloading();
        ol.f(2);
        ol.f("hello");
        ol.f('c');
        ol.f();
    }
}
/*
* output:
* no return, Integer:2
no return, String:hello
no return, char: c
no return

Process finished with exit code 0
* */

練習14

package ch7;

class Engine{
    public void start(){}
    public void rev(){}
    public void stop(){}
}

class Wheel{
    public void inflate(int psi){}
}

class Window{
    public void rollup() {}
    public void rolldown() {}
}

class Door{
    public Window window = new Window();
    public void open(){}
    public void close(){}
}

class Servie{
    {System.out.println("Service");}
}

class Car {
    public Engine engine = new Engine();
    public Wheel[] wheel = new Wheel[4];
    public Door
        left = new Door(),
        right = new Door(); //2-door
    public  Car(){
        for (int i = 0; i < 4; i ++){
            wheel[i] = new Wheel();
        }
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.left.window.rollup();
        car.wheel[0].inflate(72);
        Servie servie = new Servie();
    }

}
/**
 * output:
 * Service
 *
 * Process finished with exit code 0
 * **/

public class P137 {
}

練習15

package ch7;

class Apple{
    private String s = "";
    public Apple(){
        System.out.println("Apple constructor");
    }
    protected String f(String s){
        this.s = s;
        return s;
    }
}

class Fruit{
    public static void main(String[] args) {
        Apple apple = new Apple();
        System.out.println(apple.f("hello world"));
    }
}

/**
 * Apple constructor
 * hello world
 *
 * Process finished with exit code 0
 * **/

練習16

package ch7;

class Amphibian {
    protected void swim() {
        System.out.println("Amphibian swim");
    }
    protected void speak() {
        System.out.println("Amphibian speak");
    }
    void eat() {
        System.out.println("Amphibian eat");
    }
    static void grow(Amphibian a) {
        System.out.println("Amphibian grow");
        a.eat();
    }
}

class Frog extends Amphibian {
    public static void main(String[] args) {
        Frog f = new Frog();
        // call base-class methods:
        f.swim();
        f.speak();
        f.eat();
        // upcast Frog to Amphibian argument:
        Amphibian.grow(f);
    }
}
/**
 * output:
 * Amphibian swim
 * Amphibian speak
 * Amphibian eat
 * Amphibian grow
 * Amphibian eat
 *
 * Process finished with exit code 0
 * **/

public class Ex16 {
}

練習17

class Amphibian {
    protected void swim() {
        System.out.println("Amphibian swim");
    }
    protected void speak() {
        System.out.println("Amphibian speak");
    }
    void eat() {
        System.out.println("Amphibian eat");
    }
    static void grow(Amphibian a) {
        System.out.println("Amphibian grow");
        a.eat();
    }
}

class Frog17 extends Amphibian {
    @Override protected void swim() {
        System.out.println("Frog swim");
    }
    @Override protected void speak() {
        System.out.println("Frog speak");
    }
    @Override void eat() {
        System.out.println("Frog eat");
    }
    static void grow(Amphibian a) {
        System.out.println("Frog grow");
        a.eat();
    }
    public static void main(String[] args) {
        Frog17 f = new Frog17();
        // call overridden base-class methods:
        f.swim();
        f.speak();
        f.eat();
        // upcast Frog17 to Amphibian argument:
        f.grow(f);
        /*Frog grow
        Frog eat
        */
        // upcast Frog17 to Amphibian and call Amphibian method:
        Amphibian.grow(f);
        //Amphibian grow
        //Frog eat
    }
}

/**
 * Frog swim
 * Frog speak
 * Frog eat
 * Frog grow
 * Frog eat
 * Amphibian grow
 * Frog eat
 *
 * Process finished with exit code 0
 * **/

過載和重寫的區別

方法的重寫(Overriding)和過載(Overloading)是java多型性的不同表現，重寫是父類與子類之間多型性的一種表現，過載可以理解成多型的具體表現形式。

(1)方法過載是一個類中定義了多個方法名相同,而他們的引數的數量不同或數量相同而型別和次序不同,則稱為方法的過載(Overloading)。
(2)方法重寫是在子類存在方法與父類的方法的名字相同,而且引數的個數與型別一樣,返回值也一樣的方法,就稱為重寫(Overriding)。
(3)方法過載是一個類的多型性表現,而方法重寫是子類與父類的一種多型性表現。

在這裡插入圖片描述

final和final static 的區別

Ref:
1、組合、繼承、代理的聯絡與區別
2、重寫和過載的區別
3、final和final static 的區別

相關推薦

Java程式設計思想第七章複用類練習題解答

練習題解答 練習1 練習2 練習3 練習4 練習5 練習6 練習7 練習8 練習9 練習10 練習11 練習12 練習13 練習14 練習15

JAVA程式設計思想第七章-複用類

1.一個物件被轉換成string時，會呼叫物件的toSting方法 public class demo7 { private water w=new water(); private String s="string"; public static void main(Strin

Java程式設計思想（七）—— 複用類

        在OOP語言中，複用程式碼一般有兩種方式：一種是組合，它只需在新的類中產生現有類的物件，它複用了現有程式程式碼的功能；還有一種是繼承，它按照現有類的型別來建立新類，而無需改變現有類的形式，它複用了現有類的形式。 一、組合語法 &nb

Java程式設計思想第六章訪問許可權控制練習題解答(待更新完整.......)

練習解答 練習１ 練習2 練習3 練習１ 先在另一個包建立程式碼，命名為ch6Ex1.java package ch5; public class ch6Ex1 { public ch6Ex1()

Java程式設計思想 第七章：複用類

1. 組合用法 程式碼複用是所有語言中都具有的一種特性，我們不必編寫功能相同或相似的程式碼，只需要將原有的程式碼直接拿來或者是在原有程式碼的基礎上進行改動即可。改動的方式有兩種，一種是組合的方式，另一種是繼承的方式。組合方式的使用很常見，前邊的例子也用到過，就是比如說我們新建了一個類，在

《JAVA程式設計思想(第四版)》第七章(複用類)小結

組合語法 組合的小例子 組合很好理解,就是一個物件中的某個欄位是另一個物件. String, 就是一個物件,所以接下來就是一種組合 public class Person{ private int id; private String name;

Java程式設計思想第七章多型

複用程式碼是java眾多引人注目的功能之一。 Java 複用類有2中方式。第一種是組合，組合就是在新類中產生現有類的物件，新的類是由現有的物件組成的，所以叫組合。第二種方式是繼承，繼承就是按照現有類的型別來建立新的類。無需改變現有類的形式，採用現有類的形式並在其中新增新程式

Java程式設計思想 第七章讀書筆記

複用類 思考Java是如何複用程式碼，然後通過複用程式碼來實現更加複雜的邏輯的。 1.組合語法 也就是在新定義的類中引入已經建立類的物件 2.繼承語法 建立一個類的時候總是在繼承，顯示的通過extend 一個已有類，或者是隱式的繼承自Object類。繼承是衍生類完全繼承了父

Java程式設計思想學習筆記——第7章 複用類

7.8 final關鍵字 final指得是“這是無法改變的”。不想做改變可能出於兩種理由：設計或效率。 可能使用到final的三種情況：資料、方法和類。 7.9初始化及類的載入 載入時眾多變得更加容易的動作之一，因為Java中的所有事物都是物件。請記住，每個類的編譯程

《Java編程思想》筆記 第七章 復用類

內部 開發 pri 思想 添加 基本類 創建 權限 改變 1.組合 將其他類的對象引用置於新的類中。 3.繼承 關鍵詞extends 一個類繼承基類後自動獲得 基類的所有域（包括字段 引用 內部類 ）和方法，當然不包括private,子類中調用繼承下來的方法也不需

《java程式設計思想——第十三章(字串)》

字串## 13.1 不可變String## string物件是不可變。String類中每一個看起來會修改String值得方法，實際上都建立了一個新的String物件。 public class Immutable {； public static String upcas

《java程式設計思想——第十章(內部類)》

內部類 可以將一個類的定義放在另一個類的定義內部，這就是內部類。 10.1 建立內部類 把類的定義置於外圍類的裡面。 /** * 建立內部類 * @author Administrator */ public class Parcel1 { class Co

易學筆記-JAVA入門語言總結-第7章 複用類

所謂的組合就是在一個類的資料成員中宣告另外一個類的物件，就好像宣告一個基本型別一樣：第7章 複用類/7.1 組合語法 在繼承類中，通過super指明呼叫的是父類的方法 第7章 複用類/7.2 繼承語法 類的初始化 基類的構造方法一層層網上被呼叫，比如 基

201711671118《Java程式設計》第七章總結

7.1內部類 ①類除了可以有成員變數和方法外，還可以擁有一種成員：內部類。 ②在一個類中定義另一個類，這樣的類稱為內部類，包含內部類的類稱為內部類的外嵌類。 ③內部類和外嵌類的關係： 外嵌類的成員變數在內部類仍然有效，內部類中的方法也可以呼叫外嵌類中的方法。 內部類的類體中不可以

《Java程式設計》第七章學習總結

201711671111 《Java程式設計》第七章學習總結 1.內部類 JAVA支援在一個類中定義另一個類，這樣的類稱作內部類，而包含內部類的類稱為內部類的外嵌類。 內部類和外嵌類關係如下：①內部類的外嵌類的成員變數在內部類中仍然有效，內部類中的方法也可以呼叫外嵌類中

關於Java程式設計思想第三章中 net.jar的匯入

首先右擊你需要匯入net.jar的Eclipse專案，選擇      “構建路徑”-   -“配置構建路徑”  。點選    “庫”   選項卡，單擊右邊的“新增外部JAR”按鈕，然後找到你的 net

Java程式設計思想第五章初始化與清理練習題解答

目錄 1、構造器 練習１ 練習2 3、方法過載 練習3 練習4 練習5 練習6 練習7 練習8 練習9 練習10 練習14 練習16

201711671220 《Java程式設計》第七章學習總結

201711671220 《Java程式設計》第七章學習總結 教材學習內容總結   第七章講的是內部類和異常類。內部類就是在一個類中定義的另一個類，而包含內部類的類是內部類的外嵌類，內部類可以呼叫外嵌類的成員變數和方法，內部類的物件可以用作外嵌類的成員，內部類的類體中不能

Java 程式設計思想第三章筆記

                                                第三章操作符 一邊做筆記一邊看書，打程式碼更好 第六章靜態匯入是什麼？ 3.1 以前我就一直覺得 System 的輸出語句太長了，作者在這裡為我完美的解決了問題，利用靜態匯入這

Java 程式設計思想第四章筆記

    第四章執行控制流程     程式在執行過程中控制他的世界，利用執行控制語句。     Java 使用了 C語言中的所有流程控制語句，Java中設計的關鍵字 if-else while do-while for return break 以及選擇語句 switch。