blocks|key|1825095|text|你不能实例化一个接口，所以你永远不能创建一个来发送的接口。您可以在函数的参数中指定一个接口，并且只能传递实现该接口的对象。但是没有办法要求接口是传入的，因为您不能创建它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1825096|我认为你需要重新考虑你想要实现的目标。|1825097|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|$]]

You can't instantiate an interface so you would never be able to create one to send in. You can specify an interface in the parameters for the function and only objects which implement that interface can be passed in. But there is no way to require an interface be what is passed in because you can't create them.

I think you need to rethink what you're trying to accomplish.

blocks|key|525489|text|要仅接受实现接口的对象作为参数，请使用接口作为类型，即：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|525490|void+acceptMaps(Map+argument)+{
}|code-block|syntax|javascript|525491|可以使用实现Map接口的对象(如HashMap+)调用，但不能使用String调用，因为它们不实现Map。|offset|length|style|CODE|525492|这就是你提问的意思吗？|525493|编辑在此示例中，实现扩展Map的SortedMap的对象也被接受，因此在您的示例中，您可以创建一个BaseInterface，并在您希望被.register(BaseInterface+arg)方法接受的接口(如AcceptedInterface+extends+BaseInterface)中扩展它。|BOLD|525494|entityMap^0|0|0|6|3|G|7|X|6|1D|3|0|0|0|2|C|3|G|9|1D|D|1X|S|2Y|13|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@$I|W|J|X|K|L]|$I|Y|J|Z|K|L]|$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|15|8|@$I|16|J|17|K|Q]|$I|18|J|19|K|L]|$I|1A|J|1B|K|L]|$I|1C|J|1D|K|L]|$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|S|$]]

To accept only objects that implement an interface as argument, use the interface as type, i.e.:

<pre><code>void acceptMaps(Map argument) {
}
</code></pre>

can be called with objects implementing the <code>Map</code> interface, like <code>HashMap</code> but not with <code>String</code>s for instance as they do not implement <code>Map</code>.

Is this what you meant with your question?

Edit in this example, objects implementing <code>SortedMap</code> which extends <code>Map</code> are accepted too, so in your case you could create a <code>BaseInterface</code> and extend that in the interfaces (like <code>AcceptedInterface extends BaseInterface</code>) you want to be accepted by your <code>.register(BaseInterface arg)</code> method.

blocks|key|517687|text|您可以询问您在运行时实现的对象的接口的类。如果您不能为编译器提供您期望的接口类型，它就无法预测将传递到您的方法中的内容，因此您必须使用运行时反射。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|517688|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 can ask the class of the object you get interfaces it implements during runtime.
If you can't already give the compiler the types of the interfaces you expect it has no way to predict what is going to be passed into your method so you will have to use runtime reflection.

blocks|key|517735|text|没有办法在运行时检查“对象是不是接口”，因为对象永远不能是“接口”，它只是一个实现接口的类的实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|517736|而且不可能将方法签名限制在接口使用上，比如您将允许类型“animal”，但不允许类型“Dog”实现动物行为。(我猜这就是你要找的东西)|517737|以您的示例为例-您希望在此实现中出现编译器错误：|517738|interface+ISomething+{...}+
class+A+implements+ISomething+{+...+}
ISomething+something+=+new+A();+
MyClass.register(something);

A+unwanted+=+(A)+something;
MyClass.register(unwanted);+//+<-+compilation+error+here|code-block|syntax|javascript|517739|但实际上说出来了--我看不出有什么直接的理由。如果您想强制程序员使用接口-用户代码检查或质量检查工具。如果要限制实现的实例化，请保护构造函数并使用工厂来生产实例。|517740|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

There's no way to check at runtime, if the 'object is an interface' because an object can never ever be 'an interface', it only be an instance of a class that implements an interface.

And it's not possible to restrict a method signature to interface usage, say you'll allow type 'Animal' but not type 'Dog' which implements animal behavior. (I guess that's what you were looking for)

Taking your example - you want a compiler error for this implementation:

<pre><code>interface ISomething {...} 
class A implements ISomething { ... }
ISomething something = new A(); 
MyClass.register(something);

A unwanted = (A) something;
MyClass.register(unwanted); // &lt;- compilation error here
</code></pre>

But practically spoken - I see no immediate reason. If you want to enforce programmers to use interfaces - user code inspection or quality check tools. If you want to restrict instantiation of an implementation, protect the constructor and use a factory to produce instances.

blocks|key|1925240|text|您正在区分对象的类型(在本例中为A)和对对象的引用类型(在本例中为ISomething)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1925241|听起来你想要允许这段代码：|1925242|ISomething+something+=+new+A();+
MyClass.register(something);|code-block|syntax|javascript|1925243|但禁止以下代码：|1925244|A+something+=+new+A();+
MyClass.register(something);|1925245|我不认为你可以用Java来实现这一点。|1925246|entityMap^0|G|1|X|A|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

You're making a distinction between the type of the object (in this case <code>A</code>) and the type of the reference to the object (in this case <code>ISomething</code>).

Sounds like you want to permit this code:

<pre><code>ISomething something = new A(); 
MyClass.register(something);
</code></pre>

but forbid this code:

<pre><code>A something = new A(); 
MyClass.register(something);
</code></pre>

I don't think you can achieve this with Java.

blocks|key|517823|text|“对象是一个接口”没有任何意义。看起来您想强制传递给函数的指针是用如下接口类型声明的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|517824|Interface_t+x+=+new+Class_which_implements_interface_t();|code-block|syntax|javascript|517825|而不是|517826|Class_which_implements_interface_t+y+=+new+Class_which_imlements_interface_t();|517827|唯一的问题是，如果你像这样做一个函数：|517828|void+some_func(Interface_t+z)+{...}|517829|你用some_func(x);或some_func(y);调用它，这个函数是通过值传递引用的，这意味着在some_func内部，z是x或y的副本，它被强制转换为Interface_t指针。没有办法获得关于原始指针的类型的信息。只要它能够被转换为Interface_t，它就会被编译和运行。|offset|length|style|CODE|517830|entityMap^0|0|0|0|0|0|0|2|D|G|D|1G|9|28|B|3E|B|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]|$Q|15|R|16|S|T]|$Q|17|R|18|S|T]|$Q|19|R|1A|S|T]|$Q|1B|R|1C|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|V|$]]

"The object is an interface" doesn't make sense. It seems like you want to enforce that the pointer passed into the function was declared with an interface type like

<pre><code>Interface_t x = new Class_which_implements_interface_t();
</code></pre>

as opposed to

<pre><code>Class_which_implements_interface_t y = new Class_which_imlements_interface_t();
</code></pre>

The only problem is that if you make a function like this:

<pre><code>void some_func(Interface_t z) {...}
</code></pre>

And you call it with <code>some_func(x);</code> or <code>some_func(y);</code> the function is passing the reference by value, which means that inside of <code>some_func</code>, z is a copy of x or y which has been casted to an <code>Interface_t</code> pointer. There is no way to get information about what type the original pointer had. As long as it is able to be casted to an <code>Interface_t</code> it will compile and run.

I need to write a function that accepts an object , but I want to enforce in the function call (not after the function is called) that the object is an interface.

Meaning , I want to make sure this is an Interface at compile time , not on run time. 

What do I mean? 

<pre><code>interface ISomething {...} 
class A implements ISomething { ... }
ISomething something = new A(); 
MyClass.register(something);
</code></pre>

In this example , the passed object is an interface , and I want that the MyClass.register function to enforce the this requirment in it's declaration. 

I don't know which interface I'm going to get , and there is no use defining another interface to be implemented by all other implementation , because I need the real interface.

Java : How to create a function that can only accept object which is an Interface?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我需要编写一个接受对象的函数，但我希望在函数调用中(而不是在函数被调用之后)强制该对象是一个接口。这意味着，我希望确保这是编译时的接口，而不是运行时的接口。我是什么意思？interface ISomething {...} class A implements ISomething { ... }ISomething ...

问Java :如何创建一个只能接受作为接口的对象的函数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java :如何创建一个只能接受作为接口的对象的函数？EN