首页 > 代码库 > 蓝鸥Unity开发基础二——课时21 泛型

蓝鸥Unity开发基础二——课时21 泛型

蓝鸥Unity开发基础二——课时21 泛型

本节课我们来学习C#中的泛型,泛型是一个特殊的类型,它可以最大限度的重用我们的代码!

推荐视频讲师博客:http://11165165.blog.51cto.com/

使用泛型能够最大限度的重用代码,保护类型安全,提高性能

泛型成员因为类型的不确定性,不能使用算术运算符,比较运算符

类型参数可以有多个,可以是编译器能够识别的任何类型

类型参数的名字不能够随便起,不能重名

一、数组类Array

 

using System;

namespace Lesson_21
{
    //数组类Array
    public  class Array{

        public  int Count{
            get{
                return _count;
            }
            
        }
        public  void Add(int value){
            _arr[_count]=value;
            _count++;
        }

        public  void log(){
            //当前数组中包含3个元素:(13,76,92
            string str = "当前数组中包含"+Count+"个元素:(";
            for (int i = 0; i < Count; i++) {
                str+=_arr[i];
                if (i<Count-1) {
                    str +=", ";
                }

            }
            str += ")";

        }

        public Array(){
            _arr=new int[100];

        }

        private int[] _arr;
        private int _count=0;
        
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            Array arr = new Array ();
            arr.log ();
            arr.Add(13);
            arr.log ();
            arr.Add(76);            
            arr.log ();
            arr.Add(92);
            arr.log ();


        }
    }
}

二、索引器

using System;

namespace Lesson_21
{
    //数组类Array
    public  class Array{
        
        //索引器
        public int  this [int index] {
            set{
                _arr [index] = value;
                
            }
            get{
                return _arr[index];
            }


        }

        public  int Count{
            get{
                return _count;
            }
            
        }
        public  void Add(int value){
            _arr[_count]=value;
            _count++;
        }

        public  void log(){
            //当前数组中包含3个元素:(13,76,92
            string str = "当前数组中包含"+Count+"个元素:(";
            for (int i = 0; i < Count; i++) {
                str+=_arr[i];
                if (i<Count-1) {
                    str +=", ";
                }

            }
            str += ")";
            Console.WriteLine (str);

        }

        public Array(){
            _arr=new int[100];

        }

        private int[] _arr;
        private int _count=0;
        
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            Array arr = new Array ();
            arr.log ();
            arr.Add(13);
            arr.log ();
            arr.Add(76);            
            arr.log ();
            arr.Add(92);
            arr.log ();

            arr [0] = 26;
            arr.log ();
            Console.WriteLine ("arr[1]="+arr[1]);

        }
    }
}

三、数组中只能存整数,无法存小数的。我们在初始化和参数的时候,都确定了int类型。但是在使用的过程中,我们肯定有存其他类型的,那么我们怎么办?一种方式就是我们复制代码,修改类型,但是这种方式很麻烦。是否有更简便的方式。

大家不要忘记我们这节课的主题——泛型,那么我们就看一下泛型是如何使用的?

using System;

namespace Lesson_21
{
    //使用泛型
    //数组类Array
    //泛型类——需要在类名后加上泛型类型
    //定义的时候需要使用T泛型类型表示任意一种数据类型
    public  class Array<T>{
        
        //索引器
        public T  this [int index] {
            set{
                _arr [index] = value;
                
            }
            get{
                return _arr[index];
            }


        }

        public  int Count{
            get{
                return _count;
            }
            
        }
        public  void Add(T value){
            _arr[_count]=value;
            _count++;
        }

        public  void log(){
            //当前数组中包含3个元素:(13,76,92
            string str = "当前数组中包含"+Count+"个元素:(";
            for (int i = 0; i < Count; i++) {
                str+=_arr[i];
                if (i<Count-1) {
                    str +=", ";
                }

            }
            str += ")";
            Console.WriteLine (str);

        }

        public Array(){
            _arr=new T[100];

        }

        private T[] _arr;
        private int _count=0;
        
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            //泛型当具体使用的时候,才需要实际的类型
            Array<int> arr=new Array<int>();
            arr.log ();
            arr.Add (23);
            arr.log ();
            arr.Add (74);
            arr.log ();
            arr[1] =12;
            arr.log ();


        }
    }
}

 

修改一:存浮点类型

class MainClass
    {
        public static void Main (string[] args)
        {
            //泛型当具体使用的时候,才需要实际的类型
            Array<float> arr=new Array<float>();
            arr.log ();
            arr.Add (23.5f);
            arr.log ();
            arr.Add (74.12f);
            arr.log ();
            arr[1] =12.99f;
            arr.log ();
        } 

修改二:字符串类型

class MainClass
    {
        public static void Main (string[] args)
        {
            //泛型当具体使用的时候,才需要实际的类型
            Array<string> arr=new Array<string>();
            arr.log ();
            arr.Add ("老王");
            arr.log ();
            arr.Add("老张");
            arr.log ();
            arr[1] ="赵四";
            arr.log ();
        } 

课堂源代码:

using System;

namespace Lesson_21
{
    //使用泛型
    //数组类Array
    //泛型类——需要在类名后加上泛型类型
    //定义的时候需要使用T泛型类型表示任意一种数据类型
    //1、使用泛型能够提高代码重用
    //2、使用泛型是,由于类型不确定,所以我们不能使用算术运算符


//    public  class Math<T>{
//        public  T Max(T num1,T num2){
//            return num1 > num2 ? num1 : num2;
            
//        }
        
//    }

    //T ——type
    //S/U/V——234种类型
    //K/V——key/value
    //N——number
    public  class Array<T,S,U,V>{
        
        //索引器
        public T  this [int index] {
            set{
                _arr [index] = value;
                
            }
            get{
                return _arr[index];
            }


        }

        public  int Count{
            get{
                return _count;
            }
            
        }
        public  void Add(T value){
            _arr[_count]=value;
            _count++;
        }

        public  void log(){
            //当前数组中包含3个元素:(13,76,92
            string str = "当前数组中包含"+Count+"个元素:(";
            for (int i = 0; i < Count; i++) {
                str+=_arr[i];
                if (i<Count-1) {
                    str +=", ";
                }

            }
            str += ")";
            Console.WriteLine (str);

        }

        public Array(){
            _arr=new T[100];

        }

        private T[] _arr;
        private int _count=0;
        
    }

    class MainClass
    {
        public static void Main (string[] args)
        {
            //泛型当具体使用的时候,才需要实际的类型
            Array<string> arr=new Array<string>();
            arr.log ();
            arr.Add ("老王");
            arr.log ();
            arr.Add("老张");
            arr.log ();
            arr[1] ="赵四";
            arr.log ();

    
        }
    }
}

 

 

 


蓝鸥Unity开发基础二——课时21 泛型