本文将分享推断的类型不能有效替代Comparable泛型类型的详细内容，并且还将对类型推断要注意什么?进行详尽解释，此外，我们还将为大家带来关于angular–泛型类型’Observable’需要1个

本文将分享推断的类型不能有效替代Comparable泛型类型的详细内容，并且还将对类型推断要注意什么?进行详尽解释，此外，我们还将为大家带来关于angular – 泛型类型’Observable’需要1个类型参数、c# – 泛型和实现IComparable、c# 泛型和 IComparable 接口、C#泛型方法,可以推断泛型类型定义中参数的类型吗？的相关知识，希望对你有所帮助。

• 推断的类型不能有效替代Comparable泛型类型（类型推断要注意什么?）
• angular – 泛型类型’Observable’需要1个类型参数
• c# – 泛型和实现IComparable
• c# 泛型和 IComparable 接口
• C#泛型方法,可以推断泛型类型定义中参数的类型吗？

推断的类型不能有效替代Comparable泛型类型（类型推断要注意什么?）

考虑以下代码：

public abstract class Item<T> implements Comparable<T>{    protected T item;    public int compareTo(T o)    {        return 0; // this doesn''t matter for the time being    }}public class MyItem<T> extends Item<String>{    T object;}public class Foo<T>{    protected ArrayList<T> list;}public class Bar<V> extends Foo<MyItem<V>>{    public void sort()    {        Collections.sort(list);    }}

排序调用给出错误：

绑定不匹配：类型为Collections的通用方法sort（List ）不适用于参数（ArrayList >）。推断的类型MyItem 不是有效替代边界参数<T扩展Comparable <？超级T>>

为什么会这样呢？

如果MyItem<V>实施该工具，Comparable那为什么不能替代呢？

抱歉，是否有人提出这个问题，但我觉得这个问题有些具体。

答案1

实际上，对该错误的更详细说明可以使您javac自己：

java：找不到适合的方法sort(java.util.ArrayList<MyItem<V>>）

方法java.util.Collections.<T>sort(java.util.List<T>,java.util.Comparator<?super T>)不适用（由于实际和正式参数列表的长度不同，因此无法从参数实例化）

方法java.util.Collections.<T>sort(java.util.List<T>)是不适用（推断类型不符合声明结合（一个或多个）推断：MyItem<V>结合（一个或多个）：
java.lang.Comparable<? super MyItem<V>>）

因此，主要问题是：
为什么methodCollections.<T>sort(java.util.List<T>)）不适用？

答案是 ：
因为在Collections.<T>sort(java.util.List<T>)方法声明中参数T：是有界的<T extendsComparable<? super T>>。

换句话说，T必须Comparable在其自身上实现接口。例如String类实现这样的接口：...implements ...Comparable<String>。

在您的情况下，Item类未实现此类接口：

Item<T> implements Comparable<T>与Item<T> implements Comparable<Item<T>>。

因此，为解决此问题，您应将您的Item班级更改为此：

public abstract class Item<T> implements Comparable<Item<T>>{    protected T item;    public int compareTo(Item<T> o)    {        return 0; // this doesn''t matter for the time being    }}

angular – 泛型类型’Observable’需要1个类型参数

import { platformbrowserDynamic } from '@angular/platform-browser-dynamic';
import { NgModule,Component } from '@angular/core';
import { browserModule } from '@angular/platform-browser';
import { HttpModule,Http } from '@angular/http';
import 'rxjs/add/operator/map';
import { Observable } from "rxjs/Observable";

@Component({
    selector: 'http-client',template: `<h1>All Products</h1>
  <ul>
    <li *ngFor="let product of products">
       {{product.title}}
    </li>
  </ul>
  `})
class AppComponent {

    products: Array<string> = [];

    theDataSource: Observable;

    constructor(private http: Http) {

        this.theDataSource = this.http.get('api/products/')
            .map(res => res.json());
    }

    ngOnInit() {
        // Get the data from the server
        this.theDataSource.subscribe(
            data => {
                if (Array.isArray(data)) {
                    this.products = data;
                } else {
                    this.products.push(data);
                }
            },err =>
                console.log("Can't get products. Error code: %s,URL: %s ",err.status,err.url),() => console.log('Product(s) are retrieved')
        );
    }
}

@NgModule({
    imports: [browserModule,HttpModule],declarations: [AppComponent],bootstrap: [AppComponent]
})
class AppModule { }

platformbrowserDynamic().bootstrapModule(AppModule);

theDataSource: Observable<any>;

c# – 泛型和实现IComparable

using System;

namespace GenericsPracticeConsole.Types
{
    class SortableGenericType<T> : IComparable
    {
        private T t;
        private string stringName;

        public T name
        {
            get { return t; }
            set { t = value; }
        }

        public int Compareto(SortableGenericType<T> ourObject)
        {
            return stringName.Compareto(ourObject.stringName);
        }
    }
}

class SortableGenericType<T> : IComparable<SortableGenericType<T>>
{
   //
}

class SortableGenericType<T> : IComparable,IComparable<SortableGenericType<T>> 
   {
      private string stringName;
      public T name { get; set; }

      public int Compareto(SortableGenericType<T> ourObject)
      {
         //I forgot to add this statement:
         if(ourObject == null) 
             return -1; 
         return stringName.Compareto(ourObject.stringName);
      }

      public int Compareto(object obj)
      {
         if (obj.GetType() != GetType())
            return -1;
         return Compareto(obj as SortableGenericType<T>);
      }
   }

class SomeCollection<T> where T : IComparable<T>
   {
      private List<T> items; 

      private void Sort()
      {
         //
         T item1;
         T item2;
         if(item1.Compareto(item2) < 0)
         {
            //bla bla
         }
      }
   }

c# 泛型和 IComparable 接口

泛型

　　因为我们在编程中想先不定义数据类型，只想先写逻辑，就可以使用 Object 类型，

　　这样我们的逻辑就适用于所有类型，但是，在运行中，Object 类型的变量会需要

　　转换到对应类型，浪费资源，所有出现泛型，来代替 object 类型的方案。

　　使用泛型，可以让我们延迟定义数据类型，来编写程序

　　泛型是一种将逻辑应用到不同数据类型上的机制，可以通过类型替代符

　　来暂时替代参数的数据类型，这样只需要在编译的时候，编译器会自动

　　将该替代符编译成对应数据类型来处理

　　泛型方法：

　　　　访问修饰符 返回类型 方法名 <T,U>(T 参数，U 参数){

　　　　}

　　　　我们可以在方法名后使用 <类型替代符> 来定义一个泛型方法

　　　　方法定义好后，在调用泛型方法时，应该在 <> 括号内填上对应的类型

　　　　使用范围：当你的方法适用于所有数据类型的时候，可以使用泛型类型来代替 Object 类型，以节省资源

　　泛型类：

　　　　访问修饰符  class 类名 <T>{

　　　　　　T 成员；

　　　　}

　　　　类型替代符的作用：

　　　　　　可以让我们先不定义数据类型，只管逻辑，在调用此方法或者此类对象时，才在 <> 括号里填上对应类型

　　　　　　只有我们这段逻辑或者说这个类结构就可以适用于所有数据类型而且要比 object 类型节省资源

　　泛型集合：

　　　　在 System.Collections.Generic 下的泛型数据结构类

　　　　比 System.Collections 下的 Object 类型的数据结构类要更安全，性能更好

　　泛型列表：

　　　　List <数据类型>  列表名  = new List < 数据类型 >(可填写初始长度)　　

　　　　属性：

　　　　　　Count : 代表这个列表实际包含多少个元素

　　　　　　Capacity：代表这个列表可以包含多少个元素

　　　　方法：

　　　　　　Add ：在列表末尾添加一个元素

　　　　　　Remove：删除指定的元素

　　　　　　RemoveAt：删除下标号指定的元素

　　　　　　Contains：检测是否包含这个元素

　　　　　　IndexOf：从头开始查找第一个匹配项的下标号，没找到返回 - 1

　　　　　　LastIndexOf：从尾开始查找第一个匹配项的下标号，没找到返回 - 1

　　　　　　Insert：在指定 Index 的位置，插入这个元素

　　　　　　Reverse: 翻转当前列表的排列顺序

　　　　　　Sort：排序

　　　　　　查 / 改：索引器 [下标号]

　　IComparable <T> 接口：

　　　　　可以实现 Sort 对复杂数据类型的排序

　　　　　 让你的类实现 ComparaTo<T other> 方法

　　　　会返回一个 int 值

　　　　其含义：  大于零：对象大于 other 参数；

　　　　　　　　 小于零：对象小于 other 参数；

　　　　　　　　 等于零：对象等于 other 参数；

C#泛型方法,可以推断泛型类型定义中参数的类型吗？

public class Factory{
    public static T Get<T>(V v)
        where T : BaseClass<V> {
            T someObject = DIContainer.Resolve<T>();
            someObject.Set(v);
    }
}

public class Factory{
    public static T Get<T,V>(V v)
        where T : BaseClass<V> {
            T someObject = DIContainer.Resolve<T>();
            someObject.Set(v);
    }
}

public class Factory{
    public static T Get<T,V>(V v)
        where T : T<V> {
            T someObject = DIContainer.Resolve<T>();
            someObject.Set(v);
    }
}

我们今天的关于推断的类型不能有效替代Comparable泛型类型和类型推断要注意什么?的分享就到这里，谢谢您的阅读，如果想了解更多关于angular – 泛型类型’Observable’需要1个类型参数、c# – 泛型和实现IComparable、c# 泛型和 IComparable 接口、C#泛型方法,可以推断泛型类型定义中参数的类型吗？的相关信息，可以在本站进行搜索。