第十四章 C# 基础接口密封泛型

努力写代码的一天

已于 2023-08-10 14:17:27 修改

阅读量88

点赞数

文章标签： c# 开发语言

于 2023-08-09 17:40:34 首次发布

本文链接：https://blog.csdn.net/qianduan2001_5/article/details/132192072

版权

一.接口

接口定义：所有继承接口时应遵循的语法合同（接口定义那些功能继承的类就要实现功能）

作用：用接口可以使程序更加清晰和条理化

1.接口使用interface 关键字声明它与类的声明类似接口声明默认是public的

2.接口只包含了成员的声明（方法属性）

3.不允许声明成员上的修饰符及时是public都不行因为接口成员重视公有的

4.不能声明为虚拟和静态的成员

interface IMyinterface
    {
        int Age { get; set; }
        void IMyinterfaceMothod();
    }

5.接口中定义的成员需要类继承来实现类的继承关系要在接口继承之前

    //  public class MyClass :IMyinterface
public class MyClass :Object ,IMyinterface {
       public int Age { get; set; }

       public void IMyinterfaceMothod() {

            Console.WriteLine("123");
        }

    }


    //类继承 类继承接口
    public class MyClass1 { 
    
        
    
    }
    public class MyClass2 :MyClass1, IMyinterface 
    {

        public int Age { get; set; }

        public void IMyinterfaceMothod()
        {

            Console.WriteLine("123");
        }

    }

6.接口也可以继承接口

 interface IMyInterFace1 {

        int Age1 { get; set; }
        void IMyinterfaceMothod1();

    }
    //接口继承接口
    interface IMyInterFace2:IMyInterFace1,IMyInterFace3
    {

        int Age2 { get; set; }
        void IMyinterfaceMothod2();

    }

    interface IMyInterFace3
    {

        int Age3 { get; set; }
        void IMyinterfaceMothod3();

    }

7.一个类可以继承多个接口（接口就是c#实现多继承的方式）

// public interface MyClass3:Object,IMyInterFace2 { }
    public class MyClass3:IMyInterFace2 {

        public int Age1 { get; set; }

        public void IMyinterfaceMothod1()
        {

            Console.WriteLine("123");
        }
        public int Age2 { get; set; }

        public void IMyinterfaceMothod2()
        {

            Console.WriteLine("123");
        }
        public int Age3 { get; set; }

        public void IMyinterfaceMothod3()
        {

            Console.WriteLine("123");
        }
    }

二.密封类

1.密封类可以用限制继承性

2.声明密封类是需要使用sealed关键字

3.密封类和普通类一样都可以定义属性和方法

4.密封类不能作为基类被继承但它可以继承别的类或接口

5.密封类可以实例化对象系统中String就是密封类

6.密封类中不能声明受保护的成员或虚成员

调用：

  SealedClass sealedClass = new SealedClass();

方法：

  public class Class1
    {
    }
    interface IMyIterFace { 
    
    
    }
    public sealed class SealedClass:Class1,IMyIterFace 
    {


        private int _age;
        public int Age { get { return _age; } set { _age = value; } }

        public SealedClass() { 
        
        
        }

        public void SealedClassMothod() { 
        
        
        }
}

      //  public class MyClass :SealedClass{}

三.泛型

允许我们延迟编写类或者方法中的数据类型

直到真正使用时确定类型的一种规范

1.可以创建直接的泛型接口，泛型类，泛型方法，泛型集合，泛型事假，和泛型委托

2.泛型的格式：结构<泛型的名称> 在定义泛型是T通常用作变量类型名称但实际上T可以用任何有效名称代替

3.泛型方法在定义是提供泛型的类型在调节方法时提供具体的延迟编写类型

4.泛型无法直接使用运算符比如 + - < > 等但是能使用 Object中的属性和方法、

调用

  MyClass myClass = new MyClass();
            myClass.MyClassMothod<int>(10);
            myClass.MyClassMothod<string>("zifuchuan");
            myClass.MyClassMothod<float>(200.0f);
            myClass.MyClassMothod<MyClass>(new MyClass());

            bool isTrue = myClass.MyClassMothod1<bool>(true,false);
            MyClass myClass1 = myClass.MyClassMothod1<MyClass>(new MyClass(),new MyClass());

            int aNumber =   myClass.MyClassMothod5<int, string>(10, "123");

            //创建泛型类的对象
            MyClass1<int> myClass11 = new MyClass1<int>();
            myClass11.Age = 18;
            int bNumber=    myClass11.MyClass1Mothod();


            MyClass1<string> myClass111 = new MyClass1<string>();
            myClass111.Age = "123";
            string bNumber1 = myClass111.MyClass1Mothod();


            MyClass3 myClass3  = new MyClass3();
            myClass3.Age = 20;
            string cStr =   myClass3.MyClass1Mothod();


            MyClass4<float> myClass4 = new MyClass4<float>();
            myClass4.Name = 18.1f;
            myClass4.Age = "123";
            int dNumber=  myClass4.MyClass1Mothod();

方法

public class MyClass {

        //普通类型
        //public void MyClassMothod(int a) {
        //    Console.WriteLine(a);
        //}
        //泛型方法的定义
        public void MyClassMothod<T>(T a)
        {
            Console.WriteLine(a);
        }
        public T MyClassMothod1<T>(T a, T b)
        {

            Console.WriteLine(a);
            Console.WriteLine(b);
            return a;
        }

        public W MyClassMothod3<W>(W a)
        {
            return a;
        }
        public 狗 MyClassMothod4<狗>(狗 a)
        {
            return a;
        }

        public T MyClassMothod5<T,W>(T a, W b) { 
        
            return a;
        }
    }


    //泛型类
    public class MyClass1<T> 
    {

        private T _age;
        public T Age { get; set; }

        public T MyClass1Mothod() {
            //解决T 泛型的 默认值问题
            T a = default(T);
            return  a; 
        }
    }


    public class MyClass2<T, D> {

        public T Age { get; set; }
        public D MyClass1Mothod()
        {
            //解决T 泛型的 默认值问题
            D a = default(D);
            return a;
        }
    }
    //普通类继承泛型类
    public class MyClass3:MyClass2<int ,string> { 
    
    
    }
    //泛型类继承泛型类
    public class MyClass4<T>:MyClass2<string,int> {

        public T Name { get; set; }

    }

四.泛型的接口

 //泛型接口

    interface IMyInterFace<T>{
        int IMyInterFaceMothod();
        T IMyInterFaceMothod1();
        void IMyInterFaceMothod1(T a);
    }
    interface IMyInterFace2<T,D>
    {
        T IMyInterFace2Mothod1(D a);
    }
    interface IMyInterFace3<T, D> :IMyInterFace2<string,int>
    {
        T IMyInterFace3Mothod1(D a);
    }
    interface IMyInterFace1
    {
        int IMyInterFace1Mothod();
        void IMyInterFace1Mothod1();
        void IMyInterFace1Mothod1(string a);
    }
    class MyClass1:IMyInterFace<string>,IMyInterFace1,IMyInterFace3<float,int> {

      public  int IMyInterFaceMothod() {
            return 1;
        }
        public string IMyInterFaceMothod1() {

            return "123";
        }
       public void IMyInterFaceMothod1(string a) {

            Console.WriteLine(a);
        }


        public int IMyInterFace1Mothod() {

            return 1;
        }
        public void IMyInterFace1Mothod1() { 
        
                
        }
        public void IMyInterFace1Mothod1(string a) { 
        
            
        }
        public float IMyInterFace3Mothod1(int a) {

            return a;
        }

        public string IMyInterFace2Mothod1(int a) { 
        
           return a.ToString();
        
        }
    }