blocks|key|1681307|text|您能做的最好的事情就是在您的子类中调用super.func()，并让您的子类中的func()实现也调用super.func()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1681308|然而，问问你自己，如果我不仅需要我的父母实现的知识，也需要我的祖父母实现的知识，我是否有设计问题？坦率地说，这是在触动我“冰箱里有东西发臭”的本能。你需要重新评估你为什么要这样做。|1681309|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|$]]

The best you can do is call super.func() in your subsub class, and have the func() implementation in your subclass also call super.func().

However, ask yourself, if I need knowledge not only of my parents implementation but also my grandparents implementation, do I have a design problem? Quite frankly this is tripping my "Something stinks in the fridge" instinct. You need to re-evaluate why you want to do this.

blocks|key|662952|text|这在Java中是不可能的。顺便说一句。Java中没有任何指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|662953|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|$]]

This isn't possible in Java. And btw. there aren't any pointers in Java.

blocks|key|663172|text|我会跳上“这个设计中的某些东西闻起来很奇怪”的火车。通常，您会重写一个方法，以便它对特定的子类正常工作。如果您的父类中有跨多个子类共享的代码，那么也许可以将这些代码移动到一个非重写的方法中，以便所有的子类/granchildren/等都可以轻松地访问它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|663173|你能不能翻开你的设计，使用更多的模板方法？(http://en.wikipedia.org/wiki/Template_method_pattern)|offset|length|663174|模板方法背后的概念是，您的父类中有一些算法，您可以通过对子类的多态调用来填充需要特定于类的部分。你的问题中没有太多的细节，但从声音上看，我真的会好好看看你的设计，看看它是否有意义。|663175|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Template/_method/_pattern^0|0|M|1G|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I would jump on the "something in this design smells funny" train. Normally, you override a method so that it works properly for that specific subclass. If you have code in your parent class that is shared across multiple subclasses, perhaps that code could be moved to a non-overridden method so that it is readily accessible by all children/granchildren/etc.

Could you perhaps flip your design over and use more of a template method approach? (http://en.wikipedia.org/wiki/Template_method_pattern)

The notion behind Template Method is that you have some algorithm in your parent class and you can fill in the pieces that need to be class specific by polymorphic calls into your subclasses. You don't have a ton of detail in your question, but by the sounds of things, I'd really take a good look at your design and see if it makes sense.

blocks|key|662997|text|如果您需要调用一个定义在层次结构上两级的函数，那么您可能应该重新考虑如何处理类层次结构。考虑编写由每个子类以不同方式实现的新方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|662998|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|$]]

You should probably rethink how you are handling your class hierarchy if you need to place a call to a function that is defined two levels up the hierarchy. Consider writing new methods that are implemented by each subclass in a different way.

blocks|key|1681329|text|此示例是调用“祖父母”超方法的唯一方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1681330|class+A{
++++public+void+foo(){+System.out.println("Hi");+}
}

class+B+extends+A{
++++public+void+foo(){+super();+}
}

class+C+extends+B{
++++public+void+foo(){+super();+}
}|code-block|syntax|javascript|1681331|如果B不覆盖foo()，那就另当别论了。|offset|length|style|CODE|1681332|另一种选择是在中间类中使用“受保护的帮助器”方法。|1681333|class+D{
++++public+void+foo(){+System.out.println("Hi");+}
}

class+E+extends+D{
++++public+void+foo(){+System.out.println("Hello");+}
++++protected+void+bar(){+super.foo();+}
}

class+F+extends+E{
++++public+void+foo(){+super.bar();+}
}|1681334|entityMap^0|0|0|2|1|6|5|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

This example is the only way to call a "grandparent" super method.

<pre><code>class A{
 public void foo(){ System.out.println("Hi"); }
}

class B extends A{
 public void foo(){ super(); }
}

class C extends B{
 public void foo(){ super(); }
}
</code></pre>

This would be a different story if <code>B</code> doesn't override <code>foo()</code>.

Another option would be to have a "protected helper" method in the middle class.

<pre><code>class D{
 public void foo(){ System.out.println("Hi"); }
}

class E extends D{
 public void foo(){ System.out.println("Hello"); }
 protected void bar(){ super.foo(); }
}

class F extends E{
 public void foo(){ super.bar(); }
}
</code></pre>

blocks|key|2729912|text|您可以从子类本身访问超类方法，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2729913|class+A+{
+++void+foo()+{...}
}

class+B+extends+A+{
+++void+foo()+{...}
+++void+defaultFoo()+{+super.foo();+}
}|code-block|syntax|javascript|2729914|然而，你真的不应该以这种方式公开被覆盖的方法，你应该以一种对A和B都很好的方式编写B.foo()。这就是使用super.foo();的一个好主意：|offset|length|style|CODE|2729915|+class+B+extends+A+{
++++void+foo()+{+
++++++super.foo();+//call+superclass+implementation+first
++++++...+//do+stuff+specific+to+B
++++}
+}|2729916|更新：在回应你关于尝试访问2级以上实现的评论时，这里有一种方法。|BOLD|2729917|class+A+{
+++void+foo()+{+
+++++defaultFoo();+
+++}
+++protected+void+defaultFoo()+{+...+}

}

class+B+extends+A+{
+++void+foo()+{...}
}

class+C+extends+B+{
+++void+foo()+{
+++++defaultFoo();+
+++++...+//do+other+stuff
+++}
}|2729918|这是对你想要做的事情进行编码的更健康的模式。|2729919|entityMap^0|0|0|15|7|1I|C|0|0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|15|8|@$I|16|J|17|K|Q]]|9|@]|A|$]]|$1|R|3|S|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|T|3|U|5|6|7|19|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|W|$]]

You can access the superclass methods from within the subclass itself, e.g.

<pre><code>class A {
 void foo() {...}
}

class B extends A {
 void foo() {...}
 void defaultFoo() { super.foo(); }
}
</code></pre>

However, you really shouldn't be exposing overridden methods this way, you should write <code>B.foo()</code> in such a way that works fine for A and B. This is where it is a good idea to use <code>super.foo();</code> like this:

<pre><code> class B extends A {
 void foo() { 
 super.foo(); //call superclass implementation first
 ... //do stuff specific to B
 }
 }
</code></pre>

Update: In response to your comment on trying to access the implementation 2 levels up, here's a way of doing it.

<pre><code>class A {
 void foo() { 
 defaultFoo(); 
 }
 protected void defaultFoo() { ... }

}

class B extends A {
 void foo() {...}
}

class C extends B {
 void foo() {
 defaultFoo(); 
 ... //do other stuff
 }
}
</code></pre>

This is a healthier pattern of coding what you want to do.

blocks|key|1683946|text|为什么不让func()不被继承(称之为funcBase()或其他什么)，然后添加一个调用它的包装器func()函数？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1683947|class+A{
++++public+void+funcBase()+{
++++++++//+Base+implementation
++++++++}
++++public+void+func()+{
++++++++funcBase();
++++}
}

class+B+extends+A{
++++public+void+func(){+
+++++++++super.func();
+}
}

class+C+extends+B{
++++public+void+foo(){
+++++++++super.func();+++//+Call+B's+func
+++++++++funcBase();+++++//+Call+A's+func
++++}
}|code-block|syntax|javascript|1683948|我不知道你想做什么，但听起来你的类设计并不适合你想要的，所以你可能想在A中使用单独的函数，而不是偷偷摸摸地往上爬。|1683949|entityMap^0|5|6|J|A|1D|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Why don't you have <code>func()</code> be not inherited (call it <code>funcBase()</code> or whatever) and then add a wrapper <code>func()</code> function that calls it?

<pre><code>class A{
 public void funcBase() {
 // Base implementation
 }
 public void func() {
 funcBase();
 }
}

class B extends A{
 public void func(){ 
 super.func();
 }
}

class C extends B{
 public void foo(){
 super.func(); // Call B's func
 funcBase(); // Call A's func
 }
}
</code></pre>

I have no idea what you're trying to do, but it sounds like your class design is not appropriate for what you want, so you may want separate functions in A instead of trying to sneak your way up the ladder.

Say that I in Java have 3 classes, wheres the super one has a function named func(), I now make a subclass which overrides this, and a subclass to my subclass, now working on my sub-sub-class how will I call the 'func()' of the sub class, and the superclass?

I tried casting the 'this' "pointer", but Java 'fixes' it at runtime and calls the subsub func().

Edit:
Thanks everyone; 'Skeen is back at the drawing board'.

super.super.func()? - Java polymorphism

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

假设我在Java中有3个类，其中超级类有一个名为func()的函数，我现在创建了一个覆盖它的子类，以及我的子类的一个子类，现在正在处理我的子子类，我将如何调用子类和超类的“func()”？我尝试强制转换'this‘“指针”，但Java在运行时“修复”了它，并调用subsub func()。编辑:谢谢大家；“斯基恩又重新开始了”。

问super.super.func()？- Java多态性
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问super.super.func()？- Java多态性EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问super.super.func()？- Java多态性
EN