泛型:T扩展MyClass vs. T扩展MyClass <T>
泛型是一种编程语言的特性，它允许在定义类、接口或方法时使用一个或多个类型参数，以便在使用时可以指定具体的类型。泛型的目的是增加代码的重用性、类型安全性和可读性。
T扩展MyClass是指在定义MyClass类时，使用泛型类型参数T，并在类的成员方法或属性中使用T作为类型。这样，在使用MyClass时，可以根据具体的需求指定T的类型，从而实现对不同类型的数据进行处理。
T扩展MyClass <T>是指在定义MyClass类时，使用泛型类型参数T，并在类的成员方法或属性中使用T作为类型。与上述情况不同的是，这里的T是一个具体的类型参数，而不是一个占位符。这样，在使用MyClass时，必须指定T的具体类型，否则会编译错误。
对于这两种情况，它们的应用场景和优势如下：
- T扩展MyClass：
- 应用场景：当需要在一个类中处理多种类型的数据时，可以使用泛型来增加代码的重用性和灵活性。
- 优势：可以避免代码的重复编写，提高代码的可维护性和可读性。同时，由于类型参数T的灵活性，可以在使用时根据具体的需求指定T的类型，从而实现对不同类型的数据进行处理。
- T扩展MyClass <T>：
- 应用场景：当需要在一个类中处理特定类型的数据时，可以使用具体的类型参数T来限定数据的类型。
- 优势：可以在编译时对数据的类型进行检查，避免类型错误的问题。同时，由于指定了具体的类型参数T，可以在使用时直接使用T作为类型，而不需要再进行类型转换，提高了代码的效率和可读性。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数（云原生、服务器运维）：https://cloud.tencent.com/product/scf
- 腾讯云数据库（数据库）：https://cloud.tencent.com/product/cdb
- 腾讯云CDN（网络通信）：https://cloud.tencent.com/product/cdn
- 腾讯云安全产品（网络安全）：https://cloud.tencent.com/solution/security
- 腾讯云音视频处理（音视频、多媒体处理）：https://cloud.tencent.com/product/mps
- 腾讯云人工智能（人工智能）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（物联网）：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发（移动开发）：https://cloud.tencent.com/product/mobdev
- 腾讯云对象存储（存储）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（区块链）：https://cloud.tencent.com/product/baas
- 腾讯云虚拟专用网络（网络通信）：https://cloud.tencent.com/product/vpc
- 腾讯云容器服务（云原生）：https://cloud.tencent.com/product/ccs
- 腾讯云云服务器（服务器运维）：https://cloud.tencent.com/product/cvm
相关·内容
4回答
为什么我要这样做呢？
public <T> void myMethod(MyClass<T> value){
}
为什么我必须提到<T>两次？
浏览 3提问于2013-01-05得票数 1
回答已采纳
6回答
在这个例子中，我得到了"List是一个原始类型“的警告。如何使用泛型来正确地满足此警告？我遇到了麻烦，因为我不知道如何为全局变量定义"T“，就像为构造函数签名那样。
public class MyClass{
private List input;
public <T extends Comparable<T>> MyClass(List<T> input){
this.input = input;
}
}
浏览 2提问于2015-03-12得票数 2
回答已采纳
1回答
具有不常见泛型类型的接口列表
、、、、
我知道Java能够创建for容器。不需要指定类型的泛型整数。这在c#中是可能的吗？
public interface Interface1<T>{
void ProcessModel(T source);
}
public class Implement : Interface1<ModelClass>{
.....implementation
}
我需要实例化一些像这样的容器
public List<Interface1> temp = new List<Interface1>();
而不是这个
public List<
浏览 2提问于2016-01-11得票数 1
回答已采纳
2回答
在Java中，是否可以让类扩展泛型类型，以便可以将方法注入通过代码传递的任何类中？(或者，有没有其他方法可以用Java将方法注入或覆盖现有类？)
我的意思是“扩展泛型类型”是这样的(类"T扩展GameObject“属于游戏，可能不会改变，也是未知的，因为在运行时(从其他mods)加载到游戏中)：
class GameObject {
void moveForward(float amount) {
this.camera.z += amount;
}
}
class Extender<T extends GameObject> extend
浏览 1提问于2013-01-25得票数 3
回答已采纳
1回答
我确实注意到了静态和非静态内部异常类的奇怪行为。
例如，以下代码将无法编译：
public class MyClass<T> {
private class MyInnerException extends Exception { // won't compile
..
}
}
但是下面的代码可以编译：
public class MyClass<T> {
private static class MyInnerException extends Exception { // will compile
..
}
}
浏览 0提问于2019-12-18得票数 5
我已经写了一个小的异步函数来帮助我以两个元素的数组的形式返回Promises结果。 我的函数是 /* will.js */
const will = async (result) => {
try {
const result = await funcResult;
return [null, result];
}
catch (err) {
return [err, null];
}
}
export default will;
/* any-file.js */
import will from './will';
fu
浏览 42提问于2019-09-11得票数 1
回答已采纳
我有这个类的定义 class abstract MyClass<T> { } ，它可以用作 class MyOtherClass extends MyClass<IInterface> { } 然而，我想限制这个类与所有简单类型的使用： class MyOtherClass extends MyClass<string> { } //<-- do not allow 或 class MyOtherClass extends MyClass<nubmer> { } //<-- do not allow 基本上我只想让T成为一个复杂对
浏览 4提问于2020-07-27得票数 1
回答已采纳
public class MyClass<T> extends T {...}
以上声明将无法使用错误进行编译：
error: unexpected type
class MyClass<T> extends T {}
^
required: class
found: type parameter T
where T is a type-variable:
T declared in class MyClass
我真的想不出发生这种情况的原因，所以我想知道是否有人能说明为什么Java不允许您继承
浏览 0提问于2018-06-09得票数 4
回答已采纳
2回答
我不知道我是否从正确的角度来处理这个问题，但无论哪种方式，我都找不到有效的语法。
我想把3个泛型类型传递给一个方法--从那里我会在需要的时候使用反射来创建对象。但是，我传递的对象本身是泛型的。
这听起来有点像嵌套泛型。
假设我创建了一个接口：
public interface IAgent<TRequest, TClient, TResponse>
{
}
我有一个这样的类，它实现了IAgent：
public class MyClass : IAgent<?>
然后我想调用一个类似如下的方法：
public method MyMethod<
浏览 16提问于2015-04-22得票数 0
使用类型记录3.0+。请参见以下涉及泛型类型变量的简单设置：
abstract class BaseClass {
public abstract merge<T>(model?: T): T;
}
class MyClass extends BaseClass {
public Value: string;
public merge<MyClass>(model?: MyClass): MyClass {
this.Value += model.Value; // <--Property 'Value' does not
浏览 0提问于2018-09-18得票数 0
回答已采纳
1回答
我想重构这个类以处理更多类型的对象
public class MyClass : IMyClass
{
public void method()
{
IT obj= new ConcreteObject();
//Some code
}
}
这方面：
public class MyClass<T> : IMyClass
where T: IT, new()
{
public void method()
{
IT obj= new T();
//Some code
}
}
因为现在新的ConcreteObject中有更
浏览 1提问于2017-01-05得票数 0
回答已采纳
我有一个泛型类，但我希望强制我的类型从一个或另一个接口继承。例如：
public class MyGeneric<T> where T : IInterface1, IInterface2 {}
上面的代码将强制T同时从IInterface1和IInterface2继承，但我可以强制T从IInterface1或IInterface2 (或两者)继承吗？
浏览 0提问于2009-02-08得票数 2
回答已采纳
3回答
我有一个定义如下的TreeNode类：
class TreeNode<T extends MyClass> {
public T element;
public TreeNode<? extends MyClass> parent;
public ArrayList<TreeNode<? extends MyClass>> children;
}
我想知道是否有更简单的方法将所有TreeNodes限制为扩展MyClass的泛型类型变量？必须写出ArrayList<TreeNode<? extends MyCla
浏览 0提问于2013-03-01得票数 2
回答已采纳
4回答
有没有可能在C#中这样做：
public void DoSomething<T>(T t)
{
if (T is MyClass)
{
MyClass mc = (MyClass)t
...
}
else if (T is List<MyClass>)
{
List<MyClass> lmc = (List<MyClass>)t
...
}
}
浏览 0提问于2010-01-05得票数 77
回答已采纳
类中的两个方法是否“混淆”在下面？
class MyClass
{
public override string ToString()
{
return "I am confused now";
}
}
class Confused
{
public MyClass GetMyClass()
{
return new MyClass();
}
public T GetMyClass<T>() where T : MyClass, new()
{
浏览 2提问于2011-07-14得票数 4
回答已采纳
我希望在以下两个扩展方法声明与何时使用一个扩展方法声明之间存在技术上的区别：
public static void DoSomething(this MyClass theObject)
vs
public static void DoSomething<T>(this T theObject) where T : MyClass
例如，我知道将它与继承自MyClass类的类的对象一起使用是有区别的，但我不知道为什么。
浏览 0提问于2018-07-04得票数 0
回答已采纳
如果我需要编写一个类来处理“可比较”类型的数据，我可以用两种方法来实现：
1)
public class MyClass<T extends Comparable>
{
private T value;
MyClass(T value)
{
this.value = value;
}
other code...
}
2)
public class MyClass
{
private Comparable value;
MyClass(Comparable value)
{
浏览 4提问于2011-05-30得票数 3
回答已采纳
5回答
我想定义一个泛型类型，它的实际类型参数只能是
一个数字基元包装类(Long、Integer、Float、Double)
String
我可以用这样的定义来满足第一个要求
public final class MyClass<T extends Number> {
// Implementation omitted
}
但我想不出怎么才能见到他们俩。我怀疑这实际上是不可能的，因为AFAIK在定义形式类型参数时无法指定“或”语义，尽管您可以使用定义来指定“和”语义，例如
public final class MyClass<T extends Runnab
浏览 2提问于2008-12-11得票数 8
4回答
我有一个方法，我想将这个方法作为扩展方法添加到我的类的属性中。这个方法给出一个表达式作为输入参数。方法如下：
public static string GetPropertyName<T>(Expression<Func<T>> propertyExpression)
{
return (propertyExpression.Body as MemberExpression).Member.Name;
}
我想像下面的例子一样使用这个方法：
string propertyName = MyClass.Property1
浏览 0提问于2011-05-18得票数 4
回答已采纳
4回答
泛型列表打印方法
、、
我正在尝试编写一个通用的print方法，它适用于实现"Iterable“接口的所有类
public class List<T> {
public static <T extends Iterable<T>> void print(T[] list){
for (Object element : list){
System.out.println(element);
}
}
public static void main(String[] args){
A
浏览 4提问于2014-01-07得票数 8
2回答
整数的HashSet
、、、、
public class MyClass<Integer> extends AnotherOne<Integer> {
public MyClass(HashSet<Integer> ar) {
super(ar);
}
}
AnotherOne是一个抽象(泛型)类，其构造函数将HashSet<T>作为参数。然后，它有另一个方法，它使用T类型作为其参数。
一切都很好，但我必须使用Integer作为参数来覆盖该方法，而使用Integer而不是int似乎很奇怪。有没有一种使用原语int的方法？
浏览 4提问于2014-02-06得票数 1
回答已采纳
4回答
对于许多人来说，这将是泛型101，但下面是示例代码，这样我就可以更好地理解。
public interface IRecordedItemsProcessor<T>
{
ObservableCollection<RecordedItem> Load(string name);
void Save();
RecordedItem Parse(T itemToParse);
}
public class FileLoadingProcessor : IRecordedItemsProcessor<string>
{
public
浏览 0提问于2012-08-22得票数 1
2回答
我正在尝试使用Dart (1.22.0-dev.10.3)中的泛型方法。下面是一个简单的例子：
abstract class VR<T> {
VR();
bool foo<T>(T value);
}
class VRInt extends VR<int> {
VRInt();
bool foo<int>(int n) => n > 0; // Thinks n is Object
}
class VRString extends VR<String> {
VRString();
bool
浏览 5提问于2017-02-02得票数 17
4回答
下面是这个场景
class MyClass1{
}
class MyClass2 extends MyClass1{
}
class Parent<T>{
List<T> list;
}
class Child extends Parent<MyClass2>{
}
这不编译
Parent<MyClass1> p = new Child();
这确实是
Parent<MyClass2> p = new Child();
为什么？
是否有一种通过父类型引用的方法？
浏览 3提问于2015-03-05得票数 1
回答已采纳
8回答
我很难理解什么时候使用对象(装箱/拆箱)和什么时候使用泛型。
例如：
public class Stack
{
int position;
object[] data = new object[10];
public void Push (object o) { data[position++] = o; }
public object Pop() { return data[--position]; }
}
VS.
public class Stack<T>
{
int position;
T[] data = new T[100];
浏览 0提问于2010-12-13得票数 33
回答已采纳
当参数的类型是方法的泛型类型参数时，很容易获得参数的GenericParameterPosition：
public class MyClass {
public void Foo<T>(T a) { }
}
// ...
Console.WriteLine("pos: " + typeof(MyClass)
.GetMethod("Foo")
.GetParameters()
.Single()
.ParameterType
.GenericParameterPosition);
pos: 0
浏览 0提问于2020-05-01得票数 1
回答已采纳
1回答
嗨，我在的安卓文档中看到了下面的代码。
gridview.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
Toast.makeText(HelloGridView.this, "" + position, Toast.LENGTH_SHORT).show();
}
});
在这种情况下，<
浏览 0提问于2011-07-09得票数 0
回答已采纳
我希望有两个泛型方法的重载：
public ReturnType<T> DoStuff<T>(T thing) {...}
public ReturnType<T> DoStuff<T>(IEnumerable<T> things) {...}
当然，问题是IEnumerable<T>本身就是一个匹配第一个签名的类型，所以当我尝试将一个集合传递给这个方法时，它会调用第一个重载。
显然，我可以以不同的方式命名这些方法，以消除歧义。但是，从本质上看，这些方法都是一样的，我想把它们作为重载来保存。
是否有办法在第一个签名中定义
浏览 3提问于2016-10-09得票数 5
回答已采纳
2回答
例如，我知道如何使用List<T>并确定该集合包含的内容。这就是T的用武之地。但我不确定我是否完全理解了方括号。
如果我创建了一个类。
class MyClass<int> { }
或者我可以用T，object，string或者其他什么来代替int。那是什么意思？它会自动变成一个集合吗？
浏览 2提问于2014-09-13得票数 2
2回答
我不知道为什么我在网上找不到答案。
我有实现多个方法的类，并且我想编写期望它们的方法。我不知道该怎么做，也不知道这是否可行。
例如：
public void yellAtPet(<? extends Pet implements YellableAt> arg) {
arg.yellAt("Don't go there!");
arg.pet("Good Boy");
}
浏览 1提问于2011-03-15得票数 3
回答已采纳
1回答
我有一节课
myClass<T>
我还有一个与类完全无关的类型。
如何在java reflect中生成泛型参数T属于我的类型的myClass？
我试过了
myClass.class.getConstructor()
但我不能再往前走了。我可以在哪里指定要提供给构造函数的泛型参数？
浏览 0提问于2012-12-13得票数 0
回答已采纳
4回答
我希望有一个接口，根据实现它的类，接口声明的函数应该返回特定的类。
我应该使用这样的东西吗？
public interface IMyInterface
{
T returnClassInstance();
}
当我想要将它实现到类中时，它应该是什么样子呢？
public class MyClass : IMyInterFace
{
public T returnClassInstance()
{
ClassInstance class = new ClassInstance();
return (T)class;
}
}
浏览 0提问于2011-08-17得票数 1
2回答
我有一个泛型类。构造函数需要接受作为同一类的另一个实例的参数。问题是另一个实例可以有不同的泛型类型。
看起来C#允许我使用自己的泛型类型的方法，但构造函数似乎不允许这样做。
public class MyClass<T>
{
public MyClass<T2>(MyClass<T2> parent = null)
{
}
// ... Additional stuff
}
上面的代码告诉我T2是未定义的。它不接受它作为方法类型。
一种方法是向我的类添加第二个泛型类型。但这很尴尬，而且在许多情况下，参数将是null，而不是类
浏览 3提问于2016-08-29得票数 3
回答已采纳
当我声明一个泛型静态方法时，为什么我需要添加<T>？如果我不这样做，编译器会抛出一个错误：
//doesn't compile
private static T[] finishToArray(T[] r, Iterator<?> it) {}
//compiles
private static <T> T[] finishToArray(T[] r, Iterator<?> it) {}
浏览 0提问于2017-07-27得票数 0
2回答
我正在浏览这个链接
我试过这个程序。
package my;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class GenericTypeIdentification {
public static void main( String args[] ) {
Node<Integer> obj = new GenericTypeIdentification().new SubNode<Integer>( 1 );
浏览 4提问于2013-09-04得票数 1
回答已采纳
public interface IMyClassClient
{
MyClass<T> Default();
//T cannot be found, error
}
public class MyClass<T>
{
private IMyClassClient owner;
private MyClass<T> test;
public MyClass<T> Test
{
get { return _test;}
set
{
浏览 2提问于2016-12-11得票数 0
回答已采纳
2回答
如何编译下面的代码？
Action<MyClass<object, object>> func = x => Console.WriteLine(x.ToString());
public void Apply<T1, T2>(MyClass<T1, T2> target)
{
func.Invoke(target);
}
我知道它不工作，因为一个MyClass<T1，T2>不是一个MyClass<object，object>，但我能做什么呢？
我可以使函数泛型吗？或
浏览 1提问于2009-02-25得票数 1
回答已采纳
3回答
如何获得泛型类型参数？
、、、、
简单地说：
public static class MyClass<T> {
// i don't want to keep an instance of T, if it is not necessary.
// and it is not nice, not neat.
// Or, let's say, the member are in the form of :
ArrayList<T> mArrayList = new ArrayList<T>();
// the problem of g
浏览 0提问于2013-08-20得票数 3
4回答
尝试学习java通用特性，但在使用它时，我收到了警告，无法理解如何解决它，尽管程序本身运行良好。
我创建了一个具有以下签名的类
public class MyClass<T> {
public T demo(String string,Class<T> type){
// some work
}
}
现在，在我的另一个类中，我声明这个类的实例如下
private MyClass myClass;
我试着把这种方法称为
(ClassB)myClass.demo("hello",ClassB.class);
(Class
浏览 2提问于2011-12-03得票数 0
嗨，我有一些声明如下的类：
class SuperObject {
}
class SuperClass<T extends SuperObject> {
}
class MyObject extends SuperObject {
}
class MyClass<T extends SuperObject> extends SuperClass<T> {
protected T method() {
return new MyObject(); // error: required type T, provided
浏览 3提问于2020-08-24得票数 1
3回答
我需要一个通用服务合同，但是如果我这样做了，我会收到以下错误：
[ServiceContract]
public interface IService<T> where T : MyClass
{
[OperationContract]
void DoWork();
}
服务'z.t'.实现的合同列表中找不到合同名称'x.y‘
浏览 1提问于2011-06-02得票数 1
回答已采纳
6回答
我有一个泛型类Proxy<T>，我想编写另一个泛型类，它的类型参数是一个代理。
我想写：
public class MyClass<U> where U : Proxy<T>
但是编译器会报告The type or namespace name T could not be found。
我找到的一个解决方案是这样声明：
public class MyClass<U, T> where U : Proxy<T>
但这似乎很笨拙，因为客户端必须声明两个类型的参数，如下所示：
public class SomeClass { ... }
浏览 11提问于2011-02-04得票数 3
回答已采纳
这是代码：
using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApplication8
{
public interface MyBaseClass { }
public interface MyClass1 : MyBaseClass { }
public interface MyClass2 : MyBaseClass { }
public interface Filter { int Id { get; set; } }
public int
浏览 0提问于2014-07-17得票数 0
回答已采纳
1回答
在我们的代码库中，我们有一个基本模型(PersistenceEntity)，它处理通过通用存储库持久存储到存储中的任何模型。这对于抓取、添加和删除都很有效。我想要改进的方面是我们的update方法将被封装在存储库中，而不是在服务层中获取对象，操作它(以开发人员认为合适的方式)，然后保存它。 存储库更新方法应该在内部加载模型，调用对象上的更新方法，然后保存它(或调用AddOrUpdate扩展)。 为此，我想我可以在基类上添加一个抽象方法，以强制开发人员在模型中实现更新，而不是在另一个层中设置属性。 public abstract T Update<T>(T existing) wh
浏览 19提问于2020-01-02得票数 3
回答已采纳
1回答
我目前正在从一本书中学习Java，有些事情我不太明白。
假设我有一个参数化类：
class MyClass<T> {
T item;
public T getItem() { return item; }
// ...
}
我知道，由于类型擦除，禁止创建参数化类型的数组。现在这本书说我可以像这样使用类型：
MyClass<String>[] foo = (MyClass<String>[]) new MyClass<?>[10];
但是，下面这句话有什么区别呢？
MyClass<String>[] fo
浏览 3提问于2017-12-24得票数 3
回答已采纳
我正在尝试理解中描述的泛型接口
我的示例有一个接口：
public interface ITest<T> where T: class
{
T GetByID(int id);
}
我有一个实现接口的类，使用LINQ在项目数据中输入条目，其中包含类myClass：
public class Test<myClass> : ITest<myClass> where myClass : class
{
Data.myEntities _db = new Data.myEntities();
public m
浏览 1提问于2009-11-26得票数 1
4回答
我可以这样做吗：
public void Foo<T>(int param) where T: MYCLASS1, MYCLASS2
指定T仅为MYCLASS1或MYCLASS2实例？
谢谢。。
浏览 1提问于2011-03-19得票数 4
回答已采纳
用户通过配置支持userType和userFunction：
{"userType": "com.user.Person", "userFunction": "com.user.userFunction"}
我们希望为用户获取数据，并将数据提供给userFunction：
public class DataConsumer<T> {
//get data from some place, such as kafka
T data;
}
process() {
String userType =
浏览 0提问于2018-10-17得票数 0
回答已采纳
1回答
考虑以下四个类：
export class Car {
}
export class Mercedes extends Car {
}
export class Animal<T extends Car> {
car: T;
}
export class Dog extends Animal<Mercedes> {
}
另一个类保存了对这两个类的引用：
export class MyClass {
constructor(animalClass: typeof Animal) {}
}
现在，以下代码不起作用：
let x = new MyC
浏览 6提问于2018-01-03得票数 1
4回答
test1和test2的区别在哪里？为什么在test1中会出现编译错误？
import java.util.ArrayList;
import java.util.Collection;
class MyType {
}
class MyClass<T> {
private Collection<MyType> myTypes = new ArrayList<MyType>();
private Collection<T> myTs = new ArrayList<T>();
public Collec
浏览 0提问于2011-09-15得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
