小练习

 

　　

1 请看下列代码：

  1. public class SuperClass {
  2.     public static void main(String[] args) {
  3.         SuperClass sup=new SuperClass();
  4.         SubClass sub=new SubClass();
  5.         SuperClass supSub=new SubClass();
  6.     }
  7. }
  8. class SubClass extends SuperClass{
  9. }

根据上述代码，判断下列选项中，赋值语句错误的是：

A. sup=sub;

B. sub=sup;

C. supSub=sub;

D. supSub=sup;

参考答案

B 选项的赋值语句是错误的。

这是因为，一个类的对象可以向上造型的类型有：父类的类型或是其实现的接口类型，而B选项将sup（SuperClass类型）直接赋值给sub(SubClass类型)，属于向下造型，向下造型要使用强制类型转换，即代码改为：sub=(SubClass)sup; 来实现向下造型。

2 射击游戏

现有一个射击游戏中的场景如图- 1所示。在图- 1中有飞机、蜜蜂，这两种飞行物都可以被炮弹击中。如果击中的是敌人（即飞机)，则获得5分；如果击中的是蜜蜂则获得奖励。本案例的详细需求如下：

1. 奖励有两种类型，一种奖励为双倍火力、另一种奖励为手弹。

2. 空中现有3架飞机、两只蜜蜂，判断某一炮弹能否击中它们。

图-1

参考答案

实现题目所述的射击游戏，步骤如下：

1. 定义接口Enemy表示敌人。在该接口中定义getScore方法，用于实现分数的获取。代码如下：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.         
  4.     }
  5. }
  6. // 敌人
  7. interface Enemy {
  8.     int getScore();
  9. }

2. 定义接口Award表示奖励。在该接口中定义常量表示奖励的类型、定义getType方法用于实现获取奖励的类型。代码如下：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.     
  4.     }
  5. }
  7. // 敌人
  8. interface Enemy {
  9.     int getScore();
  10. }
  12. // 奖励
  13. interface Award {
  14.     int DOUBLE_FIRE = 2;// 双倍火力
  15.     int BOMB = 1; // 手雷
  17.     int getType();// 获取奖励类型 返回值是整数
  18. }

3. 定义抽象类FlyingObject表示飞行物。在类中定义属性 x 、y 表示飞行物所在的坐标；定义shootBy方法表示飞行物是否被击中。代码如下：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.         
  4.     }
  5. }
  8. abstract class FlyingObject {
  9.     int x;
  10.     int y;
  12.     abstract boolean shootBy(int x, int y);
  13. }
  15. // 敌人
  16. interface Enemy {
  17.     int getScore();
  18. }
  20. // 奖励
  21. interface Award {
  22.     int DOUBLE_FIRE = 2;// 双倍火力
  23.     int BOMB = 1; // 手雷
  25.     int getType();// 获取奖励类型 返回值是整数
  26. }

4. 定义类Bee表示蜜蜂。蜜蜂属于飞行物，因此Bee类继承自FlyingObject，并重写FlyingObject类的shootBy方法，根据蜜蜂被击中的规则进行重写；蜜蜂被击中后，可以获得奖励，因此，Bee类实现Award接口，并实现getType方法，获得奖励。代码如下：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.         
  4.     }
  5. }
  8. /** 小蜜蜂 是飞行物 也是奖励 */
  9. class Bee extends FlyingObject implements Award {
  10.     int r;
  11.     int type;
  13.     public Bee(int x, int y, int r) {
  14.         this.x = x;
  15.         this.y = y;
  16.         this.r = r;
  17.         type = Award.DOUBLE_FIRE;
  18.     }
  20.     public int getType() {
  21.         return type;
  22.     }
  24.     public boolean shootBy(int x, int y) {
  25.         int a = x - this.x;
  26.         int b = y - this.y;
  27.         return Math.sqrt(a * a + b * b) < r;
  28.     }
  29. }
  31. abstract class FlyingObject {
  32.     int x;
  33.     int y;
  35.     abstract boolean shootBy(int x, int y);
  36. }
  38. // 敌人
  39. interface Enemy {
  40.     int getScore();
  41. }
  43. // 奖励
  44. interface Award {
  45.     int DOUBLE_FIRE = 2;// 双倍火力
  46.     int BOMB = 1; // 手雷
  48.     int getType();// 获取奖励类型 返回值是整数的
  49. }

把蜜蜂所在的区域看出一个圆形，蜜蜂被击中的规则为：

  1.     int a = x - this.x;
  2.     int b = y - this.y;
  3. return Math.sqrt(a * a + b * b) < r;

上述代码中，x 、y表示炮弹的坐标位置，this.x 、this.y表示蜜蜂的坐标位置，r表示半径。如果表达式“ Math.sqrt(a * a + b * b) < r ”的结果返回true，则蜜蜂被炮弹击中。

5. 定义类Airplane表示飞机。飞机属于飞行物，因此Airplane类继承自FlyingObject，并重写FlyingObject类的shootBy方法，根据飞机被击中的规则进行重写；飞机被击中后，可以获得分数，因此，Airplane 类实现Enemy接口，并实现 getScore方法，用于获得分数。代码如下：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.         
  4.     }
  5. }
  7. /** 飞机是飞行物也是敌人 */
  8. class Airplane extends FlyingObject implements Enemy {
  9.     int width;
  10.     int height;
  12.     public Airplane(int x, int y, int w, int h) {
  13.         this.x = x;
  14.         this.y = y;
  15.         width = w;
  16.         height = h;
  17.     }
  19.     public boolean shootBy(int x, int y) {
  20.         int dx = x - this.x;
  21.         int dy = y - this.y;
  22.         return (dx > 0 && dx < width) && (dy > 0 && dy < height);
  23.     }
  25.     @Override
  26.     public int getScore() {
  27.         return 5;
  28.     }
  29. }
  31. /** 小蜜蜂 是飞行物 也是奖励 */
  32. class Bee extends FlyingObject implements Award {
  33.     int r;
  34.     int type;
  36.     public Bee(int x, int y, int r) {
  37.         this.x = x;
  38.         this.y = y;
  39.         this.r = r;
  40.         type = Award.DOUBLE_FIRE;
  41.     }
  43.     public int getType() {
  44.         return type;
  45.     }
  47.     public boolean shootBy(int x, int y) {
  48.         int a = x - this.x;
  49.         int b = y - this.y;
  50.         return Math.sqrt(a * a + b * b) < r;
  51.     }
  52. }
  54. abstract class FlyingObject {
  55.     int x;
  56.     int y;
  58.     abstract boolean shootBy(int x, int y);
  59. }
  61. // 敌人
  62. interface Enemy {
  63.     int getScore();
  64. }
  66. // 奖励
  67. interface Award {
  68.     int DOUBLE_FIRE = 2;// 双倍火力
  69.     int BOMB = 1; // 手雷
  71.     int getType();// 获取奖励类型 返回值是整数的
  72. }

把飞机所在的区域看出一个矩形，飞机被击中的规则为：

 
  1. int dx = x - this.x;
  2. int dy = y - this.y;
  3. return (dx > 0 && dx < width) && (dy > 0 && dy < height);

上述代码中，x 、y表示炮弹的坐标位置，this.x 、this.y表示飞机的坐标位置，width、height表示矩形的宽和高。如果表达式“(dx > 0 && dx < width) && (dy > 0 && dy < height) ”的结果返回true，则飞机被炮弹击中。

6. 在main方法中，首先，构造长度为5的FlyingObject类型的数组，将3架飞机和两只蜜蜂作为数组的元素； 然后，设置炮弹的坐标位置；最后，循环判断数组中的飞行物是否被击中，如果被击中，则再判断是蜜蜂还是飞机，如果是飞机，则输出得分，如果是蜜蜂则输出奖励类型。代码如下：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.         FlyingObject[] objects = new FlyingObject[5];
  4.         objects[0] = new Airplane(103, 68, 20, 20);
  5.         objects[1] = new Airplane(243, 102, 20, 20);
  6.         objects[2] = new Airplane(153, 166, 20, 20);
  7.         objects[3] = new Bee(85, 256, 20);
  8.         objects[4] = new Bee(256, 287, 20);
  9.         int x = 82;
  10.         int y = 253;
  11.         for (int i = 0; i < objects.length; i++) {
  12.             FlyingObject obj = objects[i];
  13.             if (obj.shootBy(x, y)) {
  14.                 if (obj instanceof Enemy) {
  15.                     Enemy enemy = (Enemy) obj;
  16.                     System.out.println("加分：" + enemy.getScore());
  17.                 }
  18.                 if (obj instanceof Award) {
  19.                     Award award = (Award) obj;
  20.                     System.out.println("奖励" + award.getType());
  21.                 }
  22.             }
  23.         }
  24.     }
  25. }
  27. /** 飞机是飞行物也是敌人 */
  28. class Airplane extends FlyingObject implements Enemy {
  29.     int width;
  30.     int height;
  32.     public Airplane(int x, int y, int w, int h) {
  33.         this.x = x;
  34.         this.y = y;
  35.         width = w;
  36.         height = h;
  37.     }
  39.     public boolean shootBy(int x, int y) {
  40.         int dx = x - this.x;
  41.         int dy = y - this.y;
  42.         return (dx > 0 && dx < width) && (dy > 0 && dy < height);
  43.     }
  45.     @Override
  46.     public int getScore() {
  47.         return 5;
  48.     }
  49. }
  51. /** 小蜜蜂 是飞行物 也是奖励 */
  52. class Bee extends FlyingObject implements Award {
  53.     int r;
  54.     int type;
  56.     public Bee(int x, int y, int r) {
  57.         this.x = x;
  58.         this.y = y;
  59.         this.r = r;
  60.         type = Award.DOUBLE_FIRE;
  61.     }
  63.     public int getType() {
  64.         return type;
  65.     }
  67.     public boolean shootBy(int x, int y) {
  68.         int a = x - this.x;
  69.         int b = y - this.y;
  70.         return Math.sqrt(a * a + b * b) < r;
  71.     }
  72. }
  74. abstract class FlyingObject {
  75.     int x;
  76.     int y;
  78.     abstract boolean shootBy(int x, int y);
  79. }
  81. // 敌人
  82. interface Enemy {
  83.     int getScore();
  84. }
  86. // 奖励
  87. interface Award {
  88.     int DOUBLE_FIRE = 2;// 双倍火力
  89.     int BOMB = 1; // 手雷
  91.     int getType();// 获取奖励类型 返回值是整数的
  92. }

本案例的完整代码如下所示：

 
  1. public class Shoot {
  2.     public static void main(String[] args) {
  3.         FlyingObject[] objects = new FlyingObject[5];
  4.         objects[0] = new Airplane(103, 68, 20, 20);
  5.         objects[1] = new Airplane(243, 102, 20, 20);
  6.         objects[2] = new Airplane(153, 166, 20, 20);
  7.         objects[3] = new Bee(85, 256, 20);
  8.         objects[4] = new Bee(256, 287, 20);
  9.         int x = 82;
  10.         int y = 253;
  11.         for (int i = 0; i < objects.length; i++) {
  12.             FlyingObject obj = objects[i];
  13.             if (obj.shootBy(x, y)) {
  14.                 if (obj instanceof Enemy) {
  15.                     Enemy enemy = (Enemy) obj;
  16.                     System.out.println("加分：" + enemy.getScore());
  17.                 }
  18.                 if (obj instanceof Award) {
  19.                     Award award = (Award) obj;
  20.                     System.out.println("奖励" + award.getType());
  21.                 }
  22.             }
  23.         }
  24.     }
  25. }
  27. /** 飞机是飞行物也是敌人 */
  28. class Airplane extends FlyingObject implements Enemy {
  29.     int width;
  30.     int height;
  32.     public Airplane(int x, int y, int w, int h) {
  33.         this.x = x;
  34.         this.y = y;
  35.         width = w;
  36.         height = h;
  37.     }
  39.     public boolean shootBy(int x, int y) {
  40.         int dx = x - this.x;
  41.         int dy = y - this.y;
  42.         return (dx > 0 && dx < width) && (dy > 0 && dy < height);
  43.     }
  45.     @Override
  46.     public int getScore() {
  47.         return 5;
  48.     }
  49. }
  51. /** 小蜜蜂 是飞行物 也是奖励 */
  52. class Bee extends FlyingObject implements Award {
  53.     int r;
  54.     int type;
  56.     public Bee(int x, int y, int r) {
  57.         this.x = x;
  58.         this.y = y;
  59.         this.r = r;
  60.         type = Award.DOUBLE_FIRE;
  61.     }
  63.     public int getType() {
  64.         return type;
  65.     }
  67.     public boolean shootBy(int x, int y) {
  68.         int a = x - this.x;
  69.         int b = y - this.y;
  70.         return Math.sqrt(a * a + b * b) < r;
  71.     }
  72. }
  74. abstract class FlyingObject {
  75.     int x;
  76.     int y;
  78.     abstract boolean shootBy(int x, int y);
  79. }
  81. // 敌人
  82. interface Enemy {
  83.     int getScore();
  84. }
  86. // 奖励
  87. interface Award {
  88.     int DOUBLE_FIRE = 2;// 双倍火力
  89.     int BOMB = 1; // 手雷
  91.     int getType();// 获取奖励类型 返回值是整数
  92. }
 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xyk1987/p/8330907.html