C# BASIC

        public //任何类访问
        protected //声明类和派生类访问
        private //类内部访问

        string[] array1=new string[1,2,4];
        foreach(string str  in array1)
       
        break 跳出当前循环
        contiune 跳过当前循环 执行下一循环
        值类型 int 结构
        引用类型  类 接口 数组 string(用法是值类型)

        装箱 值类型 到 引用类型的转换
        取消装箱 引用类型 到 值类型的转换
        静态成员static 实例化后看不见static
        结构 struct 不能继承 值类型

        静态构造函数不能有访问修饰符和参数 static className(){}

        重载  指定不同个数参数 不同参数类型(返回值不同)
        密封类 sealed class className(){}  不可继承

        重写(new 父类方法)  可以有不用的返回值 参数和个数必须一致，否则便成了重载(不需要关键字 new )

       重写 override 不可以有不用的返回值 参数和个数必须一致

using System;

namespace tran5
{
    class SecondExp
    {
        public int firstMethod()
        {
            return(secondMethod()*thirdMethod());
        }
        public virtual int secondMethod() //没有执行父类的 直接执行override
        {
            return(10);
        }
        public int thirdMethod()
        {
            return(20);
        }


        //重写的测试
        public int rewrite_firstMethod()
        {
            return(rewrite_secondMethod()*rewrite_thirdMethod());
        }
        public int rewrite_secondMethod()
        {
            return(10);
        }
        public int rewrite_thirdMethod()
        {
            return(20);
        }
    }

    class DerivedClass:SecondExp
    {
        public override int secondMethod()
        {
            return(30);
        }

        //重写的测试
        new public int rewrite_secondMethod() //没有执行  不会调用不同名的方法 objDerived.rewrite_firstMethod() 
        {
            Console.WriteLine("new");
            return(30);

        }
        //new public int rewrite_firstMethod() //会执行  如果rewrite_firstMethod重写了
        //{
        //    return (rewrite_secondMethod() * rewrite_thirdMethod());
        //}
    }

    class Test_1
    {
        public static void Main()
        {
            DerivedClass objDerived = new DerivedClass();
            //Console.WriteLine(objDerived.firstMethod());

            //重写的测试
            Console.WriteLine(objDerived.rewrite_firstMethod());
        }
    }
}

//带参数的构造函数使用

public class A_Class
    {
        public string temp_str="";
        public A_Class(string input_str)
        {
            temp_str = input_str;
        }
    }

    public class B_Class:A_Class
    {
        public string temp_str_son="";
        public B_Class(string input_str1,string input_str2):base(input_str1)
        {
            temp_str_son = input_str2;
        }
    }

    public class C_Class
    {
        public static void Main()
        {
            B_Class temp_obj = new B_Class("aaaa","bbbb");
            Console.WriteLine("属性temp_str：" + temp_obj.temp_str);
            Console.WriteLine("属性temp_str_son：" + temp_obj.temp_str_son);
        }
    }

        多态 父类 virtual 虚函数(不能有 static override abstract) 
             子类 override(new static virtual ) 父类 = new 子类

using System;

namespace tran5
{
    public class ShapeObj
    {
        public virtual void area()
        {
            Console.WriteLine("这是一个虚Area方法");
        }

        public void test()
        {
            Console.WriteLine("测试重写!");
        }
    }

    public class Circle:ShapeObj
    {
        public override void area()
        {
            Console.WriteLine("这是Circle的Area()方法");
        }
    }

    public class Rectangle:ShapeObj
    {
        public override void area()
        {
            Console.WriteLine("这是Rectangle的Area()方法");
        }
    }

    public class Square:ShapeObj
    {
        public override void area()
        {
            Console.WriteLine("这是Square的Area()方法");
        }

        new public void test()
        {
            Console.WriteLine("11111111!");
        }
    }

    public class PolymorphismExp
    {
        public static void Main()
        {
            //派生类可以隐试的转换为父类，反之则不可。Circle cobj = (Circle)new ShapeObj();  错误
            ShapeObj sobj = new Circle(); //obj 是 new class 的对象
            sobj.area();
            //ShapeObj[] objArray = new ShapeObj[4];
            //objArray[0] = new ShapeObj();
            //objArray[1] = new Rectangle();
            //objArray[2] = new Circle();
            //objArray[3] = new Square();

            //foreach(ShapeObj interateArray in objArray)
            //{
            //    interateArray.area();
            //}

            //objArray[3].test();
        }
    }
}

        抽象基类 不能被实例化 abstract
        除了包含抽象方法 还可有已实现的方法 用abstract标记为抽象方法
        实现 override 方法名参数相同

using System;

namespace tran5
{
    abstract class BaseClass
    {
        //抽象方法在继承类中必须实现
        public abstract void abstractFunc();

        
        //public abstract void abstractFunc_1();

        public void nonAbstractFunc()
        {
            Console.WriteLine("这是nonAbracFunc()方法！");
        }
    }

    class DerivedClass_1:BaseClass
    {
        public override void abstractFunc()
        {
            Console.WriteLine("这是abstractFunc方法！");
        }
    }

    class Test_2
    {
        static void Main()
        {
            DerivedClass_1 objDerived = new DerivedClass_1();
            BaseClass objBase = objDerived;
            objBase.abstractFunc();
            objDerived.abstractFunc();

        }
    }
}

接口

//接口成员隐式地具有 public 已声明可访问性。在接口成员声明中不允许使用访问修饰符。 
        public interface IFile
        {
            int delFile();
            void disFile();
        }

using System;

namespace tran5
{
    public interface IFile_3
    {
        void disFile();
    }

    public interface IFileTwo_1
    {
        void disFile();
    }

    public class MyFile_3:IFile_3,IFileTwo_1
    {
        void IFile_3.disFile()
        {
            Console.WriteLine("IFile的DisFile实现！");
        }

        void IFileTwo_1.disFile()
        {
            Console.WriteLine("IFileTwo的DisFile实现！");
        }

    }

    public class Test_5
    {
        public static void Main()
        {
            //显示接口使用的方法不同  //派生类可以隐试的转换为父类 这里是 显示不是隐试
            IFile_3 objMyFile = new MyFile_3();
            objMyFile.disFile();

            IFileTwo_1 objMyFile1 = new MyFile_3();
            objMyFile1.disFile();
        }
    }
}

委托事件

class Test_222222
    {
        public static void Main()
        {
            Test_222222 objA = new Test_222222();
            Dele dele = new Dele();
            dele.myevent += new Dele.myDele(objA.my_method);
            dele.fun(true);
        }

        public void my_method(bool flag)
        {
            if (flag == true)
            {
                Console.WriteLine("触发了事件，传入了True");
            }
            else
            {
                Console.WriteLine("触发了事件，传入了False");
            }
        }
    }

    class Dele
    {
        public delegate void myDele(bool flag); //定义委托
        public event myDele myevent;            //定义事件
        public void fun(bool flag)              //触发事件
        {
            myevent(flag);
        }
    }