泛型方法

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}



泛型类



//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}



泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

泛型是 jdk1.5引入的一个新特性，提供编译期类型安全检测机制。该机制允许在编译时检测。检测存入集合中的类是是否合法，通过参数化类型，将数据类型作为一个参数来引入。

当提到参数的时候，需要想到参数有形参和实参

泛型：参数化类型 将类型由原来的具体的类型参数化，在使用是传入具体的类型。

泛型可以用在类上（泛型类），接口（泛型接口），方法（泛型方法）上





泛型的定义格式：

<类型>：指定类型的格式

<类型1,类型2,…> 多类型的格式

泛型的使用：在使用时传入具体的类型 此处需要注意：传入的类型只能是引用类型

泛型的好处：

1 可以在编译期 来检测数据类型  从而将错误的检测时机提前到编译期

2 将来在使用集合中的对象时，可以避免对对象的强制转换。

泛型的体会：
/*
需求：用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合
   要求：按照总分从高到低出现
 */
public class GenericDemo_01 {
    public static void main(String[] args) {
        //jdk7以前
        //Set<Student> students = new TreeSet<Student>();
        //jdk7以后可以在new的时候 省略泛型的指定
        //set集合的排序使用定制排序
        Set<Student> set = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student stu1, Student stu2) {
                return (stu1.getChinese() +stu1.getMath()) -(stu2.getChinese() +stu2.getMath()) ;
            }
        });
       Student st1 = new Student("张三",80,90);
       Student st2= new Student("李四",89,92);
       Student st3 = new Student("王五",75,68);
       set.add(st1);
       set.add(st2);
       set.add(st3);
       //迭代
       Iterator<Student> iter =  set.iterator();
       while(iter.hasNext()){
          Student student =  iter.next();
           System.out.println(student);
       }
        System.out.println("----------------");
       //使用增强for进行遍历
        for(Student student : set){
            System.out.println(student);
        }
    }
}



泛型类

修饰符  class 类名<类型>


常用的泛型参数：E  T  K  V

自定义泛型类
// 这是一个泛型类 T 表示该类将使用一个数据类型为T   可以在类中使用该参数来表示一种数据类型
public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}



自定义泛型类的使用
public static void main(String[] args) {
    //自定义泛型类的使用
    Generic<String> generic = new Generic<>();
    generic.setT("admin");
    System.out.println(generic.getT().toUpperCase());//此时get所得到的是String 可以使用String类提供的所有方法
    Generic<Double> generic1 = new Generic<>();
    generic1.setT(100.2);
    generic1.setT(56.6);
    System.out.println(generic1.getT());

}


泛型方法

泛型方法的格式：修饰符 <类型> 返回值类型  方法名称(形参列表)
// 这是一个泛型类 T 表示该类将使用一个数据类型为T   可以在类中使用该参数来表示一种数据类型
public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }
// 不是泛型方法
    public void setT(T t) {
        this.t = t;
    }
    //这才是泛型方法
    public  <E> void show(E e){
        System.out.println();
    }
}


//这才是泛型方法 E 对应将来调用时传入的实参类型  T 对应的是在创建泛型类对象时 指定的类型
public  <E> void show(E e,T t){
    System.out.println(e+"---"+t);
}
//这也是一个泛型方法  E 对应调用时的传入的实参类型  泛型参数不仅可以作为方法的参数类型还可以作为返回值类型
public  <E> E show(E e){
    return  e;
}



使用
// generic.show("蓝桥",100);
 generic.show(100,"蓝桥");
 generic.show(true,"admin");
 //泛型方法返回值类型为泛型的方法调用
String s =  generic1.show("String");
 System.out.println(s);



泛型类中可以没有泛型方法 ，同时存在泛型方法的类 也不一定时泛型类

泛型接口

格式：修饰符  interface  接口名<类型>{}

泛型接口的定义
//泛型接口
public interface IGeneric<T> {
    void  test(T t);//这是普通方法
    <E> E show(E e);//泛型方法
}



使用普通类实现泛型接口（了解）
public class GenericImpl implements IGeneric<String> {
    @Override
    public void test(String s) {
        System.out.println(s);
    }

    @Override
    public <E> E show(E e) {
        return e;
    }
}



测试
public class IGenericTest {
    public static void main(String[] args) {
        IGeneric<String> generic = new GenericImpl();
        generic.test("hello ");
        String s = generic.show("world");
        System.out.println(s);
    }
}



使用泛型类来实现泛型接口（推荐使用）
public class GenericImpl<T> implements IGeneric<T> {

    @Override
    public void test(T t) {
        System.out.println(t);
    }

    @Override
    public <E> E show(E e) {
        return e;
    }
}



多泛型
//泛型接口
public interface IGeneric<T,E> {
    void  test(T t);//这是普通方法
    <E> E show(E e);//泛型方法
}




public class GenericImpl<T,E> implements IGeneric<T,E> {

    @Override
    public void test(T t) {
        System.out.println(t);
    }

    @Override
    public <E> E show(E e) {
        return e;
    }
}



泛型接口中不一定存在泛型方法  存在泛型方法的接口 也不一定是泛型接口
泛型通配符

通配符：<?>

List<?>  表示存储 的数据类型是位置类型 它可以匹配任何类型

通配符上限：List<? extends Number> 表示的类型为Number及其子类

通配符下限：List<? super Number> 表示的类型为Number及其父类

基本使用：
public static void main(String[] args) {
    // 通配符的使用 以下声明List<?>仅表示各种泛型List的父类  不能给其中添加元素
    List<?>  list1 = new ArrayList<>();
    List<?>  list2 = new ArrayList<Object>();
    List<?>  list3 = new ArrayList<Integer>();
    //通配符上限  以下声明List<? extends Number >仅表示各种泛型List的父类 上限 为Number 不能给其中添加元素
    List<? extends Number > list4 = new ArrayList<Number>();
    List<? extends  Number> list5= new ArrayList<Integer>();
  //通配符下限
    List<? super Number > list6 = new ArrayList<Number>();
    List<? super  Number> list7= new ArrayList<Object>();
  //  List<? super  Number> list8= new ArrayList<Integer>();
}

给.neter们整理了一份《.NET/C#面试手册》，目前大约4万字左右，初衷也很简单，就是希望在面试的时候能够帮助到大家，减轻大家的负担和节省时间。对于没有跳槽打算的也可以复习一下相关知识点，就当是查缺补漏！
都是一些经典的面试题目，目前主要分为10大部分。
.NET/C#面试手册：基础语法
.NET/C#面试手册：面向对象
.NET/C#面试手册：集合、异常、泛型、LINQ、委托、EF！
.NET/C#面试手册：多线程
.NET/C#面试手册：ASP.NET MVC
.NET/C#面试手册：ASP.NET Core
.NET/C#面试手册：ADO.NET、XML、HTTP、AJAX、WebService
.NET/C#面试手册：常见的算法
.NET/C#面试手册：数据库概念知识
.NET/C#面试手册：数据库SQL查询（附建表语句）
废话不多说，本手册目前为第一版，后续慢慢也会陆续更新一些知识点，目前内容有以下板块：

《.NET/C#面试手册》包含[基础知识]、[面向对象]、[集合、异常、泛型、LINQ、委托、EF]、[ASP.NET MVC]、[ASP.NET Core]、[ADO.NET、XML、HTTP、AJAX、WebService]、[数据库知识]、[数据库SQL查询（附建表语句）]。
《.NET/C#面试手册》完整pdf、word下载地址
###本章阅读列表###
泛型很难理解？不然
泛型集合和ArrayList的装箱拆箱
常见的泛型类型
泛型类和泛型方法
泛型约束
泛型委托
###泛型很难理解？不然 ###

在接触的一个新的概念的时候，总会感觉难以理解，当你掌握并能熟练地使用的时候，发现这个概念其实简单的，我相信大多数码农都会有这种似曾相识的感觉。可能大多数人刚学习泛型的时候觉得很难理解，当然我也是这样的，所以便写下这篇文章加深一下对泛型的印象。

第一次接触泛型那还是在大二上学期的时候，那会是学c#面向对象的时候接触过泛型集合，但尴尬的是那会还没有“泛型”这个概念，仅仅只停留在泛型集合的使用。关于泛型入门的文章csdn和博客园有很多，这里我也写一篇关于我对泛型学习的一个总结，如果出现错误表达不当的地方，还希望评论指出。

###泛型优点###

官方文档：https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/generics/introduction-to-generics

简介:

泛型是.NET Framework2.0新增的一个特性，在命名空间System.Collections.Generic,包含了几个新的基于泛型的集合类，官方建议.net 2.0 及更高版本的应用程序使用心得泛型集合类，而不使用非泛型集合类，例如ArrayList。

官方解释：

泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。

泛型的定义主要有以下两种：

1.在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）

2.在程序编码中一些包含参数的类。其参数可以代表类或对象等等。（人们大多把这称作模板）不论使用哪个定义，泛型的参数在真正使用泛型时都必须作出指明

官方的解释虽然很难理解，用我的话来解释那就是，声明类和方法时一般都需要定义是什么类，class Brid ,Class Food… 声明泛型类和方法时只需要传入类型的地方用 ，有点类似于占位符的作用，用的时候传入具体的类型。当针对不同类型具有相同行为的时候，也就是泛型发挥作用的时候。

优点：

1.使用泛型类、方法，我们可以极大提高代码的重用性，不需要对类型不同代码相同（仅类型参数不同）的代码写多次。

2.创建泛型类，可在编译时创建类型安全的集合

3.避免装箱和拆箱操作降低性能，在大型集合中装箱和拆箱的影响非常大.
泛型集合和ArrayList的装箱拆箱###
装箱：是指从值类型转换成引用类型

拆箱：是指从引用类型转换成值类型

下面的例子是借鉴官方的一段代码：
    System.Collections.ArrayList list1 = new System.Collections.ArrayList();
            list1.Add(3);
            list1.Add(105);

            System.Collections.ArrayList list2 = new System.Collections.ArrayList();
            list2.Add("科比");
            list2.Add("詹姆斯");

ArrayList是一个极为方便的集合类，可以用于存储任何引用或值类型。但是缺点也很明显，第一个缺点是编译的时候不会检查类型，例如
  System.Collections.ArrayList list1 = new System.Collections.ArrayList();
            list1.Add(3);
            list1.Add(105);
            list1.Add("sd");
            foreach (int item in list1)
            {
                Console.WriteLine(item.ToString());
            }

编译正常，运行的时候会出现转换类型错误。

至于ArrayList第二个缺点就是装箱拆箱的时候回造成性能的损失。我们看看ArrayList的Add方法的定义。


参数是一个object类型，也就是说ArrayList添加任何引用类型或值类型都会隐士转换成Object，这个时候便发生装箱操作，在遍历检索它们时必须从object 类型转换成指定的类型，这个时候便发生拆箱操作。这两种操作会大大降低性能。所以.net 2.0的程序时应该放弃使用ArrayList，推荐使用使用List《T》 泛型集合。这也是我们为什么要使用泛型的原因之一。
###常见的泛型类型###

在泛型类型的定义中，出现的每个T（一个展位变量而已叫别的名字也行）在运行时都会被替换成实际的类型参数。下面是一些基础的泛型类型

1.泛型类
           class MyGenericClass<T>
        {
          //......
        }

2.泛型接口
        interface  GenericInterface<T>
        {
           void  GenericMethod(T t);
        }

3.泛型方法
        public void MyGenericMethod<T>()
        {
          //......
        }

4.泛型数组
public T[] GenericArray;

5.泛型委托
 public delegate TOutput GenericDelagete<TInput, TOutput>(TInput input);

6.泛型结构
   struct MyGenericStruct<T>
        {

        }

在使用时所有的T的都要替换成具体的类型。

类型参数命名指南，参见官方文档


###泛型类和泛型方法###

我们先来看看泛型方法，这个方法的用途是来交换两个变量的
        static void Main(string[] args)
        {
            int a = 1;
            int b = 2;
            SwapInt(ref a,ref b);
            Console.WriteLine($"a={a}b={b}");
        }
        public static void SwapInt(ref int a, ref int b)
        {
            int temp;
            temp = a;
            a = b;
            b = temp;
        }

结果是a=2,b=1,但是我们现在要换成string类型呢，是不是得再写一个string参数的方法呢，如果是char、double…，这每个不同类型的参数都要写一个参数，的确太麻烦并且没有这个必要，Object ?当然可以
        static void Main(string[] args)
        {
            object a = 1;
            object b = 2;
            SwapObject(ref a,ref b);
            Console.WriteLine($"a={a}b={b}");
        }
        public static void SwapObject(ref object a, ref object b)
        {
            object temp;
            temp = a;
            a = b;
            b = temp;
        }

这确实能解决代码复用的需求，但是上面我们已经知道使用Object类型会发生装箱拆箱的操作，会降低性能。所以我们可以使用泛型方法解决这个缺点。
    static void Main(string[] args)
        {
            int a = 1;
            int b = 2;
            SwapGeneric(ref a,ref b);
            Console.WriteLine($"a={a}b={b}");
        }
        //交换两个变量的方法
        public static void SwapGeneric<T>(ref T a, ref T b)
        {
            T temp;
            temp = a;
            a = b;
            b = temp;
        }

泛型类：这个泛型类常用api通用接口的泛型类。
    class Program
    {
        static void Main(string[] args)
        {
            List<Product> data = new List<Client.Product>() {
                              new Client.Product() { Id=12,Name="土豆"},
                              new Client.Product() { Id=12,Name="茄子"},
                              new Client.Product() { Id=12,Name="黄瓜"}
           };
           var resultProduct = Result<Product>.Success(data);
            var resultUser = Result<User>.Error("没有数据");
            foreach (var item in resultProduct.Data)
            {
                Console.WriteLine(item.Id+","+item.Name);
            }
            Console.WriteLine(resultUser.IsSuccess+resultUser.Message);
        }

    }
    public class Result<T> { //泛型类，声明T变量类型
        public bool IsSuccess { get; set; }
        public List<T> Data { get; set;}//未定义具体类型的泛型集合
        public string Message { get; set; }
        public static Result<T> Error(string message) 
        {
            return new Client.Result<T> { IsSuccess = false, Message = message };
        }
        //泛型方法，初始化数据
        public static Result<T> Success(List<T> data)
        {
            return new Client.Result<T> { IsSuccess =true,Data =data}; //成功就没有提示消息的原则
        }
    }
    public class Product {
        public int Id { get; set; }
        public string Name { get; set; }
    }
    public class User {
        public int Age { get; set; }
        public string Name { get; set; }
    }

使用该通用的泛型类的好处在于，获取不同的对象集合不需要写多个方法，获取Product数据集合、获取User数据集…。只需要调用Success方法既可，使代码变得可复用。

###泛型类型参数约束###

为什么要使用类型参数的约束呢，简单点说就是筛选类型参数，在使用泛型的代码中如果违反了某个约束不允许的类型来实例化则会产生编译错误，类型参数的约束是使用关键字where。 下面列出了6中类型的约束
where T: struct

类型参数必须是值类型。可以指定除 Nullable 以外的任何值类型。有关更多信息，请参见使用可以为 null 的类型（C# 编程指南）。
where T : class

类型参数必须是引用类型；这一点也适用于任何类、接口、委托或数组类型。
where T：new()

类型参数必须具有无参数的公共构造函数。当与其他约束一起使用时，new() 约束必须最后指定。
where T：<基类名>

类型参数必须是指定的基类或派生自指定的基类。
where T：<接口名称>

类型参数必须是指定的接口或实现指定的接口。可以指定多个接口约束。约束接口也可以是泛型的。
where T：U

为 T 提供的类型参数必须是为 U 提供的参数或派生自为 U 提供的参数。

我们在看看上面那个交换两个变量的方法SwapGeneric，加上必须是值类型的约束
  public static void SwapGeneric<T>(ref T a,ref T b) where T :struct 
        {
            T temp;
            temp = a;
            a = b;
            b = a;
        }
        //实例化
            Product p = new Product() { Id=1,Name="土豆"};
            Product p1 = new Product() { Id=2,Name ="茄子"};
            SwapGeneric<Product>(ref p,ref p1);

我们在使用的时候编译给我们提示了以下的错误：


“类型Product必须是不可以为NUll值得类型”，引用类型的默认值就是NULL，所以该房型方法的类型参数不能是引用类型，这就是使用类型参数约束的好处。
约束多个参数
    class List<TLive,U> where TLive:User where U:struct
    {

    }

###泛型委托###

泛型委托可以自己定义自己的类型参数，声明的时候还是和泛型类、泛型方法一样加个<坑> 站个坑，其实泛型委托使用的时候不是很多，要慎用。，如以下事例
public delegate T DelegateGeneric<T>(T item);
DelegateGeneric<string> test = StringMethod;
        public static string StringMethod(string name)
        {
            return "你好" + name;
        }

将上面的交换两个变量的方法改成委托是这样的
        public delegate void DelegateGenericSwap<T>(ref T a,ref T b);
            string a = "张林";
            string b = "科比";
            DelegateGenericSwap<string> swap = GenericSwap;
            Console.WriteLine($"a:{a}b:{b}");
           public static void GenericSwap<T>(ref T a,ref T b)
        {
            T temp;
            temp = a;
            a = b;
            b = a;
        }


作者信息：

【文章信息】：作者-张林:原文链接-https://blog.csdn.net/kebi007/article/details/77800954

【原创公众号】：dotNet全栈开发。好文目录

版权声明：本文为CSDN博主「dotNet全栈开发」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。

泛型：就是参数类型化  再调用的时候将类型作为参数进行传入  最多的石油就是在集合中进行使用 来申明集合内部存储的元素的类型  除此之外还有泛型类  泛型方法 泛型接口

泛型类：

public class Generic<T>{ 
    
    private T key;
    public T getKey(){ 
    }
}

T就是泛型化的一个体现 

创建实例:传入要使用的参数类型

Generic<Integer> genericInteger = new Generic<Integer>();

泛型接口：与泛型方法的定义相似

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

//实现类
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}


泛型方法：


public <T> T genericMethod(Class tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

1)返回值前面要加上<T> 只有这样才能申明这是一个泛型方法
2）申明了之后就可以在方法内部使用T
3）返回值可以申明为T 参数可申明为T 内部变量给也可以申明为T 就是将T作为乐意变量类型来进行使用