访问控制符

1 查看下列代码

 
  1. abstract class Vehicle {
  2.     public int speed() {
  3.         return 0;
  4.     }
  5. }
  7. class Car extends Vehicle {
  8.     public int speed() {
  9.         return 60;
  10.     }
  11. }
  13. class RaceCar extends Car {
  14.     public int speed() {
  15.         return 150;
  16.     }
  17. }
  19. public class TestCar {
  20.     public static void main(String[] args) {
  21.         RaceCar racer = new RaceCar();
  22.         Car car = new RaceCar();
  23.         Vehicle vehicle = new RaceCar();
  24.         System.out.println(racer.speed() + ", " + car.speed() + ", "
  25.      + vehicle.speed());
  26.     }
  27. }

上述代码运行的结果是

A. 0,0,0

B. 150,60,0

C. 150,150,150

D. 抛出运行时异常

参考答案

C 选项正确。

这是因为，子类可以重写(覆盖)继承自父类的方法，即方法名和参数列表与父类的方法相同，但方法的实现不同。当子类对象的重写方法被调用时（无论是通过子类的引用调用还是通过父类的引用调用），运行的是子类的重写后的版本。因此，本题的正确答案为选项 C。

2 编写正六边形类继承Shape，实现其area方法

在课上案例“根据周长计算不同形状图形的面积”基础上，编写正六边形类继承Shape，实现其area方法。

注：正六边形的面积计算公式为：0.0721 * c * c，其中c为周长。

参考答案：

实现此案例需要按照如下步骤进行。

步骤一：定义类Hexagon

定义名为Hexagon的类，表示正六边形，使该类继承自Shape类，代码如下所示：

 
  1. public class Hexagon extends Shape {
  2. }

步骤二：实现 area方法

在area方法中，根据正六边形的面积公式计算面积，代码如下所示：

  1. public class Hexagon extends Shape {
  2.     public Hexagon(double c) {
  3.         this.c = c;
  4.     }
  5.     /**
  6.      * 计算正六边形的面积
  7.      */
  8. public double area() {
  9. return 0.0721 * c * c;
  10. }
  11. }

步骤三：在测试类TestShape类中添加测试代码

在TestShape类中，构造Hexagon类型的对象，并将其放入数组中，代码如下所示：

 
  1. public class TestShape {
  2.     public static void main(String[] args) {
  3.         Shape[] shapes = new Shape[3];
  4.         shapes[0] = new Circle(4);//数组中的第一个元素为圆形对象
  5.         shapes[1] = new Square(4);//数组中的第二个元素为正方形对象
  6.         shapes[2] = new Hexagon(4);//数组中的第三个元素为正六边形对象
  7.         maxArea(shapes);
  8.     }
  9. public static void maxArea(Shape[] shapes) {
  10.         double max = shapes[0].area();
  11.         int maxIndex = 0;
  12.         for (int i = 1; i < shapes.length; i++) {
  13.             double area = shapes[i].area();
  14.             if (area > max) {
  15.                 max = area;
  16.                 maxIndex = i;
  17.             }
  18.         }
  19.         System.out.println("数组中索引为"+maxIndex+"的图形的面积最大，面积为："+max);
  20.     }
  21. }

步骤四：运行

运行TestShape类，控制台输出结果如下所示：

 
  1. 数组中索引为0的图形的面积大，面积为：1.2736

观察上述输出结果，可以看出，shapes[0]表示的是圆形，周长相同的情况下，圆形的面积更大些。

本案例中，Hexagon类的完整代码如下所示：

  1. public class Hexagon extends Shape {
  2.     public Hexagon(double c) {
  3.         this.c = c;
  4.     }
  5.     /**
  6.      * 计算正六边形的面积
  7.      */
  8. public double area() {
  9. return 0.0721 * c * c;
  10. }
  11. }

TestShape类的完整代码如下所示：

 
  1. public class TestShape {
  2.     public static void main(String[] args) {
  3.         Shape[] shapes = new Shape[3];
  4.         shapes[0] = new Circle(4);//数组中的第一个元素为圆形对象
  5.         shapes[1] = new Square(4);//数组中的第二个元素为正方形对象
  6.         shapes[2] = new Hexagon(4);//数组中的第三个元素为正六边形对象
  7.         maxArea(shapes);
  8.     }
  9. public static void maxArea(Shape[] shapes) {
  10.         double max = shapes[0].area();
  11.         int maxIndex = 0;
  12.         for (int i = 1; i < shapes.length; i++) {
  13.             double area = shapes[i].area();
  14.             if (area > max) {
  15.                 max = area;
  16.                 maxIndex = i;
  17.             }
  18.         }
  19.         System.out.println("数组中索引为"+maxIndex+"的图形的面积最大，面积为："+max);
  20.     }
  22. }

3 简述抽象类的意义

参考答案：

抽象类的意义在于：

1. 为其子类提供一个公共的父类型，避免该类被实例化；

2. 封装子类中的重复内容（成员变量和方法）;

3. 定义公共抽象方法，由子类提供不同的实现。

4 编写建设银行接口CCB继承银联接口，并实现该接口

在课上案例“银行卡系统（实现银联接口）”的基础上，编写建设银行接口CCB。建设银行接口，用于描述中国建设银行发行的卡片功能，在满足银联接口的规则基础上，增加了支付燃气费的功能。

参考答案

实现此案例需要按照如下步骤进行。

步骤一： 定义建设银行接口

定义名为CCB的接口表示建设银行接口，用于描述中国建设银行发行的卡片功能，该接口需要满足银联接口的功能，因此，继承银联接口；该接口在具备银联接口的功能基础上，要求增加支付燃气费的功能，所以，在该接口中定义payGasBill方法，表示此功能，代码如下所示：

 
  1. /**
  2. * 接口：用于描述建设银行发行的卡片功能，在满足
  3. * 银联的规则基础上，添加自己特有的功能
  4. */
  5. public interface CCB extends UnionPay {
  6.     /**增加的支付燃气费功能*/
  7.     public void payGasBill(double number);
  8. }

步骤二：定义建设银行接口的实现类

首先，定义名为CCBImpl的类 ，该类实现CCB接口；另外，分析问题中的取钱功能，需要对余额信息进行存储，插入卡片以后需要输入密码后才能进行取钱，因此，在CCBImpl类中定义double类型属性money表示账户余额以及String类型属性pwd表示卡片的密码，代码如下所示：

 
  1. /**
  2. * 类：用于描述建设银行实际发行的卡片
  3. * 该卡片具有的功能来自于继承的已经符合银联规范的CCB接口
  4. */
  5. public class CCBImpl implements CCB {
  6.     private double money;
  7.     private String pwd;
  8.     
  9.     public CCBImpl(double money,String pwd){
  10.         this.money = money;
  11.         this.pwd = pwd;
  12.     }
  13. }

步骤三：实现检查密码、获取余额、取款、支付燃气费功能

在CCBImpl类实现checkPwd方法、getBalance方法、drawMoney方法以及payGasBill方法，代码如下所示：

 
  1. /**
  2. * 类：用于描述建设银行实际发行的卡片
  3. * 该卡片具有的功能来自于继承的已经符合银联规范的CCB接口
  4. */
  5. public class CCBImpl implements CCB {
  6.     private double money;
  7.     private String pwd;
  8.     
  9.     public CCBImpl(double money,String pwd){
  10.         this.money = money;
  11.         this.pwd = pwd;
  12.     }
  13.     
  14.     @Override
  15.     public double getBalance() {        
  16.         return money;
  17.     }
  19.     @Override
  20.     public boolean drawMoney(double number) {
  21.         if(number <= money){
  22.             money -=number;
  23.             return true;
  24.         }
  25.         return false;
  27.     }
  29.     @Override
  30.     public void payGasBill(double number) {
  31.         if(number < money){
  32.             money-=number;
  33.         }
  34.     }
  36.     @Override
  37.     public boolean checkPwd(String input) {
  38.         if(pwd.equals(input))
  39.             return true;
  40.         else
  41.             return false;
  42.     }
  43. }

以上四个方法的实现逻辑为：

取钱功能的实现为在当前余额的基础上减去要取的金额，如drawMoney方法的实现。

支付燃气费功能的实现为当前余额的基础上减去要支付的金额，如payGasBill方法的实现。

检查密码功能的实现为检查卡的密码与用户输入的密码是否相等，如果相等返回true，否则返回false，如checkPwd方法的实现。

获取余额功能的实现为类CCBImpl中的money属性即表示余额，将其返回即可，如getBalance方法的实现。

步骤四：测试

在TestUnionPay类中，测试银联接口提供的方法，是否成功实现，代码如下所示：

 
  1. import java.util.Scanner;
  2. /**
  3. * 测试实现接口后的类的方法调用
  4. */
  5. public class TestUnionPay {
  7.     public static void main(String[] args) {
  8.         //ICBCImpl icbc = new ICBCImpl(2000,"123456");
  9.         //ICBC icbc = new ICBCImpl(2000,"123456");
  10.         //UnionPay icbc = new ICBCImpl(2000,"123456");
  11.         //UnionPay icbc = new ABCImpl(2000,"123456");
  12.         UnionPay ccb = new CCBImpl(2000,"123456");
  13.         Scanner input = new Scanner(System.in);
  14.         System.out.println("请输入密码：");
  15.         if(ccb.checkPwd(input.next())){
  16.             System.out.println("请输入金额：");
  17.             double num = Double.parseDouble(input.next());
  18.             if(ccb.drawMoney(num)){
  19.                 System.out.println("取钱成功，卡余额为："+icbc.getBalance());
  20.             }
  21.             else{
  22.                 System.out.println("取钱失败");
  23.             }
  24.         }else{
  25.             System.out.println("密码错误");
  26.         }
  27.     }
  28. }

查看上述代码，可以看出上述代码是采用CCBImpl类来实例化银联接口UnionPay的，运行后，实现了取款功能。

本案例中，UnionPay接口的完整代码如下所示：

 
  1. /**
  2. * 接口：用于描述银联统一制定的规则
  3. */
  4. public interface UnionPay {
  5.     /**查看余额*/
  6.     public double getBalance();    
  7.     /**取钱*/
  8.     public boolean drawMoney(double number);
  9.     /**检查密码*/
  10.     public boolean checkPwd(String input);
  11. }
 

CCB接口的完整代码如下所示：

 
  1. /**
  2. * 接口：用于描述建设银行发行的卡片功能，在满足
  3. * 银联的规则基础上，添加自己特有的功能
  4. */
  5. public interface CCB extends UnionPay {
  6.     /**增加的支付燃气费功能*/
  7.     public void payGasBill(double number);
  8. }
 

CCBImpl类的完整代码如下所示：

 
  1. /**
  2. * 类：用于描述建设银行实际发行的卡片
  3. * 该卡片具有的功能来自于继承的已经符合银联规范的CCB接口
  4. */
  5. public class CCBImpl implements CCB {
  6.     private double money;
  7.     private String pwd;
  8.     
  9.     public CCBImpl(double money,String pwd){
  10.         this.money = money;
  11.         this.pwd = pwd;
  12.     }
  13.     
  14.     @Override
  15.     public double getBalance() {        
  16.         return money;
  17.     }
  19.     @Override
  20.     public boolean drawMoney(double number) {
  21.         if(number <= money){
  22.             money -=number;
  23.             return true;
  24.         }
  25.         return false;
  27.     }
  29.     @Override
  30.     public void payGasBill(double number) {
  31.         if(number < money){
  32.             money-=number;
  33.         }
  34.     }
  36.     @Override
  37.     public boolean checkPwd(String input) {
  38.         if(pwd.equals(input))
  39.             return true;
  40.         else
  41.             return false;
  42.     }
  43. }

TestUnionPay类的完整代码如下所示：

 
  1. import java.util.Scanner;
  2. /**
  3. * 测试实现接口后的类的方法调用
  4. */
  5. public class TestUnionPay {
  7.     public static void main(String[] args) {
  8.         //ICBCImpl icbc = new ICBCImpl(2000,"123456");
  9.         //ICBC icbc = new ICBCImpl(2000,"123456");
  10.         //UnionPay icbc = new ICBCImpl(2000,"123456");
  11.         //UnionPay icbc = new ABCImpl(2000,"123456");
  12.         UnionPay ccb = new CCBImpl(2000,"123456");
  13.         Scanner input = new Scanner(System.in);
  14.         System.out.println("请输入密码：");
  15.         if(ccb.checkPwd(input.next())){
  16.             System.out.println("请输入金额：");
  17.             double num = Double.parseDouble(input.next());
  18.             if(ccb.drawMoney(num)){
  19.                 System.out.println("取钱成功，卡余额为："+icbc.getBalance());
  20.             }
  21.             else{
  22.                 System.out.println("取钱失败");
  23.             }
  24.         }else{
  25.             System.out.println("密码错误");
  26.         }
  27.     }
  28. }
 

5 关于接口和抽象类，下列说法正确的是

A. 抽象类和接口都不能实例化。

B. 接口里只能包含抽象方法，抽象类则可以包含普通方法。

C. 接口里不包含构造器，抽象类里可以包含构造器。

D. 一个类只能实现一个接口

参考答案：

选项ABC是正确的。

选项A，抽象类和接口都不能实例化对象，用于被其他类继承和实现。

选项B，接口里只能包含抽象方法，抽象类则可以包含普通方法和抽象方法。

选项C，接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

选项D，一个类只能有一个直接父类；但一个类可以直接实现多个接口，实现多继承。

posted @ 2018-01-22 16:49  清风已来  阅读(316)  评论(0)  编辑  收藏  举报