zoukankan      html  css  js  c++  java

  • 小练习

     

    　　

    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. }
     
  • 相关阅读:
    第3章 对象基础
    [置顶] CSDN博客客户端（非官方）
    javascript 修改对象
    Print2Flash出现"System Error. Code:1722. RPC服务器不可用."错误解决办法
    ConfigHelper 配置文件辅助类
    多个委托方法的顺序执行
    javascript Table
    字符串拼接方式(待商榷)
    CSDN博客客户端（非官方）
    javascript 对象继承
  • 原文地址：https://www.cnblogs.com/xyk1987/p/8330907.html
Copyright © 2011-2022 走看看