blocks|key|2027268|text|但是在K3中，我们最终需要知道S的实际类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2027269|2027270|因此，K2.handle()中的所有逻辑都在调用K3.handle()之前。|offset|length|style|CODE|2027271|此外，根据任务的措辞，由于K3.handle(A)和K3.handle(B)不能为K3.handle(S)，因此K3.handle()似乎是一个重载方法，尽管问题中没有明确说明这一点。|2027272|要做到这一点，一种方法是将公共逻辑移动到内部助手方法：|2027273|public+class+K2+{
++++public+void+handle(A+a)+{
++++++++handleInternal(a);
++++++++K3.handle(a);
++++}
++++public+void+handle(B+b)+{
++++++++handleInternal(b);
++++++++K3.handle(b);
++++}
++++private+void+handleInternal(S+s)+{
++++++++//+K2+logic+here
++++}
}|code-block|syntax|javascript|2027274|或者，您可以使用方法引用，允许将对K3的调用嵌入到K2逻辑中，而不仅仅是在最后：|2027275|public+class+K2+{
++++public+void+handle(A+a)+{
++++++++handleInternal(a,+K3::handle);+//+method+reference+to+K3.handle(A)
++++}
++++public+void+handle(B+b)+{
++++++++handleInternal(b,+K3::handle);+//+method+reference+to+K3.handle(B)
++++}
++++private+<T+extends+S>+void+handleInternal(S+s,+Consumer<T>+k3_handle)+{
++++++++//+Some+K2+logic+here
++++++++k3_handle.accept(s);
++++++++//+More+K2+logic+here
++++}
}|2027276|entityMap^0|0|0|3|B|O|B|0|D|C|Q|C|15|C|1K|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|Z|8|@$E|10|F|11|G|H]|$E|12|F|13|G|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|14|8|@$E|15|F|16|G|H]|$E|17|F|18|G|H]|$E|19|F|1A|G|H]|$E|1B|F|1C|G|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1D|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1E|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1F|8|@]|9|@]|A|$]]|$1|T|3|U|5|O|7|1G|8|@]|9|@]|A|$P|Q]]|$1|V|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 But in the very end at K3 we need to know the actual type of S.
</blockquote>

So all the logic in <code>K2.handle()</code> comes before the call to <code>K3.handle()</code>.

Also, since <code>K3.handle(A)</code> and <code>K3.handle(B)</code> cannot be <code>K3.handle(S)</code>, according to the wording of the questing, it would appear that <code>K3.handle()</code> is an overloaded method, even though that's not explicitly stated in the question.

One way to do this is then to move common logic to an internal helper method:

<pre class="lang-java prettyprint-override"><code>public class K2 {
 public void handle(A a) {
 handleInternal(a);
 K3.handle(a);
 }
 public void handle(B b) {
 handleInternal(b);
 K3.handle(b);
 }
 private void handleInternal(S s) {
 // K2 logic here
 }
}
</code></pre>

Or you could use a method reference, allowing the call to K3 to be embedded in the K2 logic, not just at the end:

<pre class="lang-java prettyprint-override"><code>public class K2 {
 public void handle(A a) {
 handleInternal(a, K3::handle); // method reference to K3.handle(A)
 }
 public void handle(B b) {
 handleInternal(b, K3::handle); // method reference to K3.handle(B)
 }
 private &lt;T extends S&gt; void handleInternal(S s, Consumer&lt;T&gt; k3_handle) {
 // Some K2 logic here
 k3_handle.accept(s);
 // More K2 logic here
 }
}
</code></pre>

blocks|key|5812464|text|给定示例类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5812465|class+S+{}

class+A+extends+S+{
++++public+int+getAInfo()+{
++++++++return+1;
++++}
}

class+B+extends+S+{
++++public+int+getBInfo()+{
++++++++return+2;
++++}
}|code-block|syntax|javascript|5812466|我们可以创建一个利用绑定类型参数的接口K，如下所示：|offset|length|style|CODE|5812467|@FunctionalInterface
interface+K<T+extends+S>+{
++++void+handle(T+s);

++++@SafeVarargs
++++static+<FT+extends+S>+K<FT>+compose(K<FT>+finalK,+K<?+super+FT>...+ks)+{
++++++++return+s+->+{
++++++++++++Stream.of(ks).forEach(k+->+k.handle(s));
++++++++++++finalK.handle(s);
++++++++};
++++}
}|5812468|然后，我们可以使用K.construct来创建一个新的K实例，该实例将在整个K流水线中转发一个s。这个K流水线的结构使得除了最后一个k之外的所有都是通用的处理程序，接受S的任何实例。只有最后一个将接受S的特定子类的实例，即FT+(“最终类型”的缩写)。|5812469|使用此K定义，将编译以下所有语句：|5812470|K<S>+k1+=+s+->+System.out.println("K1+handled.");
K<S>+k2+=+s+->+System.out.println("K2+handled.");
K<A>+k3A+=+a+->+System.out.println(a.getAInfo());
K+k3B+=+b+->+System.out.println(b.getBInfo());

K.compose(k3A,+k1,+k2).handle(new+A());+//+Propagates+instance+of+A+through+pipeline
K.compose(k3B,+k1,+k2).handle(new+B());+//+Propagates+instance+of+B+through+pipeline|5812471|然而，管道中不是最后一个k的所有K的即席多态性仍然保持不变，因为这两个语句也会进行编译：|5812472|k1.handle(new+S());
k2.handle(new+S());|5812473|我在这个解决方案中看到的一个缺点是，与其他答案不同，K处理程序必须严格按顺序执行，并且对下一个k处理程序的调用不能在前一个处理程序的中间发生。|5812474|entityMap^0|0|0|J|1|0|0|9|B|R|1|12|1|1B|1|1F|1|1U|1|2C|1|2S|1|33|2|0|3|1|0|0|C|1|G|1|0|0|Q|1|1B|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|18|8|@$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]|$I|1J|J|1K|K|L]|$I|1L|J|1M|K|L]|$I|1N|J|1O|K|L]|$I|1P|J|1Q|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1R|8|@$I|1S|J|1T|K|L]]|9|@]|A|$]]|$1|S|3|T|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1V|8|@$I|1W|J|1X|K|L]|$I|1Y|J|1Z|K|L]]|9|@]|A|$]]|$1|W|3|X|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|21|8|@$I|22|J|23|K|L]|$I|24|J|25|K|L]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|26|8|@]|9|@]|A|$]]]|11|$]]

Given sample classes:

<pre><code>class S {}

class A extends S {
 public int getAInfo() {
 return 1;
 }
}

class B extends S {
 public int getBInfo() {
 return 2;
 }
}
</code></pre>

We can make an interface <code>K</code> that takes advantage of a bounded type parameter as follows:

<pre><code>@FunctionalInterface
interface K&lt;T extends S&gt; {
 void handle(T s);

 @SafeVarargs
 static &lt;FT extends S&gt; K&lt;FT&gt; compose(K&lt;FT&gt; finalK, K&lt;? super FT&gt;... ks) {
 return s -&gt; {
 Stream.of(ks).forEach(k -&gt; k.handle(s));
 finalK.handle(s);
 };
 }
}
</code></pre>

We can then use <code>K.construct</code> to make a new instance of <code>K</code> that will forward an <code>s</code> throughout an entire pipeline of <code>K</code>s. This pipeline of <code>K</code>s is structured such that all but the last <code>k</code> are generic handlers, accepting any instance of <code>S</code>. Only the last one will accept an instance of a specific subclass of <code>S</code>, namely <code>FT</code> (abbreviation for "final type").

With this <code>K</code> definition, all the following statements compile:

<pre><code>K&lt;S&gt; k1 = s -&gt; System.out.println("K1 handled.");
K&lt;S&gt; k2 = s -&gt; System.out.println("K2 handled.");
K&lt;A&gt; k3A = a -&gt; System.out.println(a.getAInfo());
K&lt;B&gt; k3B = b -&gt; System.out.println(b.getBInfo());

K.compose(k3A, k1, k2).handle(new A()); // Propagates instance of A through pipeline
K.compose(k3B, k1, k2).handle(new B()); // Propagates instance of B through pipeline
</code></pre>

yet the ad-hoc polymorphism of all the <code>K</code>s in the pipeline that are not the last <code>k</code> is still maintained, as both these statements compile as well:

<pre><code>k1.handle(new S());
k2.handle(new S());
</code></pre>

One downside I see in this solution is that, unlike the other answer, the <code>K</code> handlers must be strictly sequentially executed, and calls to the next <code>k</code>'s handler cannot happen in the middle of the previous one. Through I still think you can extend this type of design to enable support for that.

blocks|key|1610653|text|是的，这是一个访问者模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1610654|参观者是|1610655|interface+K+{
++++void+handle(A+a);
++++void+handle(B+b);
}|code-block|syntax|javascript|1610656|并由K1、K2、K3实现。|offset|length|style|CODE|1610657|S需要的是一个带有实现的方法visit(K)|1610658|class+A+implements+S+{
++++public+void+visit(K+visitor)+{
++++++++visitor.handle(this);+//+calls+the+handle(A)+method
++++}
}
class+B+implements+S+{
++++public+void+visit(K+visitor)+{
++++++++visitor.handle(this);+//+calls+the+handle(A)+method
++++}
}|1610659|你的列表(即你的链条)只是一个List<K>，其内容类似于|1610660|List<K>+handlers+=+Arrays.asList(new+K1(),+new+K2(),+new+K3());
S+sample+=+new+A();
for+(K+visitor+:+handlers)+{
++++sample.visit(visitor);
}
sample+=+new+B();
for+(K+visitor+:+handlers)+{
++++sample.visit(visitor);
}|1610661|这是一个running+version。|1610662|entityMap|0|LINK|mutability|MUTABLE|url|https://ideone.com/fV7Moh^0|0|0|0|2|2|5|2|8|2|0|E|8|0|0|F|7|0|0|4|F|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@$K|1A|L|1B|M|N]|$K|1C|L|1D|M|N]|$K|1E|L|1F|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1G|8|@$K|1H|L|1I|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1K|8|@$K|1L|L|1M|M|N]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1N|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1O|8|@]|9|@$K|1P|L|1Q|1|1R]]|A|$]]|$1|Y|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

Yes, this is a visitor pattern.

The visitor is 

<pre><code>interface K {
 void handle(A a);
 void handle(B b);
}
</code></pre>

and <code>K1</code>, <code>K2</code>, <code>K3</code> implement it.

What S needs is a method <code>visit(K)</code> with the implementations

<pre><code>class A implements S {
 public void visit(K visitor) {
 visitor.handle(this); // calls the handle(A) method
 }
}
class B implements S {
 public void visit(K visitor) {
 visitor.handle(this); // calls the handle(A) method
 }
}
</code></pre>

Your list (ie your chain) is just a <code>List&lt;K&gt;</code> with something like

<pre><code>List&lt;K&gt; handlers = Arrays.asList(new K1(), new K2(), new K3());
S sample = new A();
for (K visitor : handlers) {
 sample.visit(visitor);
}
sample = new B();
for (K visitor : handlers) {
 sample.visit(visitor);
}
</code></pre>

Here's a <a href="https://ideone.com/fV7Moh" rel="nofollow noreferrer">running version</a>.

blocks|key|5812580|text|我从来没有真正欣赏过Visitor模式，所以这里有一个使用函数组合和Java泛型的替代方案。我认为您不需要使用这种方法向现有的类或接口添加方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5812581|您可以利用这样一个事实，即K3.handle(A)是一个Consumer<A>，您可以使用Function<A,A>+handleA+=+a+->+k3.handle(a);+return+a;轻松地将其转换为Function<A,A>。这将返回类型为A的输入元素，然后可以使用其他函数k2::handle和k1::handle对其进行compose()。您不能将其作为单行上的链式调用来执行，因为这会破坏Java的类型推断，但这是有效的：|offset|length|style|CODE|5812582|K+k1+=+new+K1();
K+k2+=+new+K2();
//+construct+A+chain
K3A+specificA+=+new+K3A();
Function<A,+A>+handleA+=+a+->+specificA.handle(a);
handleA+=+handleA.compose(k2::handle);
handleA+=+handleA.compose(k1::handle);|code-block|syntax|javascript|5812583|在这种情况下，|5812584|class+K+{
++++<T>+T+handle(T+item);
}
class+K3A+{
++++A+handle(A+item)+{+...+}
}|5812585|但是，如果handle()方法是void，您可以将它们包装到lambda中，如上所述。|5812586|我不确定你是否觉得这更具可读性/可维护性，但我还是非常不喜欢Visitor，所以我不得不试一试。|5812587|这里是一个running+sample，这里是一个fork+with+the+wrapped+version+(它表示的情况与您展示的IIUC完全相同，并且没有对S、A、B或任何K进行任何代码更改)。|5812588|entityMap|0|LINK|mutability|MUTABLE|url|https://ideone.com/BqlEqf|1|https://ideone.com/fmWxvh^0|0|D|C|S|B|19|1G|2X|D|3I|1|3Z|A|4A|A|4O|9|0|0|0|0|5|8|G|4|0|0|29|1|2B|1|2D|1|2H|1|5|E|0|P|T|1|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]|$D|1K|E|1L|F|G]|$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1O|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1P|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1Q|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1W|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1X|8|@$D|1Y|E|1Z|F|G]|$D|20|E|21|F|G]|$D|22|E|23|F|G]|$D|24|E|25|F|G]]|9|@$D|26|E|27|1|28]|$D|29|E|2A|1|2B]]|A|$]]|$1|W|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

I never really appreciated Visitor pattern, so here's an alternative with using functional composition and Java generics. I don't think you need to add methods to existing classes or interfaces using this approach.

You can use the fact that <code>K3.handle(A)</code> is a <code>Consumer&lt;A&gt;</code> which you can easily transform into a <code>Function&lt;A,A&gt;</code> by using <code>Function&lt;A,A&gt; handleA = a -&gt; k3.handle(a); return a;</code>. This returns the input element typed as <code>A</code>, which you can then <code>compose()</code> with the other functions <code>k2::handle</code> and <code>k1::handle</code>. You cannot do that as a chained call on a single line because that breaks Java's type inference, but this works:

<pre><code>K k1 = new K1();
K k2 = new K2();
// construct A chain
K3A specificA = new K3A();
Function&lt;A, A&gt; handleA = a -&gt; specificA.handle(a);
handleA = handleA.compose(k2::handle);
handleA = handleA.compose(k1::handle);
</code></pre>

In this case,

<pre><code>class K {
 &lt;T&gt; T handle(T item);
}
class K3A {
 A handle(A item) { ... }
}
</code></pre>

but if the <code>handle()</code> methods are <code>void</code>, you can wrap them into lambdas as I've described above.

Not sure if you find this more readable/maintainable, but again I dislike Visitor so much that I had to try.

Here's a <a href="https://ideone.com/BqlEqf" rel="nofollow noreferrer">running sample</a> and here a <a href="https://ideone.com/fmWxvh" rel="nofollow noreferrer">fork with the wrapped version</a> (which represents exactly the case you presented IIUC, and without any code change in <code>S</code>, <code>A</code>, <code>B</code> or any of the <code>K</code>s).

So imagine this,

Given a class hierarchy:

<pre><code>S (abstract)
A extends S
B extends S
</code></pre>

Let's say we have a chain of connected components handling objects of types of A and B. For example:
<code>K1.handle(A) -&gt; K2.handle(A) -&gt; K3.handle(A)</code>
meaning that K1 takes in A and calls K2 with A which calls K3 with A.

Similarly we have:
<code>K1.handle(B) -&gt; K2.handle(B) -&gt; K3.handle(B)</code>

Thing is K2's logic does not depend on the sub type of S. So we could replace K2.handle(A) and K2.handle(B) with K2.handle(S). But the problem is that at some point we need to do type checking of the actual object type to call correct K3 method.

How does one solve this without doing <code>if</code> or <code>switch</code> etc. statements that inspect the type/properties of the actual objects?

Is it the visitor pattern I need to look into?

To give a concrete example of the case. Let's say K1 is a REST controller with different POST endpoints for A and B. It deserialises the payload and validates the data, then it passes the object to K2 for further processing. All the steps included in K2 (and other components it calls) are happy to work with objects of type S only. But in the very end at K3 we need to know the actual type of S.

From sub class to super class and back again

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

所以想象一下，给定一个类层次结构：S (abstract)A extends SB extends S假设我们有一个处理A和B类型对象的连接组件链。例如：K1.handle(A) -> K2.handle(A) -> K3.handle(A)表示K1接受A并使用A调用K2，后者使用A调用K3。类似地，我们有：K1.ha...

问从子类到超类，然后再返回
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从子类到超类，然后再返回EN