Question

写出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
   }***

Answer 1

将int n和double r设为protected 。在getN()，你应该写return n;同样在getM()写return m;，getQ()写return q;和getR()写{{1} }}

您的抽象类应该如下所示：

return r;

您没有明确提及在何处使用/覆盖public abstract Calculator{ public abstract calc(); }方法

Answer 2

编写B类声明。

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

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

n，一个整数。此变量只能由扩展B类的类或与B类相同的包访问。

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

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

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

    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;
    }
}

Answer 3

因为在B类中m不应该被任何其他类访问，所以它应该是private 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 tutorial

Answer 4

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，则子类可以覆盖超类的方法。

遵循这些规则集创建两个类

4 个答案: