blocks|key|814228|text|这是对接口(或超类型)进行编程的概念，我们使用超类型引用，以便它可以容纳任何子类型实例|type|unstyled|depth|inlineStyleRanges|entityRanges|data|814229|例如:假设我们有扩展A的B&C类|814230|接受A作为参数的某些方法(&S)|814231|无效打印(A+a)+{System.out.println(a);}|814232|可以通过传递A或其子类型的任何实例来调用此方法|814233|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

This is the concept of programming to interfaces(or supertype)
we use supertype reference so that it can hold any sub type instance

eg: assume we have Class B &amp; C extending A

&amp; some method which accepts A as parameter

void print(A a) {System.out.println(a);}

this method canbe invoked by passing any instance of A or its subtype

blocks|key|3163451|text|因为如果C是A的一个子类型，你可以这样说|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3163452|myClassA+=+new+C();|code-block|syntax|javascript|3163453|并且您的代码仍将按预期工作。|3163454|entityMap^0|4|1|6|1|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]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Because then if <code>C</code> is a subtype of <code>A</code>, you can say

<pre><code>myClassA = new C();
</code></pre>

and your code would (should) still work as intended.

blocks|key|5060553|text|您可以稍后将A实例分配给myClassA。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5060554|entityMap^0|6|1|C|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

That you may assign an instance of <code>A</code> to <code>myClassA</code> later.

blocks|key|5060590|text|原因是，如果B扩展了A，但所有公开的API都是在A中定义的，那么您可以将对象视为A，而不需要知道它的真实类型。如果将来，您可能会添加另一个扩展A的实现C，并且可能会开始同时使用C和B，但您不必更改使用这些对象的代码，因为它将它们视为A。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5060591|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|$]]

The reason is that if B extends A but all exposed API is defined in A you can treat the object as A without knowing its real type. If future you will probably add yet another implementation C that extends A as well and will probably start using C and B together but you will not have to change the code that uses these objects because it treats them as A.

blocks|key|4778615|text|Program+to+interface,+not+an+implemenation。例如,|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4778616|A+myClassA+=+new+B();+|code-block|syntax|javascript|4778617|在这里，您可以更改实现new+C()，而不会影响现有代码，因为您刚刚公开了接口。|4778618|A+myClassA+=+new+C();|4778619|或|4778620|A+myClassA+=+getClassATypeInstance();|4778621|entityMap^0|0|16|0|0|B|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

<code>Program to interface, not an implemenation</code>. 
For example,

<pre><code>A myClassA = new B(); 
</code></pre>

Here you can change the implementation, <code>new C()</code> without affecting the existing code since you just exposed the interface.

<pre><code>A myClassA = new C();
</code></pre>

or

<pre><code>A myClassA = getClassATypeInstance();
</code></pre>

blocks|key|4778645|text|Collections+API就是一个很好的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4778646|看看java.util.Collections的静态"min“方法。参数类型是"Collection“，很多类都实现了这个接口。您可以从ArrayList+(实现列表扩展集合)或HashMap的值(HashMap.values()返回集合接口的私有实现)中获取min。|4778647|如果java.util.Collections.min()的参数类型为ArrayList，则不能使用该方法获取HashMap的最小值。|4778648|如果不需要通过子类型获得的其他方法，则使用基类型声明变量和参数。|4778649|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

A good example is the Collections API.

Look at the static "min" method of java.util.Collections.
The Parameter type is "Collection" and a lot of classes implement this interface.
You may get the min from a ArrayList (implements List extends Collection) or the values of a HashMap (HashMap.values() returns a private implementation of the Collection interface).

If the java.util.Collections.min() has a ArrayList as parameter type you couldn't use the method to get the minimum value of a HashMap.

Declare your variables and parameters with the basetype if you don't need the additional methods you get through the Subtypes.

blocks|key|4778684|text|一个很好的例子就是形状。假设我们有两个形状，一个圆形和一个正方形。两者都有不同的属性，但我们可以得到两者的面积。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4778685|public+abstract+class+Shape+{
++++public+abstract+float+area();
}

public+class+Circle+extends+Shape+{
++++private+float+radius;

++++public+Circle(float+radius)+{
++++++++this.radius+=+radius;
++++}

++++@Override
++++public+float+area()+{
++++++++return+Math.PI+*+radius+*+radius;
++++}
}

public+class+Square+extends+Shape+{
++++private+float+width;
++++private+float+height;

++++public+Square+(float+width,+float+height)+{
++++++++this.width+=+width;
++++++++this.height=+height;
++++}

++++@Override
++++public+float+area()+{
++++++++return+width+*+height;
++++}
}|code-block|syntax|javascript|4778686|现在，这个实现允许计算所有形状的面积，而不管它们是什么类型。例如，您可以拥有一个形状数组并对其进行迭代，调用每个形状的面积函数并将面积相加。|4778687|人们应该总是把正确的信息放在正确的类中。圆和正方形都有面积，其他形状也有面积，所以可以放心地假设面积是形状的属性，也就是说，圆有面积是因为它们是形状。|4778688|将它放在类层次结构中的较低位置，可以使您的代码具有健康的抽象级别。它变成了一种“需要知道的基础”的-principle，在这种情况下，你永远不应该访问更多你现在需要的代码。另一个经验法则是编写代码，这样你总是从子类型转换到基类型，而不是从子类型转换到基类型(这比听起来难得多)。|4778689|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A good example is always that of shapes. Let's say we have two shapes, a circle and a square. Both have different properties, but we can get the area of both.

<pre><code>public abstract class Shape {
 public abstract float area();
}

public class Circle extends Shape {
 private float radius;

 public Circle(float radius) {
 this.radius = radius;
 }

 @Override
 public float area() {
 return Math.PI * radius * radius;
 }
}

public class Square extends Shape {
 private float width;
 private float height;

 public Square (float width, float height) {
 this.width = width;
 this.height= height;
 }

 @Override
 public float area() {
 return width * height;
 }
}
</code></pre>

Now what this implementation allows, is to calculate the area of all shapes regardless of what types they are. You can for instance have an array of Shapes and iterate over them, calling the area function of each shape and summing the areas up.

One should always put the right information in the right class. Circles and squares both have areas, and so does other shapes to, so it is safe to assume that area is a property of a shape, i.e. circle's have an area because they are shapes.

Putting it lower in the class hierarchy gives your code a healthy level of abstraction. It becomes sort of a "need-to-know-basis"-principle, where you should never have access to more code that you need at the moment. Another rule of thumb is to code so that you always cast from subtype to base, and never the other way around (which is a lot harder than it sounds).

Assume that class B extends from class A.

So what is the advantage of writing something like this:

<pre><code>A myClassA = new B();
</code></pre>

What's the difference to:

<pre><code>B myClassA = new B();
</code></pre>

Java: What's the reason to write Supertype a = new Subtyp()`?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯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编辑器全新改版上线，欢迎大家体验!

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

社区新版编辑器体验调研

假设B类从A类扩展而来。那么，编写这样的代码有什么好处：A myClassA = new B();与以下内容有什么区别：B myClassA = new B();

问Java:为什么要写Supertype a= new Subtyp()`？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:为什么要写Supertype a= new Subtyp()`？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java:为什么要写Supertype a= new Subtyp()`？
EN