文章目录

• 泛型概述
• 泛型集合类使用场合概述
• 自定义泛型类的创建
• 类型参数
• 泛型继承之开放与封闭
• 泛型继承之泛型类继普通类
• 泛型继承之普通类继承泛型类
• 泛型继承之泛型类继承泛型类
• 泛型集合接口概述
• 泛型接口的使用
• 定义泛型方法
• 调用泛型方法

泛型概述

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._1泛型概述
{
    class Program
    {
        static void Main(string[] args)
        {
            //集合与数组：①长度可以改变②添加数据时不用考虑具体类型，object
            List<int> list = new List<int>();
            list.Add(2);
            list.Add(4);
            list.AddRange(new int[] { 1, 2, 3, 4, 5, 6 });
            list.AddRange(list);//泛型可以添加自己
            list.Insert(3, 100);//在索引为3处插入100
            //list.Sort();//从小到大排序
            //list.Reverse();//倒叙

            for(int i=0;i<list.Count;i++)
            {
                Console.WriteLine(list[i]);
            }

            int[] nums = list.ToArray();//将泛型转换成数组
            List<int> listTwo = nums.ToList();//nums可以转换成list

            
            Console.ReadKey();
        }
    }
}

结果：

2
4
1
100
2
3
4
5
6

泛型集合类使用场合概述

自定义泛型类的创建

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._3自定义泛型类的创建
{
    public class TGeneric<T>//创建泛型类
    {
        public T Field;
    }

    class commonlyClass//普通类
    {
        public T G<T>(T t)//普通方法
        {
            return t;
        }
    }


    class TGenericTwo<T>//泛型类
    {
        public  T M(T t)//此方法有自己的类型参数列表，为泛型方法
        {
            return t;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            TGeneric<string> g = new TGeneric<string>();
            g.Field = "51zxw.net";
            Console.WriteLine(g.Field);
            Console.ReadKey();
        }
    }
}

类型参数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._4类型参数_T
{
    public class TGenericDemo<T>
    {
        void Exp(T input)
        {

        }
    }



    class Program
    {
        private class customClass//自定义类型，其余普通的int char类是一样的
        {

        }
        static void Main(string[] args)
        {
            //实例化泛型类，gd1为char类型
            
            TGenericDemo<char> gd1 = new TGenericDemo<char>();
            Console.WriteLine("实例化类型为char的TGenercDemo的gd1成功");

            TGenericDemo<int> gd2 = new TGenericDemo<int>();
            Console.WriteLine("实例化类型为int的TGenercDemo的gd2成功");

            TGenericDemo<string> gd3 = new TGenericDemo<string>();
            Console.WriteLine("实例化类型为string的TGenercDemo的gd3成功");

            TGenericDemo<customClass> gd4 = new TGenericDemo<customClass>();
            Console.WriteLine("实例化类型为自定义类型的TGenercDemo的gd4成功");
            Console.ReadKey();

        }
    }
}

结果：

实例化类型为char的TGenercDemo的gd1成功
实例化类型为int的TGenercDemo的gd2成功
实例化类型为string的TGenercDemo的gd3成功
实例化类型为自定义类型的TGenercDemo的gd4成功

泛型继承之开放与封闭

泛型继承之泛型类继普通类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._6泛型继承之泛型类继承普通类
{
    public abstract class  baseClass//普通基类的创建
    {
        protected int user_name;//定义字段
        public virtual int user_Name//定义属性
        {
            get { return user_name; }
            set { user_name = value; }
        }
        public baseClass(int index)//构造函数
        {
            user_name = index;
        }

        public abstract void method(int t);//方法
    }


    public class TGenClass<T>:baseClass//泛型派生类
    {
        protected new T user_name;//隐藏基类的同名成员
        public new T user_Name
        {
            get { return user_name; }
        }
        public TGenClass(int index) : base(index)//构造函数
        { }
        public TGenClass(T t):base(1000)
        {
            user_name = t;
        }
        public override void method(int t)//重载方法
        {
            Console.WriteLine("调用方法成功");

        }
        public void method(T t)//方法
        { }


    }


    class Program
    {
        static void Main(string[] args)
        {
            int val = 1000;
            TGenClass<int> g = new TGenClass<int>(val);
            g.method(g.user_Name);
            Console.WriteLine("泛型继承演示成功：泛型类继承普通类");
            
            Console.ReadKey();
        }
    }
}

结果：

泛型继承演示成功：泛型类继承普通类

泛型继承之普通类继承泛型类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._7泛型继承之普通类继承泛型类
{

    abstract class TgenClass<T>//泛型基类
    {
        protected T field;//字段
        public virtual T Filed
        {
            get { return field; }
        }
        public TgenClass(int index)//构造函数
        {

        }
        public TgenClass(T t) { field = t; }//构造函数
        public abstract void method(T t);//抽象方法 不需要方法体
    }

     class ordinaryClass: TgenClass<int>//普通派生类
    {
        public override int Filed
        {
            get { return base.Filed; }
        }

        public ordinaryClass(int t) : base(t) { }//构造函数
        public override void method(int t)
        {
            Console.WriteLine("Field属性值为：{0}", t);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            int val = 1000;
            ordinaryClass oc = new ordinaryClass(val);
            oc.method(val);
            Console.WriteLine("普通类继承泛型类演示成功");
            Console.ReadKey();
        }
    }
}

结果：

Field属性值为：1000
普通类继承泛型类演示成功

泛型继承之泛型类继承泛型类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._8泛型继承之泛型类继承泛型类
{

    //定义泛型基类
    //<T>T可以是任意的标识符，只要遵循我们的通常c#中的命名规则即可，比如多参数T1,T2,T3
    abstract class TgenBaseClass<T1,T2>
    {
        //定义两个字段
        public T1[] str;
        public T2[] ind;//索引字段
        //定义一个索引属性
        public T1 this [int index]
        {
            get { return str[index];}
            set { str[index] = value; }
        }
        //定义一个获取数组长度的属性
        public int length
        {
            get { return str.Length; }//只读
        }
        //构造函数
        public TgenBaseClass(int index)
        {
            str = new T1[index];
            ind = new T2[index];
        }



    }
    //定义派生泛型类
    class TgenClass<T>:TgenBaseClass<T,int>
    {
        public TgenClass(int index):base(index)
        {
            for(int i=0;i<length;i++)
            {
                ind[i] = i;
            }
        }
        //派生类中定义一个output方法
        public void output()
        {
            for(int i=0;i<length;i++)
            {
                Console.WriteLine(str[i].ToString());   
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //实例化
            TgenClass<string> gc = new TgenClass<string>(6);
            //添加元素的过程
            gc[0] = "first";
            gc[1] = "second";
            gc[2] = "third";
            gc[3] = "fourth";
            gc[4] = "fifth";
            gc[5] = "sixth";
            
            //调用方法，遍历元素
            gc.output();
            Console.WriteLine("泛型继承之泛型类继承泛型类演示成功");
            Console.ReadKey();
        }
    }
}

结果：

first
second
third
fourth
fifth
sixth
泛型继承之泛型类继承泛型类演示成功

泛型集合接口概述

泛型接口的使用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._10泛型接口的使用
{
    public interface IMyinterface { }
    public interface IMyinterface<T> { }
    public interface IMyinterface <T1,T2>{ }

    public interface IRelation<T1,T2>
    {
        int Forward(T1 forward);//参数类型要么是封闭的，要么是由接口的参数列表来决定的
        int Afater(T2 after);//只提供表示，不实现
        T1 GetForward(int index);

        void GetAfter(int index, out T2 after);
        void change(ref T1 forward, ref T2 after);
    }

    class Program
    {
        static void Main(string[] args)
        {
            

        }
    }
}

定义泛型方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _10._11定义泛型方法
{
    public class myclass
    {
        //定义泛型方法
        public bool Contains<T>(T[] TArray,T TValue)
        {
            //遍历元素
            foreach(T t in TArray)
            {
                //判断是否存在TValue
                if (t.Equals(TValue))
                    return true;//存在返回true

            }
            return false;//不存在返回false
        }

    }



    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

调用泛型方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _19._12调用泛型方法
{
    public class myclass
    {
        //泛型方法实现
        public bool Contains<T>(T[] TArray,T TValue)
        {
            foreach(T t in TArray)
            {
                if (t.Equals(TValue)) return true;

            }
            return false;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int[] myint = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            myclass mc = new myclass();
            bool mybool;
            int testInt = 50;

            完整调用
            //mybool = mc.Contains<int>(myint, testInt);

            //简写调用
            mybool = mc.Contains(myint, testInt);
            if (mybool) Console.WriteLine("数组中包含有元素" + testInt);
            else Console.WriteLine("数组中不存在元素" + testInt);

            Console.ReadKey();

        }
    }
}

结果：

数组中不存在元素50