JAVA习题

6.4　 习题
1． 创建 一个 名为 Book 的 类， 用来 代表 一 本书。 类 中有 3 个 属性， 分别 是 String 类型 的 bookName， int 类型 的 pageCount 和 double 类型 的 price。
2． 使用 第 1 题中 的 Book 类。 首先 创建 一个 Book 类 的 对象， 然后 给 类 中的 3 个 属性 赋值， 最后 将 Book 类 对象 的 3 个 属性 值 输出 到 控制台。
3． 理解 对象 和 引用 之间 的 关系： 编写 一个 程序， 使用 第 1 题中 的 Book 类。 首先 创建 一个 Book 类 的 对象， 然后 创建 book1 和 book2 两个 Book 类 的 引用， 让 它们 都 指向 创建 出 的 Book 类。 通过 这 两个 引用 修改 Book 对象 的 属性 值， 最后 将 Book 对象 的 属性 值 输出 到 控制台。

Exercise3:

public class exercise3 {
    public static void main(String[] args) {
        book newBook = new book();  //创建对象
        book book1; 
        book book2;    //创建两个引用
        book1 = newBook;
        book2 = book1;    //让两个引用都指向Newbook 
        //通过引用修改book的3个属性值
        book1.bookName = "the kite scraper";
        book1.pageCount= 18;
        book2.bookPrice = 19.2;
        System.out.println(newBook.bookName);
        System.out.println(book1.pageCount);
        System.out.println(newBook.bookPrice);
    }  
}

7.12　 习题
1． 扩展 第 6 章 习题 中的 Book 类， 给 类 中 添加 两个 构造 方法。 一个 构造 方法 不接受 任何 参数， 给 3 个 属性 赋 初始 值； 另一个 构造 方法 有 3 个 参数， 分别 用 来给 3 个 属性 赋值。
2． 扩展 第 6 章 习题 中的 Book 类， 给 类 中 每个 属性 添加 得到 属性 值 和 设置 属性 值 的 方法。 比如， 对于 bookName() 方法， 应该 添加 一个 getBookName() 方法， 用来 返回 bookName 属 性的 值； 还要 添加 一个 setBookName() 的 方法， 用来 设置 bookName 属 性的 值。
3． 使用 第 2 题中 添加 的 方法， 创建 Book 类 的 对象， 然后 给 Book 类 的 属性 赋值， 最后 将 属性 值 输出 到 控制台。

exercise1

public class book {
    String bookName;
    int pageCount;
    double bookPrice;
    //添加两个构造方法，一个不接受任何参数,给属性赋初始值
    public book(){
        bookName = "the kite runner";
        pageCount = 10;
        bookPrice = 55.5;
    }           //另一个接受3个参数，给属性赋值
    public book(String setBookName, int setPageCount, double setBookPrice){
        bookName = setBookName;
        pageCount = setPageCount;
        bookPrice = setBookPrice;
    }
}

exercise2

public class book {
    String bookName;
    int pageCount;
    double Price;
    //添加两个构造方法，一个不接受任何参数,给属性赋初始值 
    public book() {
        this("习题集", 30, 50.5);  //在一个构造器中调用另外一个构造器，则可以使用this
    }
    public book(String bookName, int pageCount, double price) {
        this.bookName= bookName;
        this.pageCount = pageCount;
        this.Price = price;
    }
    public String getbookName(){  //添加 一个 getBookName() 方法， 用来 返回 bookName 属 性的 值；
    return bookName;
    }
    public int pageCount(){  //添加 一个 getBookName() 方法， 用来 返回 bookName 属 性的 值；
        return pageCount;
        }
    public double Price(){  //添加 一个 getBookName() 方法， 用来 返回 bookName 属 性的 值；
        return Price;
        }
    public void setbookName(String setbookName){
        bookName = setbookName;
    }
    public void setpageCount(int setpageCount){
        pageCount = setpageCount;
    }
    public void setPrice(double setPrice){
        Price = setPrice;
    }
}

exercise3

public class exercise3 {
    public static void main(String[] args) {
         book bookobj = new book();    //创建对象
         bookobj.setbookName("This is the bookname");  //给属性赋值,只修改了书名
         bookobj.setpageCount(33);
         bookobj.setPrice(50.6);
         System.out.println(bookobj.bookName);   //输出到控制台
         System.out.println(bookobj.pageCount);   //输出到控制台
         System.out.println(bookobj.Price);   //输出到控制台    
    }
}

10.7 习题
1． 练习 方法 的 覆盖： 编写 一个 名为 Parent 的 类， 类 中有 一个 叫 method1() 和 一个 叫 method2() 的 方法， 方法 的 内容 就是 将 方法 所属 的 类 和 方法 名 输出 到 控制台。 然后 编写 一个 Child 类 继承 Parent 类， 让 Child 类 覆盖 method1() 方法， 方法 内容 也是 向 控制台 输出 方法 所属 类 和 方 法名。

public class Parent {
    public void method1() {
        System.out.println("这是Parent类中的method1方法");
    }

    public void method2() {
        System.out.println("这是Parent类中的method2方法");
    }
}

Child类已创建，里面分别有method1把父类的method1覆盖了

public class Child extends Parent {   //继承parent类，构造方法不会被继承
public void method1() {  //覆盖父类的method1
System.out.println("这是Child类中的method1方法");
  }
}

2． 练习 使用 覆盖 的 方法： 编写 一个 静态 方法 invokeMethods， 参数 为 Parent 类 的 引用。 方法 中 首先 使用 instanceof 判断 参数 指向 对象 所属 的 类， 然后 调用 method1() 方法 和 method2() 方法。 然后 编写 一个 程序， 分别 使用 Parent 类 的 实例 和 Child 类 的 实例 为 参数， 调用 invokeMethods() 方法。
import:导入支持类（可以是JDK基础类或者自己编写的类），可以供本类调用方法和属性。

import exercise1.Child;
import exercise1.Parent;  //导入两个类

public class Exercise2 {
    public static void main(String[] args) {  //然后 编写 一个 程序， 
        //分别 使用 Parent 类 的 实例 和 Child 类 的 实例 为 参数， 调用 invokeMethods() 方法
        Exercise2.invokeMethods(new Parent());
        Exercise2.invokeMethods(new Child());
    }

    public static void invokeMethods(Parent ref) {  //静态方法，参数为parent类的引用
        if (ref instanceof Child) {  //使用 instanceof 判断 参数 指向 对象 所属 的类
            System.out.println("参数指向的是一个Child类的对象");
        } else {
            System.out.println("参数指向的是一个Parent类的对象");
        }
        ref.method1();
        ref.method2();     // 然后 调用 method1() 方法 和 method2() 方法
    }
}

3． 在 第 1 题的 基础上， 编写 一个 Child2 类， 覆盖 Parent 类 的 method2() 方法。 然后 编写 一个 程序， 使用 Child2 类 的 实例 调用 invokeMethods() 方法。

public class Child2 extends Parent {
public void method2() {
System.out.println(“这是Child2类中的method2方法”);
}
}

import exercise1.Child2;
import exercise1.Parent;

public class Exercise3 {
    public static void main(String[] args) {  //编写 一个 程序， 使用 Child2 类 的 实例 调用 invokeMethods() 方法。
        Exercise3.invokeMethods(new Child2());
    }

    public static void invokeMethods(Parent ref) {
        if (ref instanceof Child2) {  
            System.out.println("参数指向的是一个Child2类的对象");
        } else {
            System.out.println("参数指向的是一个Parent类的对象");
        }
        ref.method1();
        ref.method2();
    }
}