Java Line类的Getter方法

我有两个类：

Point

class和

LineSub

，它们

扩展了
Point

这是第一个类的构造函数
第一个类还具有私有变量的
getter
和
setter

    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

这是第二节课：

public class LineSub extends Point {

    Point end;  // It has only the end instance variable.
    public LineSub(Point begin, Point end) {
       super(begin.getX(), begin.getY());
       this.end = end;
    }
}

问题：是否可以编写一个返回起点的
getBegin（）
方法？
排序。但它所包含的只是这个

public Point getBegin() {
return new Point(super.getX(), super.getY());
}

public Point getBegin(){
    return this;
}

您的
LineSub
方法不只是引用开始
点
。这是开始
点

public class Line {
    private Point begin;
    private Point end;

    public Line(Point begin, Point end) {
       this.begin = begin;
       this.end = end;
    }
}

由于您从<代码>点>代码继承，所有公共方法都是对引用您实现的任何人都可以访问的字段，并且由于您实现它的方式，引用是您所考虑的起点。
请注意，这几乎肯定是实现此功能的错误方法，并且可能是您应该使用的方法。不过我会留下这个答案，因为它不需要更改类的实现。
有点像。但它所包含的只是这个

public Point getBegin(){
    return this;
}

您的
LineSub
方法不只是引用开始
点
。这是开始
点

public class Line {
    private Point begin;
    private Point end;

    public Line(Point begin, Point end) {
       this.begin = begin;
       this.end = end;
    }
}

由于您从<代码>点>代码继承，所有公共方法都是对引用您实现的任何人都可以访问的字段，并且由于您实现它的方式，引用是您所考虑的起点。
请注意，这几乎肯定是实现此功能的错误方法，并且可能是您应该使用的方法。不过，我会留下这个答案，因为它不需要更改类的实现。
要回答您的问题，请回答“是”；尽管有多种方法：

public Point getBegin() {
    return new Point(super.getX(), super.getY());
}

另一种方法是在类中维护
begin
实例：

Point end;
Point begin;

public LineSub(Point begin, Point end) {
    this.begin = begin;
    this.end = end;
}

public Point getBegin() {
    return this.begin;
}

您会注意到，第二种方法消除了继承的需要。事实上，这就引出了我的主要观点。这是一个非常奇怪的类层次结构，我会积极反对它。
行
由两个点组成；这本身不是两点。
回答你的问题，是的；尽管有多种方法：

public Point getBegin() {
    return new Point(super.getX(), super.getY());
}

另一种方法是在类中维护
begin
实例：

Point end;
Point begin;

public LineSub(Point begin, Point end) {
    this.begin = begin;
    this.end = end;
}

public Point getBegin() {
    return this.begin;
}

您会注意到，第二种方法消除了继承的需要。事实上，这就引出了我的主要观点。这是一个非常奇怪的类层次结构，我会积极反对它。
行
由两个点组成；它本身不是两点。
可以编写一个getter方法，返回一个
点作为起点（从
点
类），但这不是一个好的设计

我要做的是重新考虑你的设计。
LineSub
a
点
？否，一个
LineSub
由两个
点组成，即起点和终点

我将创建一个
行
类，而不是子类化
点
，该类不使用两个成员变量扩展
点
，每个变量都是
点

public class Line {
    private Point begin;
    private Point end;

    public Line(Point begin, Point end) {
       this.begin = begin;
       this.end = end;
    }
}

然后您可以编写两个getter方法，一个用于
点
s。可以编写一个getter方法，返回一个
点
作为起点（从
点
类），但这不是一个好的设计

我要做的是重新考虑你的设计。
LineSub
a
点
？否，一个
LineSub
由两个
点组成，即起点和终点

我将创建一个
行
类，而不是子类化
点
，该类不使用两个成员变量扩展
点
，每个变量都是
点

public class Line {
    private Point begin;
    private Point end;

    public Line(Point begin, Point end) {
       this.begin = begin;
       this.end = end;
    }
}

然后，您可以编写两个getter方法，一个用于
点
s.
因为
LineSub
扩展了
点
，并且基本上是使用它的super来存储begin
点
，所以您可以返回它：

public Point getBegin() {
    return this;
}

但是，如果
点
是可变的，这可能是一个坏主意，因为它将允许调用方修改
LineSub
的开头：
myLineSub.getBegin（）.setX（123）。更安全的方法可能是重建对象：

 public Point getBegin() {
    return new Point(getX(), getY());
}

由于
LineSub
扩展了
点
，并且基本上是使用它的super来存储begin
点
，因此您可以返回它：

public Point getBegin() {
    return this;
}

但是，如果
点
是可变的，这可能是一个坏主意，因为它将允许调用方修改
LineSub
的开头：
myLineSub.getBegin（）.setX（123）。更安全的方法可能是重建对象：

 public Point getBegin() {
    return new Point(getX(), getY());
}

你的代码应该是这样的

public class LineSub {
    Point begin;
    Point end;
    public LineSub(Point begin, Point end) {
       this.end = end;
       this.begin = begin;
    }
}

正如前面指出的，您不需要退出it点。
您的代码应该如下所示

public class LineSub {
    Point begin;
    Point end;
    public LineSub(Point begin, Point end) {
       this.end = end;
       this.begin = begin;
    }
}

正如所指出的，您不需要退出it点。
是的，使用
x
和
y
的getter

public Point getBegin() {
    return new Point(getX(), getY());
}

然而，让line类只包含两点不是更有意义吗

例如：

public class Line {
    private Point begin;
    private Point end;

    public Line(Point begin, Point end) {
        this.begin = begin;
        this.end = end;
    }
}

是，使用
x
和
y
的getter

public Point getBegin() {
    return new Point(getX(), getY());
}

然而，让line类只包含两点不是更有意义吗

例如：

public class Line {
    private Point begin;
    private Point end;

    public Line(Point begin, Point end) {
        this.begin = begin;
        this.end = end;
    }
}

旁注：这是一个错误的类层次结构。很明显，
行
没有扩展
点
。我知道这很糟糕。这是从这里开始的练习。我更喜欢用作文，但这是练习。好吧，你知道这不好。下面是您选择的答案。您可以返回您自己（返回此；），因为您是一个点，或者您可以在调用getX和getY后创建一个新点。这两种方法都有效。当我认为练习顺序是错误的时候，我从不遵循。我会写我认为正确的练习，即使它会花费我的分数（在我的情况下，它通常没有）。旁注：这是一个糟糕的类层次结构。很明显，
Line