blocks|key|1613188|text|这取决于你对“距离”的定义。您可以为基类提供一个抽象的CenterPoint属性，该属性被每个派生类覆盖。现在很简单了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1613189|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It depends on what you define as "distance". You could give the base class an abstract CenterPoint property, overridden by each derived class. Now it is simple.

blocks|key|325280|text|如果形状在X和Y轴上都是对称的，并且距离应该从中心开始计算，那么您可能希望在抽象基类中有一个Point+GetCenter()方法。从那里，使用distance+formula计算它们之间的距离。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|325281|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Distance^0|1A|H|20|G|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

If the shapes are all symmetrical on both the X and Y axes, and distance should be calculated from the center, then you'd want to have a <code>Point GetCenter()</code> method in the abstract base class. From there, use the <a href="http://en.wikipedia.org/wiki/Distance" rel="nofollow noreferrer">distance formula</a> to calculate the distance between them.

blocks|key|1613242|text|您可以创建一个抽象基类Shape，您可以从该抽象基类继承每个形状的类。在基类中，您为所需的功能声明了一个抽象方法(例如，CalculateDistance)，但没有任何代码(即没有主体)。在每个继承类中，您都需要提供此方法的实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1613243|注意:选择Shape类的属性和方法时，需要将大量代码从一个shape派生类复制到另一个shape派生类。如果是这种情况，您应该将该代码放在抽象Shape类的属性或方法中。最后，每个子类只包含每个形状不同部分的代码。这取决于您的实现，取决于如何在内部表示形状。|1613244|entityMap^0|B|5|1O|H|0|5|5|1Z|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

You could create an abstract base class <code>Shape</code> from which you inherit classes for each of those shapes. In the base class, you declare an abstract method for the functionality you want (for example, <code>CalculateDistance</code>), but without any code (i.e. no body). In each of the inherited classes, you will need to provide implementation for this method.

On a related note: choose the properties and methods for your <code>Shape</code> class in such way that you would need to copy substantial amounts of code from one shape derived class to another. If that would be the case, you should put that code in a property or method in the abstract <code>Shape</code> class. In the end, each subclass only contains code for those portions that differ for each shape. This depends on your implementation, on how to want to represent a shape internally.

blocks|key|1074254|text|这是一个棘手的问题，因为如果您正在实现使用最近点计算两个对象之间的距离的方法，那么您确实需要知道这两个对象的类型。例如，如果您使用中心点来比较它，那么它将很容易-您只需添加GetCenter方法，但这在这种情况下根本不起作用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1074255|问题是，如果您可以将类层次结构设计为可扩展的，那么类层次结构就很有用-也就是说，允许在不修改现有类型的情况下添加其他类型。这里不是这种情况，因为当您添加Ellipse时，您将需要实现DistancePointEllipse、DistanceTriangleEllipse等...使用函数式语言中已知的algebraic+data+type来表示这一点会容易得多。例如在F#中：|1074256|type+Shape+=+
++%7C+Circle+of+float+*+float+*+float+//+center+&+radius
++%7C+Point+of+float+*+float++++++++++//+center|code-block|syntax|javascript|1074257|然后，您可以使用模式匹配来处理所有可能的情况：|1074258|match+shape1,+shape2+with
%7C+Circle(x1,+y1,+r1),+Circle(x2,+y2,+r2)+->+//+two+circles
%7C+Point(x1,+y1),+Point(x2,+y2)+->+//+two+points
%7C+Circle(cx,+cy,+r),+Point(px,+py)+
%7C+Point(px,+py),+Circle(cx,+cy,+r)+->
++++//+point+and+a+circle+(both+combinations|1074259|函数式编程似乎更适合这个问题:-)。|1074260|无论如何，一种可能的(但仍然是不可扩展的)面向对象设计是让Shape基类具有DistanceToPoint、DistanceToTriangle等方法，这些方法计算从当前类型到另一种形状类型的距离(因为您确实需要所有的组合)。|1074261|另一种方法是简单地在C#中编写重载方法：|1074262|float+Distance(Triangle+t,+Point+p);
float+Distance(Triangle+t,+Circle+c);
//+...+etc|1074263|这个选项的好处是，您可以很容易地减少需要编写的方法的数量。例如，如果您有一个用于Ellipse和Point的案例，则可以从Ellipse继承Circle，然后在比较Circle和Point时也使用现有案例。|1074264|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Algebraic_data_type^0|2E|9|0|24|7|2J|K|34|N|46|J|0|0|0|0|0|0|T|5|12|F|1I|I|0|0|0|14|7|1C|5|1P|7|1Y|6|2A|6|2H|5|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|H|3|I|5|J|7|1L|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1M|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1O|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1W|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1X|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]|$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|10|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]]]

This is a tricky problem, because if you're implementing the method to calculate distance between two objects using the nearest point, you really need to know what are the types of both of the objects. If you were comparing it using for example the center point, then it would be easy - you'd just add <code>GetCenter</code> method, but that simply doesn't work in this case.

The problem is that class hierarchies are useful if you can design them as extensible - that is, allow adding of other types without modifying the existing ones. This is not the case here, because when you add <code>Ellipse</code> you'll need to implement <code>DistancePointEllipse</code>, <code>DistanceTriangleEllipse</code>, and so on... It would be much easier to represent this using <a href="http://en.wikipedia.org/wiki/Algebraic_data_type" rel="nofollow noreferrer">algebraic data type</a> known from functional languages. For example in F#:

<pre><code>type Shape = 
 | Circle of float * float * float // center &amp; radius
 | Point of float * float // center
</code></pre>

Then you could use pattern matching to handle all possible cases:

<pre><code>match shape1, shape2 with
| Circle(x1, y1, r1), Circle(x2, y2, r2) -&gt; // two circles
| Point(x1, y1), Point(x2, y2) -&gt; // two points
| Circle(cx, cy, r), Point(px, py) 
| Point(px, py), Circle(cx, cy, r) -&gt;
 // point and a circle (both combinations
</code></pre>

Functional programming simply seems to be a better fit for this problem :-).

Anyway, one possible (but still non-extensibel) object-oriented design would be to have <code>Shape</code> base class with methods <code>DistanceToPoint</code>, <code>DistanceToTriangle</code>, etc. that calculate the distance from the current type to the other type of shape (as you really need all the combinations).

Another approach would be to simply write overloaded method in C#:

<pre><code>float Distance(Triangle t, Point p);
float Distance(Triangle t, Circle c);
// ... etc
</code></pre>

The nice thing about this option is that you could easily reduce the number of methods you need to write. For example if you have a case for <code>Ellipse</code> and <code>Point</code>, you can inherit <code>Circle</code> from <code>Ellipse</code> and then use the existing case when comparing <code>Circle</code> with <code>Point</code> as well.

blocks|key|1074279|text|一种可以使其可扩展的设计是将距离查找封装为对特定形状进行操作的策略。您将为新的形状类型对注册委托，然后系统可以使用这些委托来解析任何形状类型对的适当函数。这将允许可扩展性，但它也会增加复杂性并降低性能。如果您的层次结构如您所描述的那样简单，那么简单的条件语句将会更快、更容易维护。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1074280|这里真正的问题是，所讨论的函数不是特定类的简单行为，而是涉及系统中所有形状的知识。对于'OOP‘，你能做的最好的事情就是把所有混乱的条件都封装在一个知道你所有形状的管理器类中。您无法避免由于提供此功能而引入的必要耦合，但您至少可以将其隐藏在一个更简单的接口后面，正如您所描述的那样。|1074281|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

One design that could make this extensible would be to encapsulate the distance finding as a Strategy that operates on particular Shapes. You would register delegates for new Shape type pairs, which the system could then use to resolve an appropriate function for any pair of shape types. This would allow for extensibility, but it would also increase complexity and decrease performance. If your hierarchy is as simple as you've described, then simple conditionals will be both faster and easier to maintain.

The real issue here is that the function in question is not a simple behavior of a specific class, but rather involves knowledge about all of the Shapes in the system. The best you can do for 'OOP' is encapsulate all the messy conditionals in a manager class that knows about all of your Shapes. You can't avoid the necessary coupling that is introduced as a result of providing this function, but you can at least hide it behind a simpler interface, as you've described.

blocks|key|1074296|text|使用that方法创建一个抽象的Shape基类，该方法将形状转换为多边形：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1074297|abstract+class+Shape
{
++++virtual+Polygons+Flatten();
}|code-block|syntax|javascript|1074298|计算两个多边形之间的距离的代码应该足够简单。那么你的距离函数看起来像这样：|1074299|float+Distance(Shape+a,+Shape+b)
{
++++Polygons+polygonsA+=+a.Flatten();
++++Polygons+polygonsB+=+b.Flatten();
++++return+polygonsA.Distance(polygonsB);
}|1074300|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Make an abstract Shape base class with a flatten method, that converts the shape to polygons:

<pre><code>abstract class Shape
{
 virtual Polygons Flatten();
}
</code></pre>

The code to calculate the distance between two polygons should be easy enough. Then your Distance function looks like this:

<pre><code>float Distance(Shape a, Shape b)
{
 Polygons polygonsA = a.Flatten();
 Polygons polygonsB = b.Flatten();
 return polygonsA.Distance(polygonsB);
}
</code></pre>

I want to design shape class. I need to distinguish several different shapes: 

<pre><code>-Point 
-Line 
-Triangle 
-Circle 
-Polygons 
</code></pre>

The main purpose of this class is to calculate distance between two shapes. 
I've all methods for calculating those distances, but I want to have a single method that can be used, it should looks like this:

<pre><code>float Distance(Shape a, Shape b)
</code></pre>

Simplest way to do it is to put a lot of if statements and then invoke proper method but this is deffinitely not OOP.

How to design such class in OOP style?

How to design shape class

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想设计形状类。我需要区分几种不同的形状：-Point  -Line  -Triangle  -Circle  -Polygons  这个类的主要目的是计算两个形状之间的距离。我有计算这些距离的所有方法，但我想要一个可以使用的方法，它应该是这样的：float Distance(Shape a, Shape b)要做到这...

问如何设计shape类
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何设计shape类EN