Java开发网 - [学习总结]Java2实用教程(第三版)习题4

Java开发网

您没有登录

» Java开发网 » Java SE 综合讨论区 » 学习心得/方法/资源

打印话题 寄给朋友 订阅主题

作者

[学习总结]Java2实用教程(第三版)习题4

喝杯茶吃个包

发贴: 7
积分: 1

于 2008-09-19 18:59

习题4
1．类中的实例变量在什么时候会被分配内存空间？
答：在使用类创建实例对象时会被分配空间。

2．什么叫方法的重载？构造方法可以重载吗？
答：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
构造方法可以重载。

3．类中的实例方法可以操作类变量(static变量)吗？类方法(static方法)可以操作实例变量吗？
答：可以，类变量是属于整个类，也属于所有该类创建的对象，它在类定义时已经被分配空间，故使用实例方法去操作类变量不会出现非法操作问题。
不可以，因为实例变量在创建对象的时候才被分配空间，对象在使用完后即可能被销毁，而类方法的生命周期为类定义到程序退出，且可以直接通过类名调用。当调用类方法去操作一个并求被分配空间的对象的实例变量时，这明显是不符合逻辑的，故类方法只能操作类变量或类方法。

4．类中的实例方法可以用类名直接调用吗？
答：不可以，实例方法是属于某个具体的类的对象，而不是属于类，它操作的对象的实例变量只在对象被创建时分配空间并初始化，实例变量都未被分配空间时，实例方法是不能去操作它的。

5．举例说明protected方法和友好方法的区别。
答：

public class Tom {
  float f(float a, float b) {
    return a + b;
  }
}

public class Jerry {
  protected float f(float a, float b) {
    return a + b;
  }
}

在同一个包中时，使用Tom和Jerry来创建对象，这些对象可以直接调用属于它们的友好方法f和protected 方法 f，即同一个包中类的友好方法和protected 方法对所在包都可见。不在同一个包中时，通过引入包使用Tom和Jerry来创建对象，Tom创建的对象不能直接调用友好方法f，但是使用Jerry创建的对象则可以直接调用它的protected 方法f，即友好方法对包外的类不可见，protected方法对所在包和别的包中的所有类可见。

6．举例说明实例变量和类变量的区别。
答：

class Takecare {
  static int x;
  int y;
}

class A {
  Takecare A1 = new Takecare();
  Takecare A2 = new Takecare();
}

给类Takecare对应分配空间时的内存模式如图所示：

从图上可以看出A1和A2中的实例变量分别被分配到不同空间上，而类变量则是A1和A2共享，即不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响到其它对象的这个类变量，也就是说对象共享变量。

7．子类将继承父类的哪些成员变量和方法？子类在什么情况下隐藏父类的成员变量和方法？在子类中是否允许有一个方法和父类的方法名字相同，而类型不同？
答：子类和父类在同一个包时，子类将继承父类中不是private的成员变量及成员方法作为自己的成员变量及成员方法，继承的成员的访问权限保持不变。子类和父类不在同一个包时，子类将继承父类的protected、public成员作为自己的成员变量及成员方法作为自己的成员变量及成员方法，子类中它们的访问权限保持不变，子类没有继承父类的友好变量及友好方法。

对于子类可以从父类继承的成员变量，只要子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量。对于已继承的方法，子类可以通过方法重写来隐藏继承的方法。

允许,其实这就是方法重载，而方法重写则是子类中定义的方法，其名字、返回类型、参数个数和类型与从父类继承的方法完全相同，方法重载不会隐藏同名方法。

8．父类的final方法可以被子类重写吗？
答：不可以，final方法相当于final变量一样，相当于常量，其值不可被改变，只不过用final修饰的方法是常成员方法，其方法体不可被改写与其是一样的道理。

9．什么类中可以有abstract方法？
答：abstract类中可以有abstract方法。

10. 什么叫对象的上转型对象？
答：
假设B类是A类的子类或间接子类，当用子类B创建一个对象，并把这个对象的引用放到A类的对象中时，如:
A a;
a = new B();
或
A a;
B b = new B();
a = b;
那么，称这个A类对象a是子类对象b的上转型对象。

11.什么叫接口的回调？
答：如果把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口中的方法，实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用对象中已实现的接口的方法，这种技术就叫做接口回调。

12.下列程序有什么错误？

public class Teachers {
  int a = 90;
  static float b = 10.98f;

  public static void main(String args[]) {
    float c = a + b;
    System.out.println("c=" + c);
  }
}

答：float c = a +b ;这一行代码有错，编译时编译器会报出“无法从静态上下文中引用非静态变量 a”的错误，因为main方法是一个静态方法，所以根据语法它只能操作该类中静态成员变量b，而不能操作非静态成员变量a。

13.请写出下列程序的输出结果。

class A {
  public int f(int x) {
    return x + 1;
  }
}

class B extends A {
  public int f(int x) {
    return x * x;
  }
}

public class E {
  public static void main(String args[]) {
    A a = new B();
    int m = a.f(10);
    System.out.println( m );
  }
}

输出结果为：100

14.请写出下列程序的输出结果。

class A {
  int x;

  public void setX(int x) {
    this.x = x;
  }
  int getX() {
    return x;
  }
}

class B {
  public void f(A a) {
    a.setX(100);
  }
}

public class E {
  public static void main(String args[]) {
    A a = new A();
    a.setX( 8 );
    System.out.println(a.getX());
    B b = new B();
    b.f( a )
    System.out.println(a.getX());
  }
}

输出结果为：
8
100[/color]

15.使用接口有哪些注意事项？模仿例子4.27，编写一个类实现两个接口的程序。
答：
注意事项：
A.接口声明：:接口通过使用关键字interface来声明。
B.接口体：接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不允许提供方法的实现，所以，方法的定义没有方法体，且用分号“：”结尾。
C.接口的使用：一个类通过使用关键字implements声明自己使用一个或多个接口。如果使用多个接口，用逗号隔开接口名。需要注意的是，在类中实现接口的方法时，方法的名字、返回类型、参数个数及类型必须与接口中的完全一致。特别需要注意的是，接口中使用的方法默认是public abstrct方法，所以类在实现接口方法时必须给出方法体，并且一定要用public来修饰，而且接口中的常量默认是public static常量。

interface Sum {
  public int sum();
}

interface Average {
  public float average();
}

class Student implements Sum, Average {
  String name;
  String num;
  int[] score;
  int sum;
  float ave;

  Student() {
  }

  Student(String name, String num, int[] score) {
    this.name = name;
    this.num = num;
    this.score = new int[score.length];

    for (int i = 0; i < score.length; i++) {
      this.score[i] = score[i];
    }
  }

  public int sum() {
    sum = 0;
    for (int i = 0; i < score.length; i++) {
      sum +=score[i];
    }
    return sum;
  }

  public float average() {
    ave = (float)sum / score.length;
    return ave;
  }
}

public class Exercise15 {
  public static void main(String args[]) {
    int[] score = {98, 99, 98, 99, 97};
    Student st = new Student("小强", "9527", score);

    System.out.println("学生" + st.name + "各科成绩分别是,琴:" + st.score[0] + " 棋:" + st.score[1] + " 书:" + 
        st.score[2] + " 画:" + st.score[3] + " 诗:" + st.score[4]);
    System.out.println("总分为:" + st.sum() + " 平均分为:" + st.average());
  }
}

运行结果

16.编写一个类A，该类创建的对象可以调用方法f输出英文字母表，然后再编写一个该类的子类B，要求子类B必须继承A类的方法f(不允许重写)，子类创建的对象不仅可以调用方法f输出英文字母表，而且调用子类新增的方法g输出希腊字母表。

class A {
  public final void f() {
    for (int i = 0; i < 128; i++) {
      System.out.print((char) i + " ");
    }
    System.out.println("\n");
  }
}

class B extends A {
  public void g() {
    int x = (int) 'Γ' - 2;

    for (int i = x; i <= x + 56; i++) {
      if ( '?' == (char) i ) continue;
      System.out.print((char) i + " ");
    }
    System.out.println("\n");
  }
}

public class Exercise16 {
  public static void main(String args[]) {
    A a = new A();
    B b = new B();

    a.f();
    b.g();
    b.f();
  }
}

运行结果

17.编写一个异常类MyException,再编写一个类Student，该类有一个产生异常的方法public void speak(int m) throws MyException，要求参数m的值大于1000时，方法抛出一个MyException对象。最后编写主类，在主类的main方法中用Student创建一个对象，让该对象调用speak方法。

class MyException extends Exception {
  String message;
  MyException(int m) {
    message = "发生异常:数字" + m + "大于1000";
  }
  public String toString() {
    return message;
  }
}

class Student {
  public void speak(int m) throws MyException {
    if (m > 1000) {
      MyException exception = new MyException( m );
      throw exception;    // 抛出异常，结束方法的执行
    }
    System.out.println("m=" + m);
  }
}

public class Exercise17 {
  public static void main(String args[]) {
    try {
      Student st = new Student();

      st.speak(100);
      st.speak(1500);
    }
    catch (MyException me) {
      System.out.println(me.toString());
    }
  }
}

运行结果

18.编写一个类，该类有一个方法public int f(int a, int b),该方法返回a和b的最大公约数。然后再编写一个该类的子类，要求子类重写方法f，而且重写的方法将返回a和b的最小公倍数。要求在重写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将乘积(a*b)/m返回。要求在应用程序的主类中分别使用父类和子类创建对象，并分别调用方法f计算两个正整数的最大公约数和最小公倍数。

class NopositiveException extends Exception {
  String message;
  NopositiveException(int m, int n) {
    message = "数字" + m + "或" + n + "不是正整数";
  }
  public String toString() {
    return message;
  }
}

class GCD {
  public int f(int m, int n) throws NopositiveException {
    if (m <= 0 || n <= 0) {
      NopositiveException exception = new NopositiveException(m, n);
      throw exception;
    }
    int r = m % n;
    while(r != 0) {
      m = n;
      n = r;
      r = m % n;
    }
    return n;
  }
}

class LCM extends GCD {
  public int f(int m, int n ) throws NopositiveException {
    if (m <= 0 || n <= 0) {
      NopositiveException exception = new NopositiveException(m, n);
      throw exception;
    }
    int lcm = super.f(m, n);
    lcm = m * n / lcm;
    return lcm;
  }
}

class Exercise18 {
  public static void main(String args[]) {
    try {
      GCD gcd = new GCD();
      LCM lcm = new LCM();
      int m  = 15, n = 3;
      System.out.println(m + "和" + n + "的最大公约数" + gcd.f(m, n));
      System.out.println(m + "和" + n + "的最小公倍数" + lcm.f(m, n));
    }
    catch (NopositiveException e) {
      System.out.println(e.toString());
    }
  }
}

运行结果

总结：从08年9月12到08年9月19，整整七天，才把第4章看完，前几天还剩十几页的时候，我就每天都和自己说，今天可以把第4章搞定了，然后又发生各种各样的意外让我处理。一直拖，直到现在才总算把第4章完满的解决了。虽然在多数人看来，我解决的只是一些小问题，但至少我又感觉到自己的进步了，这是促使我不断学习、不断进步的最强大的动力。今天是学习第4章的最后一天，花了6、7个小时，甚至还要多的时间才总算做完习题4的18道题目，虽然感觉有点枯燥，但是很开心。
Smile

喝杯茶吃个包 edited on 2008-09-19 19:12

话题树型展开

人气	标题	作者	字数	发贴时间
10196	[学习总结]Java2实用教程(第三版)习题4	喝杯茶吃个包	11708	2008-09-19 18:59

已读帖子

新的帖子

被删除的帖子