欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

泛型约束:接口约束、new()构造函数约束、组合约束(即多种约束合并)

程序员文章站 2022-12-09 21:13:03
泛型 接口约束: 普通 单例模式: 上面用到的是类中一个方法来获取类的唯一实例对象 那完全也可以用属性的访问器来初始化一个类的对象啊,如下: 调用的话:var str = Singleton.Instance.Outresult("我是输出内容...."); 综上:两种方式实现单例 泛型 new() ......

泛型 接口约束:

using system;

namespace consoleapp1
{

    /*
     * 
     * 接口约束:where t:interfacename
     * t是类型形参的名称,interfacename是接口名称,
     * 接口约束是  指定某个类型实参必须实现的接口。
     * 它的两个主要的功能和基类约束一样,允许开发人员在泛型类中使用接口中的成员;确保只能使用实现了特定接口的类型实参。
     *  也就是说,对任何给定的接口约束,类型实参必须是接口本身或者是实现了该接口的类。
     *  
     */



    class program
    {
        static void main(string[] args)
        {
            console.writeline(compare<int>.comparedata(3, 12));//12
        }
    }

    /// <summary>
    /// 接口约束,t的类型用icomparable这个接口来约束
    /// 也就是说t的类型就是icomparable接口,用t可以调用它里面的任何方法,只要你愿意,这也就实现了接口约束的目的,即你要使用我这个接口,就必须按照我的规定来!
    /// </summary>
    /// <typeparam name="t"></typeparam>
    public class compare<t> where t : icomparable
    {
        // 定义一个方法,返回值类型为 t , 其两个形参也是t类型的
        // 方法的功能:返回较大值
        public static t comparedata(t n1,t n2)
        {
            // 调用icomparable接口中方法compareto(),这个方法的返回值类型为int
            return n1.compareto(n2) > 0 ? n1 : n2;

            //先不考虑两值相等的时候
        }
    }
}



普通 单例模式:

 

class program
{
    static void main(string[] args)
    {
        //使用单例:类名.静态方法()  <----获取到实例对象,然后再用对象调用它里面的其他方法即可
        var str = singleton.getinstance().outresult("我是输出内容....");
        console.writeline(str);
    }
}


/// <summary>
/// 单例模式-----即一个函数只允许有一个实例对象!
/// </summary>
public class singleton
{
    // 首先定义一个singleton类型的对象(必须静态的,不然调用它还要实例化,相悖了....),intance就是singleton类的唯一实例对象
    public static singleton instance;

    // 一个获取实例对象的方法
    public static singleton getinstance()
    {
        // 只有当singleton类型的对象不存在时(即本类的实例对象),才去创建这样一个对象!
        if (instance == null)
        {
            instance = new singleton();
        }

        return instance;
    }

    // 本类中一个输出方法(测试用的)
    public string outresult(string str)
    {
        return str;
    }
}

上面用到的是类中一个方法来获取类的唯一实例对象

那完全也可以用属性的访问器来初始化一个类的对象啊,如下:

public class singleton
{
    public static singleton instance;

    // 用属性的get访问器 生成单例的对象
    public static singleton instance
    {
        get
        {
            if (instance == null)
            {
                instance = new singleton();
            }
            return instance;
        }

    }
    //其他输出方法......
}

调用的话:var str = singleton.instance.outresult("我是输出内容....");

综上:两种方式实现单例 

 

泛型 new()约束:父类是一个单例类

 

using system;

namespace consoleapp1
{

    /*
     * 
     * new()构造函数约束: where t: new()
     * 它允许开发人员实例化一个泛型类型的对象。
     * new()约束要求类型实参必须提供一个无参数的公有构造函数。
     * 使用new()约束时,可以通过调用该无参构造器来创建对象。
     * 
     * 注意:
     * 1. new()在与其他约束一起使用时,必须放在约束列表的末端
     * 2. 仅允许使用无参构造器构造一个对象,即使同时存在其他的构造器也是如此。即不允许给类型形参的构造器传递实参。
     * 3. 不可以同时使用new()约束和值类型约束。因为值类型都是隐式的提供一个无参公共构造器。就如同定义接口时指定访问类型为public一样,编译器会报错,因为接口一定是public的!!!
     *  
     */



    class program
    {
        static void main(string[] args)
        {
            console.writeline(person.instance.getperson());

            console.writeline(student.instance.getstudent());

            console.writeline(person.instance.outresult());

            console.readkey();
        }
    }


    /// <summary>
    /// 单例模式-----即一个函数只允许有一个实例对象!
    /// </summary>
    public class singleton<t> where t : new()
    {
        private static t instance;

        // 用属性的get访问器 生成单例的对象
        public static t instance
        {
            get
            {
                if (instance == null)
                {
                    // 这里创建的不再是一个singleton对象,而是t对象
                    instance = new t();
                    // 这样写会报错:变量类型 t 没有new()约束,因此无法创建该类型的实例
                    //解决:类上面写new()的约束......
                }
                return instance;
            }
        }

        // 本类中一个输出方法(测试用的)
        public string outresult()
        {
            return "this method in singleton";
        }
    }


    /*
     * 对于继承singleton的类,必须要有一个无参构造器,因为他有new()约束!!! 
     * 
     */

    // person类继承singleton类,就必须指定t的类型,这里指定为person....
    public class person : singleton<person>
    {
        public string getperson()
        {
            return "this method in person class";
        }
    }

    public class student : singleton<student>
    {
        public string getstudent()
        {
            return "this method in student";
        }
    }
}

 

 

 

组合约束:

/*
*    五种约束:
* 
* where t:struct  值类型约束----类型参数必须为值类型
* 
* where t:class   引用类型约束:适用于类、接口、委托、数组等----类型参数必须为引用类型
* 
* where t:new()   new()约束-----类型参数必须有一个公有的无参构造器
* 
* where t:<base class name>   基类约束-----类型参数必须是指定的基类或是派生自指定的基类
* 
* where t:<interface>   接口约束-----类型参数必须是指定接口或实现指定的接口,可以指定多个接口约束,约束接口也可以是泛型的
* 
* 
* 组合约束:用的不多,基本都是别人封装好的,我们拿来直接调用即可
* 同一个类型形参可以使用多个约束。逗号隔开
* 在约束列表中,第一个必须是引用类型约束或者值类型约束,或者是基类约束,然后才是接口约束,最后才是new()约束
* 指定引用类型约束或值类型约束的同时也指定基类约束是非法的
* 
* 例如:
* class test<t> where t : myclass, interface, new(){......}
* 替换t的类型实参必须是继承myclass类,实现interface接口,且拥有一个无参构造器
* 
* 在使用两个或多个类型形参时,也可以使用多条where子句分别为它们指定约束
*  
*/