如何将实用程序函数应用于泛型类型的超类型参数
将实用程序函数应用于泛型类型的超类型参数可以通过使用泛型约束来实现。泛型约束允许我们指定泛型类型参数必须继承自特定的类或实现特定的接口。
在C#中，可以使用where关键字来指定泛型类型参数的约束。下面是一个示例：
public T DoSomething<T>(T input) where T : MyBaseClass
{
// 在这里可以使用 MyBaseClass 类的方法和属性
return input;
}在上面的示例中，DoSomething方法接受一个泛型类型参数T，并且要求T必须是MyBaseClass类或其子类。这样，在方法内部就可以使用MyBaseClass类的方法和属性。
除了类约束，还可以使用接口约束。例如：
public T DoSomething<T>(T input) where T : IMyInterface
{
// 在这里可以使用 IMyInterface 接口的方法和属性
return input;
}在上面的示例中，DoSomething方法要求泛型类型参数T必须实现IMyInterface接口。
通过使用泛型约束，我们可以确保在应用实用程序函数时，泛型类型参数具有特定的行为和功能。这样可以增加代码的可靠性和可维护性。
对于腾讯云相关产品和产品介绍链接地址，由于要求不能提及具体的云计算品牌商，我无法提供相关链接。但是，腾讯云提供了丰富的云计算服务，包括云服务器、云数据库、云存储等，可以根据具体需求选择适合的产品。
相关·内容
5回答
组合原始类型和泛型方法
、、、
这里有一个问题，第一个代码清单编译得很好(JDK 1.6 | JDK 1.7)：
ArrayList<String> a = new ArrayList<String>();
String[] s = a.toArray(new String[0]);
但是，如果我将List引用声明为原始类型：
ArrayList a = new ArrayList();
String[] s = a.toArray(new String[0]);
我得到一个编译器错误，告诉我String[]是必需的，但是找到了Object[]。
这意味着我的编译器将泛型方法解释为返回Object[]
浏览 31提问于2012-06-13得票数 28
回答已采纳
我将一个Java类转换为kotlin，并得到了上面提到的超类型的直接参数不允许错误投影 Java类是 public class RecipeViewHolder extends ParentViewHolder {
private static final float INITIAL_POSITION = 0.0f;
private static final float ROTATED_POSITION = 180f;
@NonNull
private final ImageView mArrowExpandImageView;
private T
浏览 19提问于2019-05-02得票数 1
回答已采纳
1回答
class A<E>{
}
class B<E> extends A{
}
public class WildInDeclare<E>{
public static void main(String[] args){
A<Integer> obj = new B<Integer>();
}
}
当我编译上面的程序时，我得到了这个错误。
Note: WildInDeclare.java uses unchecked or unsafe operations.
Note: Recompile with
浏览 0提问于2016-04-07得票数 0
4回答
第6行发生了什么？<C extends Cat>是useMe的返回类型，对吗？<? super Dog>是做什么的？
2. class Animal { }
3. class Dog extends Animal { }
4. class Cat extends Animal { }
5. public class Mixer<A extends Animal> {
6. public <C extends Cat> Mixer<? super Dog> useMe(A a, C c) {
7. //Some code
8. } }
浏览 1提问于2012-01-22得票数 2
回答已采纳
1回答
我知道我错过了什么，但这不应该有效吗？
public interface IFoo<out TA, in TB>
where TA : class
where TB : class
{
}
public class Foo<T> : IFoo<T, T> where T : class { }
public class Whatever { }
..。
Foo<Whatever> _Foo = new Foo<Whatever>(); // (changed "Foo" to "_Foo to
浏览 3提问于2015-03-31得票数 0
回答已采纳
我在Stack上寻找答案已经有一段时间了。所有的答案看起来都像是说我已经有了正确的答案，但我仍然在下面的构造函数的第一行中得到一个类强制转换异常。
SEVERE: Exception while loading the app : EJB Container initialization error
java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
at com.domain.security.logging.ElsAbstractCru
浏览 0提问于2012-07-21得票数 2
回答已采纳
1回答
我有三个类:抽象A和两个B和C类，它们扩展了A。
class A<T> {
ArrayList<T> someField;
A() {
someField = new ArrayList<T>();
}
ArrayList<T> getSomeField() { return someField; }
}
现在我有了B和C
class B<T> extends A {
B() {
super();
}
}
class C<T> extends A{
浏览 2提问于2014-03-31得票数 1
回答已采纳
以下是与Java中使用泛型的类型不匹配相关的几个问题，但我无法找到与我的情况相对应的任何内容。
我想知道为什么这个错误发生在下面的代码中？
类型不匹配:无法从元素类型对象转换为字符串
在队列中
for (字符串元素: arg.someMethod())
但是如果
SomeInterface arg
被更改为
SomeInterface<?> arg
它起作用了。如果列表参数类型没有连接到接口类型参数，为什么要删除它？
import java.util.List;
public class TypeMismatchExample
{
interface So
浏览 2提问于2014-05-15得票数 1
回答已采纳
这是关于一个令人费解的“不兼容类型”错误，这个错误是在编译下面的代码时产生的，经过很小的修改。
下面是一个极简主义类的内容，它在javac和IntelliJ中编译都没有问题：
public final class ChildClass extends ParentClass<Object> {
public void method() {
String value = stringList.get(0);
}
}
class ParentClass<T> {
protected final List<String>
浏览 1提问于2013-06-27得票数 3
回答已采纳
2回答
考虑这两个实例函数：
public <T> void f1 (List<? extends Object> a) {
System.out.println(a);
}
public void f2 (<? extends Object> a) {
System.out.println(a);
}
第一个函数被接受，第二个函数得到一个错误标记Syntax error on token "(", Type expected after this token。
我不明白为什么。有人能帮我吗？
编辑:让我重新表述所有。我有
浏览 2提问于2017-03-16得票数 0
回答已采纳
1回答
让我们假设我
// Foo.js
type PropsType = { cool: boolean };
class Foo extends React.Component<PropsType> {}
// Bar.js
import Foo from './Foo';
type PropsBar = { temp: string };
class Bar extends Foo {
test() {
this.props.cool; // there is no error
this.props.temp;
浏览 3提问于2017-11-23得票数 2
回答已采纳
我想为类开发定义一个必须是强类型且只允许类型的方法。
继承自使用没有参数的构造函数的类Dev。
以下是我得出的结论：
class Dev
{
public static void Interview<T>(T target) where T : Dev
{
}
}
另一种选择是：
class Dev
{
public static void Interview<T>(T target) where T : Dev, new()
{
}
}
不确定上面的任何内容是否
浏览 5提问于2022-06-01得票数 0
1回答
有以下例子：
public class A<S> {
public S id;
}
public class B extends A<String> {
B(){
this.id = "";
}
}
public class C<K> extends B {
public K property;
public static void main(String[] args) {
System.out.println(new C().id.substring(0,1));
}
}
new C().id
浏览 0提问于2018-09-12得票数 1
回答已采纳
我有以下代码：
List strings = new ArrayList<String>();
strings.add("string");
System.out.println(GenericTypeResolver.resolveTypeArguments(String.class, strings.getClass()));
它打印null。
我无法理解这个方法签名。
我想检查strings是否与String参数化。
如何正确使用resolveTypeArguments？
附注：
我的例子就是假的。
P.S.2
我知道spring可以用转换器接口做类似的事情。
浏览 2提问于2015-12-14得票数 0
回答已采纳
我觉得这完全令人费解。出于某些原因，在类型安全方面，javac似乎以不同的方式对待具有未指定泛型和<?>的引用。有没有人知道为什么会这样(Java1.6)？
public abstract class ClassWithGenericMember<GenMember> {
GenMember getMember() {
return (GenMember) null;
}
<GenReturn> GenReturn handle(Handler<GenReturn> handler) {
return handle
浏览 3提问于2013-05-16得票数 2
回答已采纳
1回答
有人能告诉我为什么会出现编译错误吗？我不明白为什么在第二个for循环中对A的强制转换会导致string()返回一个通用的对象列表。
import java.util.ArrayList;
import java.util.List;
public class E {
public static void main(String[] args) {
for (String s : new D().strings()) {
System.out.println("s = " + s);
}
for
浏览 0提问于2010-01-07得票数 5
回答已采纳
3回答
覆盖方法
、、
类subA是A类的子类，我试图重写一个方法，但不知怎么它不允许我重写它。为什么会这样呢？是因为参数中的参数吗？
错误信息：
名称冲突: subA中的add( E#2 )和A中的add(E#2)具有相同的擦除，但它们都不覆盖E#1、E#2是类型变量的其他变量：
E#1扩展了类subA中声明的对象
E#2扩展了A类中声明的对象
SuperClass A：
public class A <E> {
public void add(E toInsert) {...}
}
SubClass subA：
public class subA <E> extends
浏览 1提问于2013-06-02得票数 1
回答已采纳
为什么默认情况下将函数中的泛型类型替换为动态类型？
示例：
class Boo {
void displayType<int>() {
print('type int to string: $int');
print('type string to string: $String');
}
}
main() {
final boo = Boo();
boo.displayType();
}
产出：
type int to string: dynamic
type string to string: String
它的
浏览 5提问于2022-05-06得票数 0
1回答
出于好奇，我关注了SSCCE
import javax.ws.rs.Path;
@Path("/")
public class T {
void a() {
Path p = getClass().getAnnotation(Path.class); //1
Class z = getClass();
p = z.getAnnotation(Path.class); //2
}
}
编译器给出以下错误消息：
T.java:12: incompat
浏览 3提问于2012-04-17得票数 3
回答已采纳
在Java规范()中，new有以下形式：
ClassInstanceCreationExpression ::=
| new TypeArguments_opt TypeDeclSpecifier TypeArgumentsOrDiamond_opt
( ArgumentListopt ) ClassBodyopt
| Primary . new TypeArguments_opt Identifier TypeArgumentsOrDiamond_opt
( ArgumentListopt ) ClassBodyopt
新参数之后的第一个可选类型参数列表的目的是什么？我无法从
浏览 5提问于2013-09-08得票数 10
回答已采纳
4回答
请在通用铸造之后如何工作？
private <T, N> N send(final T request) {
final String serviceUrl = "someUri"
try {
return (N) webServiceTemplate.marshalSendAndReceive(serviceUrl, request);
} catch (final SoapFaultClientException e) {
}
}
当我像这样调用这个私有方法时：
MyReq request = new MyR
浏览 13提问于2014-08-05得票数 2
回答已采纳
我正在尝试使用类型安全方法EntityGraph.addAttributeNodes(Attribute<T, ?> ... attribute)来构造实体图。我有一个带有@MappedSuperclass的类型层次结构，基本上如下所示：
@MappedSuperclass
public abstract class BaseEntity
{
@Id
private int dbid;
}
@Entity
public class Entity extends BaseEntity
{
private String someAttribute;
}
Ecl
浏览 0提问于2015-08-07得票数 4
回答已采纳
2回答
Java继承和泛型
、、、
我试图用泛型扩展抽象类，但遇到了一个问题：
abstract public class SomeClassA<S extends Stuff> {
protected ArrayList<S> array;
public SomeClassA(S s) {
// ...
}
public void someMethod() {
// Some method using the ArrayList
}
abstract public void anotherMethod() {
// ...
}
}
现在我想用另
浏览 5提问于2011-04-07得票数 1
回答已采纳
为什么在第二个示例中没有编译错误，但是在第一个示例中有下面的编译错误？
SomeConcreateClass.java:1: ISomeBaseInterface cannot be inherited with different arguments: <java.lang.Object> and <>
public class SomeConcreateClass
^
1 error
在第二个示例中，惟一的差异类SomeDerivedClass不是参数化的。
Example1:
我是否正确地理解了在这个例子中
public class SomeConc
浏览 3提问于2011-12-09得票数 3
回答已采纳
Java 8的Java语言规范提供了一个带有类型参数的方法调用的示例，在“示例4.11-1.类型的使用”中：
<S> void loop(S s) {
this.<S>loop(s); // <S> is the the type argument for the method call.
}
在该示例中，提供的类型参数是有意义的，但显然方法调用的类型参数也可能是多余的，完全没有意义，甚至不需要涉及泛型。例如：
void m() { }
void test() {
m();
this.m();
this.<Inte
浏览 2提问于2015-08-28得票数 12
回答已采纳
下面我粘贴了我想运行的示例。
我可以很容易地获得StringHome实例的泛型类，它扩展了Home<String>，但是我不能对new Home<String>()实例这样做。我怎样才能得到它？
我的目标是使mainKO方法像mainOK一样工作。
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class Home<E> {
@SuppressWarnings ("unchecked")
public Cla
浏览 0提问于2016-07-01得票数 0
回答已采纳
6回答
在Java中，可以声明变量类型的数组，但我不能创建该数组。这不可能吗？
class ClassName<T> {
{
T[] localVar; // OK
localVar = new T[3]; // Error: Cannot create a generic array of T
}
}
浏览 0提问于2011-01-20得票数 4
回答已采纳
2回答
我有一个预定义的类，叫做
ParameterList<Recipient_Type,Subject_Type> {
//some code here...
}
它是通用的，可以接受收件人类型和主题类型。我有一个名为通信的对象，它具有用于设置不同类型的主题的setter方法，例如
correspondence.setSubject1((Subject1)subject)
correspondence.setSubject2((Subject2)subject).
以及用于设置不同类型的接收者的类似方法
correspondence.setRecipient1((Recipient1)
浏览 0提问于2011-10-04得票数 0
3回答
我不理解由以下代码导致的编译器错误。我用两个方法定义了一个通用接口，参见Task：U doSomething(String value)和List<Integer> getIDs()。doSomething()方法实际上使用泛型类型作为其返回值的类型，但似乎没有造成问题。getIDs()方法返回一个与任务类型无关的列表，但是当使用for..each语句对返回值进行迭代时，它会导致问题。发生下列编译器错误。
错误:不兼容类型(整数值: task.getIDs()){必需:整数查找: Object
接口上的类型擦除似乎导致编译器忘记了第二个方法上声明的类型，后者与泛型类型无关。
浏览 4提问于2013-06-19得票数 14
回答已采纳
我有一个通用功能：
function mkSorter<T extends { [key: string]: unknown }, K extends keyof T>(prop: K) {
return (a: T, b: T) => a[prop] - b[prop];
}
如何将属性值设置为number的另一个约束，以便使prop: keyof T和T[K]: number
更新：
为了以这种方式使用它：
type SomeObjectType = {
number: number;
alsoNumber: number;
string: string;
浏览 4提问于2021-04-02得票数 0
为什么不是原始类型，泛型类中的静态变量？
例如，
public class MyType<E> {
class Inner { }
static class Nested { }
public static void main(String[] args) {
MyType mt; // warning: MyType is a raw type
MyType.Inner inn; // warning: MyType.Inner is a raw type
MyType.Nest
浏览 0提问于2013-10-18得票数 4
1回答
为什么会发生这种事。如果我通过匿名泛型类来类型确定方法--一切都是好的。但是如果我在这个方法中传递对象-控制台输出是E。
public static void main(String[] args) {
printType(new ArrayList<Integer>() {});
printType(new ArrayList<Integer>());
}
public static void printType(final List<?> list) {
System.out.println(((ParameterizedT
浏览 1提问于2013-09-27得票数 5
回答已采纳
我刚了解到这个
Collections.<String>emptyList()
获得一个空的List，其中的元素应该是String类型的。Java的源代码如下所示：
public static final List EMPTY_LIST = new EmptyList<Object>();
:
public static final <T> List<T> emptyList() {
return (List<T>) EMPTY_LIST;
}
现在，如果在参数列表中不显示泛型类型的情况下，以这种方式编写方法，那么是否可以访问成为
浏览 6提问于2011-12-08得票数 9
回答已采纳
1回答
Scala匿名函数一般方差问题
、、、、
我在学习Scala的路上，我很难理解逆变、协变、不变性等。从中，我学到了如何将函数视为另一个函数的子类型。(知道这点真的很有用！)
下面的代码是我认为是解决我的难题的重要部分。我已经提取了一些我认为会给问题增加不必要复杂性的部分。根据示例，我有一个Student对象，它将作为一个工厂来生成函数。
函数将接受AnyVal的类型或子句(Int、Double、Long等)，并且返回的输出将是相同的输入类型。为此，学生类接受一个泛型(A)，它是AnyVal的一个子类型。抽象类在那里，所以我可以通过执行类似List的操作来引用这些学生的列表。
问题是我不能有行"val function: Lis
浏览 4提问于2013-09-08得票数 0
我刚刚遇到了一个不可能的泛型方法。似乎我不能编写一个接受JavaFX过滤列表和谓词的方法，并简单地将过滤列表谓词与传入的谓词进行and运算。唯一的方法是强制转换(在某些情况下会导致ClassCastException )，或者使用原始类型。我不认为java能代表<? super <? super String>>。如果我漏掉了什么，有人能发现吗？
import javafx.collections.transformation.FilteredList;
import java.util.function.Predicate;
public class Test {
浏览 2提问于2017-09-22得票数 1
2回答
我在下面的代码中遇到了一个奇怪的问题。
Map<String, Object> map = new HashMap<String, Object>();
for(Entry<String, Object> entry : map.entrySet()) {
//
}
而下面的代码不能编译。
Map map = new HashMap();
for(Entry entry : map.entrySet()) { // compile error here
//
}
有什么线索吗？
浏览 1提问于2011-08-28得票数 8
回答已采纳
class HasId<I> {}
class HasStringId extends HasId<String> {}
class Alert<T extends /*Some*/Object> extends HasStringId {}
class BaseController<M extends HasId<String>> {
// abstract Class<M> getModelClass();
}
class AlertController extends BaseController<Al
浏览 8提问于2013-03-11得票数 8
我知道有一个类似的，但答案是告诉我如何做，但不是reason.And，我有另一种方法来创建，但我不知道为什么
public class testForGeneric<T> {
public testForGeneric(T[] a) {
int len = a.length;
Node<T>[] nodes = new Node<T>[len];//THE PROBLEM!
for (int i = 0; i < len; i++)
nodes[i] = new No
浏览 0提问于2019-04-19得票数 0
2回答
我是半懂Java的，并且在Groovy中尝试一些东西。
是否可以在Groovy/Java中使用以下内容：
public class A {
}
public class B {
}
public class C<Ta extends A, Tb extends B> extends Ta {
public Ta[] bArray;
public Tb[] getAllBs()
{
Tb[] ret = new Tb[0];
....
return ret;
}
}
以上定义不显示任何错误。但是，当我试图使用C作为另一种类
浏览 1提问于2017-08-12得票数 1
回答已采纳
我创建了一个可重现的。
我的问题是:如何用react-final-form修复这个打字错误
错误是：
Type '{ name: string; onBlur: (event?: FocusEvent<HTMLElement>) => void; onChange: (event: any) => void; onFocus: (event?: FocusEvent<HTMLElement>) => void; type?: string; value: T; checked?: boolean; multiple?: boolean; }&#
浏览 1提问于2020-07-21得票数 1
3回答
Java编译器忽略类型安全
、、、、
public class POJO<T> {
private List<Integer> integer = new ArrayList<Integer>();
public POJO() {
integer.add(1);
integer.add(2);
}
public List<Integer> getInteger() {
return integer;
}
public static void main(String[] args)
浏览 0提问于2012-08-31得票数 7
回答已采纳
3回答
对不起，我想不出一个更简洁的标题了。
我的问题是，为什么下面的代码可以工作：
public abstract class TObjectPool<T> {
protected Object[] availableObjects;
TObjectPool(int size){
availableObjects = new Object[size];
}
protected class RenderElementPool extends TObjectPool<RenderElement>{
@Override
public void fill(
浏览 3提问于2011-06-06得票数 6
回答已采纳
2回答
最近，我遇到了一个不寻常的Java语法.下面是一个例子：
List list = new <String, Long>ArrayList();
注意<String, Long>类型参数的位置.它不是像往常一样在类型之后，而是在前面。我不介意承认我以前从未见过这种语法。还请注意，当ArrayList只有1时，有2个类型的参数。
类型参数的位置是否与将它们放在类型后面具有相同的意义？如果没有，不同的定位意味着什么？
为什么在ArrayList只有1的情况下有两个类型的参数是合法的？
我已经搜查了通常的地方。Angelika和这里，但是除了ANTLR项目的Java语法文件中的
浏览 0提问于2019-03-25得票数 132
回答已采纳
3回答
我通常尝试将流函数类型与它们的实现分开。当我写到：
type Fn = string => string;
const aFn: Fn = name => `hello, ${ name }`;
而不是：
const aFn = (name: string): string => `hello, ${ name }`;
当使用泛型类型时，我们可以编写：
const j= <T>(i: T): T => i;
const jString: string = j('apple'); // √
const jNumber: number = j(
浏览 6提问于2017-10-05得票数 12
回答已采纳
如何获得应用于TypeScript中参数的泛型函数的类型？
例如，我如何在下面定义Apply？
declare function f<T>(t: T): T extends number ? boolean : object;
type ResForNumArg = Apply<typeof f, number>; // should be boolean
type ResForStringArg = Apply<typeof f, object>; // should be object
如果无法做到这一点，您可以通过创建一个类型别名来解决特定情
浏览 1提问于2020-03-04得票数 3
回答已采纳
我试图将JSON对象的字符串表示解析为映射列表。json对象的结构如下所示：
[
{
"first_name": "fname1",
"last_name": "lname1"
},
{
"first_name": "fname2",
"last_name": "lname2"
}
.
.
.
]
唯一已知的是字符串值(例如"first_name“、"last_name")在运行时仅使用，因此我不能
浏览 0提问于2012-12-03得票数 1
为什么编译器会报告以下代码的错误？
class B<T, U> {
T t; U u;
public B(T t, U u) { this.t = t; this.u = u; }
public T getT() { return t; }
public U getU() { return u; }
}
class D<T> extends B<T, String> {
public D(T t, String u) {
super(t, u);
}
}
public static void main(String[] ar
浏览 3提问于2014-01-20得票数 1
回答已采纳
2回答
如果在Java中将泛型类的实例声明为原始类型，那么编译器是否为所有类成员方法假定参数化的Object类型？这是否扩展到那些返回具体参数化类型的某种形式(例如Collection)的方法？
我错误地声明了一个没有参数化类型的泛型类的实例，这导致了非常有趣的下游效应。我提供了一个简单的场景示例，它产生了一个“不兼容类型”编译错误。我的基本问题是:为什么javac会产生一个“不兼容类型”错误，抱怨下面所示的行？
import java.util.*;
public class Main {
public static void main(String[] args) {
fi
浏览 5提问于2014-04-22得票数 5
回答已采纳
HashMap<String, Set<String>> foo = new HashMap<>();
if (foo.getClass().equals(HashMap.class)) {
System.out.print(true);
}
以上代码打印真。为什么这两种类型比较相等？对我来说，foo.getClass()比HashMap.class.包含更多的类型信息。
浏览 0提问于2018-09-12得票数 0
回答已采纳
1回答
为了解决这个问题，下面是我的泛型类。
[ComVisible(true)]
public class HtmlTable<T> where T : class
{
List<T> listToConvert;
public HtmlTable(List<T> listToConvert)
{
this.listToConvert = listToConvert;
}
}
本质上，这个类负责将类T的列表转换为HTML表(我省略了生成部分)，我得到的.The错误是
Generic classes may not
浏览 5提问于2010-01-06得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
