C#复习基础-2

C#面向对象（OOP）

一、接口

interface接口。
接口成员要全部在调用接口的类中实现。
接口只有属性和抽象方法（方法不能有定义），不能写字段。

 //接口
    public interface InterfaceTest1
    {
        //属性
        string StrDtae1 { get; set; }
        string StrDtae2 { get; set; }
        //方法，抽象方法，没有方法体{}不能使用StrDtae1 等类中成员。
        void Method1(string str1,string str2,ref string resultstr);
        void Method2(string str1, string str2, ref string resultstr);
    }

    //使用接口，要把接口成员全部实现。
    public class Interfacetest11 : InterfaceTest1
    {
        private string str11 = "";
        private string str12 = "";
        string InterfaceTest1.StrDtae1 { get => str12; set => str12=value; }
        string InterfaceTest1.StrDtae2
        {
            get
            {
                return str11;
            }
            set
            {
                str11=value;
            }
        }

        void InterfaceTest1.Method1(string str1, string str2, ref string resultstr)
        {
            resultstr = str1 + str2;
        }
        void InterfaceTest1.Method2(string str1, string str2, ref string resultstr)
        {
            resultstr = str2 + str1;
        }
    }

特殊的IDisposable

    public class DisposeTest : IDisposable
    {
        public string str21 = "";
        string str22 = "";
        public DisposeTest()
        {
            Console.WriteLine("对象创建成功");
        }
        ~DisposeTest()
        {
            Console.WriteLine("对象删除成功");

        }

        public void Dispose()
        {
            Console.WriteLine("对象Dispose");
        }

    }

使用它

using(DisposeTest disposeTest1 = new DisposeTest())
{
      disposeTest.str21 = "1234str210001";  
 }

二、继承

被继承的叫父类（基类），继承的叫派生类。
对象只能派生于一个基类，但基类可以有基类
protected保护访问性，外部类是无法访问，继承类可以访问。
可以对继承的类重写。

  public class parent
    {
        //构造函数，调用Something（）；
        public parent()
        {
            Something();
        }
        //设置为虚拟成员。
        protected virtual void Something()
        {

        }

    }
    //继承parent
    class Child : parent
    {
        private string foo;

        public Child()
        {
            foo = "12345";
        }
        //继承过来的所以也是虚拟的。
        protected override void Something()
        {
            try
            {
                Console.WriteLine(foo.ToLower());
            }
            catch (Exception ex)
            {
                Console.WriteLine("错了"+ex.ToString());
            }

        }
    }

实例化Child对象

 //初始化实例对象。会进入异常,因为foo为null，parent类的构造函数调用的Something（）是Child（）的；
  Child child = new Child();

可以知道， 对象的基础构造函数在其自己的构造函数之前被调用 。
通过在对象的构造函数中进行virtual调用，您将引入一种可能性，即继承对象将在代码完全初始化之前执行代码。

抽象类（必须在派生类重写的），用abstract修饰的类，即抽象类；用abstract修饰的方法，即抽象方法。
抽象方法不能再普通类，类要在抽象类。
类可以密封，密封的类不能作为基类。

三、多态

派生类变量可以赋值给基本类

class Program
    {
        static void Main(string[] args)
        {
            AAA aAA = new AAA();
            BBB bBB = new BBB();
             //par不能为其他的如BBB类型。否则转化失败报错。
            pareat par = aAA;
            par.StrADD("234", "345");
            
            AAA aA = (AAA)par;
            aA.StrADD("123", "456");

            Console.ReadKey();
        }
    }
    public class pareat
    {
        //属性
        protected string StrTest1 { get; set; }
        //字段
        protected string StrTest2 = "";
        //方法
        public void StrADD(string str1, string str2)
        {
            Console.WriteLine("StrADD" + str1 + str2);
        }
        抽象方法  用abstract修饰的类，即抽象类；用abstract修饰的方法，即抽象方法。抽象方法所在类要为抽象类。
        //protected abstract void Stradd(string str1, string str2, ref string resultst);
    }
    public class AAA : pareat
    {
        public void AA(string straa)
        {
            Console.WriteLine("AA" + straa + straa);
        }
        public void StrADD(string str1)
        {
            Console.WriteLine("StrADDAA" + str1 + str1 + str1);
        }
    }
    public class BBB : pareat
    {
        public void BB(string strbb, ref string resuStraaaa)
        {
            Console.WriteLine("BB" + strbb + strbb+ strbb+ strbb);
        }
        public void StrADD(string str1)
        {
            Console.WriteLine("StrADDBB" + str1 + str1+str1);

        }
    }

接口多态
派生类会继承基类的接口。

 class Program
    {
        static void Main(string[] args)
        {
          //实例化两个对象
            DDD dDD = new DDD();
            EEE eEE = new EEE();
            //建立接口类型变量
            CCC cCC;
            //以相同的方式访问多个变量
            cCC = dDD;
            cCC.Method1("123", "456");
            cCC = eEE;
            cCC.Method1("123", "456");
            Console.ReadKey();
        }
    }
    //接口CCC
interface CCC
    {
        //方法，抽象方法，没有方法体{}。
        void Method1(string str1, string str2);
    }

    public class DDD:CCC
    {
        void CCC.Method1(string str1, string str2)
        {
            Console.WriteLine("DDD:CCC" + str1 + str2);
        }
      
    }
    public class EEE : CCC
    {
        void CCC.Method1(string str1, string str2)
        {
            Console.WriteLine("EEE:CCC" + str1 + str2);
        }

    }

四、对象关系

包含
一个类包含另一个类。我的理解就是类中实例化了另一个类。有着这个类的变量。
集合
存储多个类的变量。