JAVA习题

最新推荐文章于 2021-02-20 00:06:30 发布

thmk123

最新推荐文章于 2021-02-20 00:06:30 发布

阅读量1.1k

点赞数 1

分类专栏： JAVA 文章标签： java

JAVA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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();
    }
}