-1

为 B 类编写声明。该类的成员应如下所示：

m，一个整数。类外部的代码或扩展类 B 的任何类都不应访问此变量。

n，整数。该变量应该只能被扩展类 B 的类或与类 B 位于同一包中的类访问。

setM、getM、setN 和 getN。这些是成员变量 m 和 n 的 mutator 和 accessor 方法。类外的代码应该可以访问这些方法。计算。这是一个公共抽象方法。

接下来，为类 D 编写声明，它扩展类 B。该类的成员应如下所示：q，一个双精度数。类外的代码不应访问此变量。r，双。扩展类 D 或在同一包中的任何类都应该可以访问此变量。setQ、getQ、setR 和 getR。这些是成员变量 q 和 r 的 mutator 和 accessor 方法。类外的代码应该可以访问这些方法。calc，一个覆盖超类的抽象 calc 方法的公共方法。此方法应返回 q 乘以 r 的值。

这是我的代码，盯着看的是我弄错的部分-

import java.io.*;
public class ClassB{

   ***private int m;
   public int n;***
  public setM(int minteger){
      m=minteger;
   }
   public void getM(){
      return minteger;
   }
   public setN(int ninteger){
      n=ninteger;
   }
   ***public void getN(){
      return ninteger
   }***
}

public class ClassD extends ClassB
{
   private double q;
   ***public double r;***

  public setQ(double qdouble){
      q=qdouble;
   }
   public void getQ(){
      return qdouble;
   }
   public setR(double rdouble){
      r=rdouble;
   }
   public void getR(){
      return rdouble
   }
}
   ***public abstract class calc{
   return r*q
   }***
4

4 回答 4

2

制作int n和double r作为protected 。在getN()你应该写return n;类似的getM()写return m;，getQ()写return q;和getR()写return r;

您的抽象类应如下所示：

 public abstract Calculator{
      public abstract calc();
 }

你没有明确提到在哪里使用/覆盖calc方法

于 2012-10-11T16:50:39.120 回答
1

写 B 类的声明。

该类的成员应如下所示： m，整数。类外部的代码或扩展类 B 的任何类都不应访问此变量。 *

m 必须是私有的（也是 q）

n，整数。该变量应该只能被扩展类 B 的类或与类 B 位于同一包中的类访问。

n 必须受到保护（也是 r）

计算。这是一个公共抽象方法。

在 B 类中有一个抽象方法要求 B 类是一个抽象类。B 类应该定义在 D 类中实现的抽象方法 calc。注意在 return 语句中使用 private 或 protected 成员，例如，return m而不是。return minteger至于计算：

    public abstract class Class_B{

    private int m;
    protected int n;

      //insert mutator and accessor methods

    public abstract double calc();
    }

    public class Class_D extends Class_B{

    private double q;
    protected double r;

      //insert mutator and accessor methods

    @Override
    public double calc() {
        return q*r;
    }
}
于 2012-10-11T17:35:51.520 回答
0

因为在 B 类中，任何其他类都不能访问 m，所以它应该是私有的 int m。将 int n 和 double r 设为受保护。getN 访问器应该是

public int getN()
{
return n;
}

getM 也应该是

public int getM()
{
return m;
}

getQ 和 getR 的其他两个访问器方法也应该有返回类型 double。你的抽象类应该看起来像

public abstract Calculator
{
public abstract cal();
}

欲了解更多访问详情，请学习Oracle 教程

于 2012-10-11T17:08:08.900 回答
0 
class B
{

    private int m;

    protected int n;

    public int getM()
    {
        return m;
    }

    public void setM(int m)
    {
        this.m = m;
    }

    public int getN()
    {
        return n;
    }

    public void setN(int n)
    {
        this.n = n;
    }
}




class D extends B
{

    private double q;

    double r;

    public double getQ()
    {
        return q;
    }

    public void setQ(double q)
    {
        this.q = q;
    }

    public double getR()
    {
        return r;
    }

    public void setR(double r)
    {
        this.r = r;
    }
}

这里我想告诉你一些关于java类声明中的一些访问修饰符。其中有 4 个：public/default/protected/private

如您所知 public，意味着可以从任何地方访问（读/写）类的这个字段。default存在但未明确使用

int a;

当前面没有其他修饰符意味着它使用default修饰符时，这就是您所说的“仅可访问扩展类 B 或与类在同一包中的类”。

protected是只能由此类或扩展此类的类访问的特权。

private是java中最严格的修饰符，这意味着字段或方法只能被类的对象访问。从这个类继承的类不能访问这些字段或方法。

另一个需要注意的是，如果这个方法不是，子类可以覆盖超类的方法private。

于 2012-10-11T17:38:20.323 回答