CSharp--复习篇

复习内容：

包括了：CSharp入门、基础、核心所有知识点，CSharp核心还行学习中！

多阅读！！！

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Lesson000_复习
{
    //枚举
    enum E_Animal
    {
        Cat,
        Dug,
        Tige,
        Fish,
    }

    //结构体
    struct Test3
    {
        //成员变量
        int i;
        public string name;
        private bool bo;
        int[][] arr;

        //构造函数
        public Test3(int i, string name, bool bo, int[][] arr)
        {
            this.i = i;
            this.name = name;
            this.bo = bo;
            this.arr = arr;
        }

        //成员方法
        public void Speak()
        {

        }

        //索引器
        public int this[int num, int num2]
        {
            get
            {
                return arr[num][num2];
            }
            set
            {
                arr[num][num2] = value;
            }
        }

    }

    //类
    partial class Test
    {
        //特征--成员变量
        public int i;
        public string smile;
        private Test[] tests;
        protected int[][] arr;

        //行为--成员方法
        public void Speak()
        {
            Console.WriteLine("Test 自身方法");
        }

        //构造函数
        public Test()
        {

        }

        public Test(string name)
        {

        }

        //成员属性
        public int I
        {
            get
            {
                //写上相应的逻辑
                return 0;
            }
            set
            {
                //相应的逻辑
            }
        }

        public string Str
        {
            get;
            set;
        }

        //析构函数
        ~Test()
        {

        }

        //索引器
        public Test this[int index]
        {
            get
            {
                return tests[index];
            }
            set
            {
                tests[index] = value;
            }
        }

        public int this[int num, int num2]
        {
            get
            {
                return arr[num][num2];
            }
        }

        //静态方法
        //static
        public static void AA()
        {

        }

        static void BB()
        {
            //静态方法里面只能使用静态成员
        }

        //运算符重载
        //一定是静态的
        //相关符号成对出现
        //可以有重载
        //不能使用ref和out
        public static Test operator +(Test t1, Test t2)
        {
            Test t = new Test();
            t.i = t1.i + t2.i;
            return t;
        }

        public static Test operator -(Test t1, int i)
        {
            Test t = new Test();
            t.i = t1.i - i;
            return t;
        }

        public static Test operator ++(Test t1)
        {
            Test t = new Test();
            t.i = ++t1.i;
            return t;
        }

        public static bool operator !(Test t1)
        {
            return false;
        }

        public static Test operator &(Test t1, Test t2)
        {
            return null;
        }

        public static Test operator ^(Test t1, Test t2)
        {
            return null;
        }

        public static Test operator ~(Test t1)
        {
            return null;
        }

        public static Test operator <<(Test t1, int i)
        {
            return null;
        }

        //内部类
        //加public 外面才能调用
        public class Test00
        {
            public void Speak()
            {
                Console.WriteLine("内部Test00的 Speak方法");
            }
        }


    }

    //继承
    class Lesson : Test
    {
        string name;

        public Lesson(string name) : base(name)
        {

        }
    }

    //分部类
    //partial
    partial class Test
    {
        public void Run()
        {

        }

        //分部方法
        //了解即可
    }

    //拓展方法--写静态类中

    //静态类和静态构造函数
    static class Test2
    {
        //不能被实例化
        //只包含静态成员
        //把常用的静态方法写到静态类里，相当于是个工具包
        static string name;
        static int num;

        //静态构造函数
        static Test2()
        {
            //1.静态类和普通类都可以申明静态构造函数
            //2.不能加修饰符
            //3.不能有参数
            //4.只会调用一次
            //作用：参数静态变量
            name = "Sunset";
            num = 20;
        }

        //拓展方法
        //访问修饰符 static 返回类型 函数名(this 拓展类名 参数名, 参数类型 参数名, 参数类型 参数名)
        public static void TestInt(this int te)
        {
            Console.WriteLine("int的拓展方法");
        }

        public static void SpeakTest(this Test test, string str, string str2)
        {
            Console.WriteLine("Test 的拓展方法");
            Console.WriteLine("调用本方法的对象：" + test);
            Console.WriteLine("传入的参数：" + str + str2);
            //return test;
        }

    }

    #region object--普通方法MemberwiseClone相关
    class Cat
    {
        public int ii = 1;
        public Dug dug = new Dug();

        public Cat Clone()
        {
            return MemberwiseClone() as Cat;
        }
    }

    class Dug
    {
        public int dd = 2;
    }
    #endregion


    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("复习");

            #region CSharp入门--复习
            //变量类型
            //有符号整形： sbyte  short  int  long
            //无符号整形： byte  ushort  uint  ulong
            //浮点数： float  double decimal
            //特殊类型：char bool string

            //常量 -- const
            const int num1 = 1;

            //转义字符
            // \t  \n  \a--警报音  \b--光标退格  \0--空字符  \'  \"  \\--调用文件路径时会使用到
            // 取消转义字符： 前面加 @

            //类型转换 -- 强转
            //括号强转 -- 丢失精度
            long l = 1;
            int i = (int)l;
            //Parse法 -- 把字符串类型转为对应类型
            int i2 = int.Parse("12");
            //Convert法
            sbyte sb = Convert.ToSByte(l);
            short s = Convert.ToInt16(l);
            int i3 = Convert.ToInt32(l);
            long l2 = Convert.ToInt64(i3);

            byte b = Convert.ToByte(l);
            ushort us = Convert.ToUInt16(l);
            uint ui = Convert.ToUInt32(l);
            ulong ul = Convert.ToUInt64(ui);

            float f = Convert.ToSingle(l);
            double d = Convert.ToDouble(l);
            decimal de = Convert.ToDecimal(l);

            char c = Convert.ToChar(l);
            Console.WriteLine(c);
            bool bo = Convert.ToBoolean(l);
            Console.WriteLine(bo);
            string str = Convert.ToString(l);

            //其他类型转字符串
            str = l + "";
            str = bo.ToString();
            Console.WriteLine(str);

            //位运算
            //位与 &  -- 用零为零，全1为1
            int i4 = 3;
            int i5 = 5;
            int i6 = i4 & i5;

            //位或 |  --有1为1，全0为0
            i6 = i4 | i5;

            //异或 ^  --不同为1，相同为0
            i6 = i4 ^ i5;

            //位取反 ~
            i6 = ~i5;

            //位 左移 <<  右移 >>
            i6 = i5 << 2;
            i6 = i5 >> 2;


            #endregion

            #region CSharp基础--复习
            //枚举  enum E_枚举名
            E_Animal animal = E_Animal.Dug;
            switch (animal)
            {
                case E_Animal.Cat:
                    break;
                case E_Animal.Dug:
                    break;
                case E_Animal.Tige:
                    break;
                case E_Animal.Fish:
                    break;
                default:
                    break;
            }

            int num = (int)animal;
            Console.WriteLine(num);
            string str1 = animal.ToString();
            Console.WriteLine(str1);
            animal = (E_Animal)E_Animal.Parse(typeof(E_Animal), "Cat");
            Console.WriteLine(animal);

            //ref 和 out
            //ref 在函数内部赋值
            //out 在传入函数内时要先赋值

            //变长参数 -- params

            //递归  函数自己调用自己
            Test2(0);

            //结构体

            //冒泡排序
            int[] arrs = new int[] { 12, 45, 2, 6, 77, 44, 36, 54, 23 };
            int temp = 0;
            for (int j = 0; j < arrs.Length - 1; j++)
            {
                for (int k = 0; k < arrs.Length - 1 - j; k++)
                {
                    if (arrs[k] > arrs[k + 1])
                    {
                        temp = arrs[k];
                        arrs[k] = arrs[k + 1];
                        arrs[k + 1] = temp;
                    }
                }
            }

            for (int j = 0; j < arrs.Length; j++)
            {
                Console.WriteLine(arrs[j]);
            }

            //选择排序
            int[] arrs2 = new int[] { 12, 45, 2, 6, 77, 44, 36, 54, 23 };
            
            for (int j = 0; j < arrs2.Length; j++)
            {
                temp = 0;
                //找出最大值
                for (int k = 1; k < arrs2.Length - j; k++)
                {
                    if(arrs2[temp] < arrs2[k])
                    {
                        temp = k;
                    }
                }

                //交换位置
                if (temp != arrs2.Length - 1 - j)
                {
                    int box = arrs2[temp];
                    arrs2[temp] = arrs2[arrs2.Length - 1 - j];
                    arrs2[arrs2.Length - 1 - j] = box;
                }
            }

            for (int j = 0; j < arrs2.Length; j++)
            {
                Console.WriteLine(arrs2[j]);
            }

            #endregion

            #region CSharp核心--复习

            #region 封装知识点
            Test test00 = new Test();
            test00.Speak();
            test00.SpeakTest("Sunset", "Sunrise");

            Test.Test00 tt = new Test.Test00();
            tt.Speak();

            #endregion

            #region 继承知识点
            //里氏替换原则

            //继承中的构造函数

            //万物之父和装箱拆箱
            //装箱
            object oi = 1;
            //拆箱
            int num3 = (int)oi;

            //密封类
            //sealed
            //让类无法再被继承

            #endregion

            #region 多态知识点
            //多态-- vob
            //virtual--虚函数
            //override -- 重写
            //base -- 父类

            //抽象类和抽象方法
            //abstract
            //不能被实例化
            //抽象方法只能在抽象类中申明，不能有方法体，又叫纯虚方法
            //继承了抽象类就必须实现里面的抽象方法

            //接口
            //interface
            //可以包含：成员属性、成员方法、索引器、事件，但都不能去实现，都没有访问修饰符
            //继承了就要实现接口里的所有成员

            //密封方法
            //sealed
            //不让重写

            #endregion

            #region 面向对象关联知识点
            //命名空间
            //namespace
            //不同命名空间中相互调用，需要用 using 引出命名空间，或指明出处

            //万物之父中的方法
            //object中的静态方法
            //静态方法：Equals
            //若是值类型就比较值
            //若是引用类型就比较地址
            int num4 = 1;
            int num5 = 1;
            //Console.WriteLine(num4.Equals(num5));  java 的写法
            Console.WriteLine(Object.Equals(num4,num5));
            Console.WriteLine(Equals(num4,num5)); //也可以这样写
            Test test1 = new Test();
            Test test2 = new Test();
            //test2 = test1;
            //Console.WriteLine(test1.Equals(test2));
            Console.WriteLine(object.Equals(test1,test2));
            Console.WriteLine(Equals(test1,test2));

            //静态方法：ReferenceEquals
            //比较两个对象是否是相同的引用，主要是用来比较引用类型的对象
            //值类型对象返回值始终是false
            Console.WriteLine(object.ReferenceEquals(num4, num5));
            Console.WriteLine(ReferenceEquals(test1, test2));

            //object中的成员方法
            //GetType  -- 反射相关知识点后面会学习到

            //MemberwiseClone
            //该方法用于获取对象的浅拷贝对象，就是会返回一个新对象
            //注意点：但新对象中的引用变量会和老对象中一致
            //下面例子解析：得到克隆体后，改变克隆体的值类型和引用类型
            //发现本体的值类型没有发生改变，但引用类型随着克隆体变化了
            Cat cat = new Cat();
            Cat cat2 = cat.Clone();
            Console.WriteLine("克隆对象后");
            Console.WriteLine("cat.ii = " + cat.ii);
            Console.WriteLine("cat.dug.dd = " + cat.dug.dd);
            Console.WriteLine("cat2.ii = " + cat2.ii);
            Console.WriteLine("cat2.dug.dd = " + cat2.dug.dd);

            cat2.ii = 20;
            cat2.dug.dd = 21;
            Console.WriteLine("改变克隆体信息后");
            Console.WriteLine("cat.ii = " + cat.ii);
            Console.WriteLine("cat.dug.dd = " + cat.dug.dd);
            Console.WriteLine("cat2.ii = " + cat2.ii);
            Console.WriteLine("cat2.dug.dd = " + cat2.dug.dd);

            //object中的虚方法
            //Equals  -- 可以自定义判断规则
            //GetHashCode  -- 用的少
            //ToString  -- 打印方法

            //String
            //字符串本质上是char数组
            string str2 = "山高路远";
            //转char数组 -- ToCharArray
            char[] ch = str2.ToCharArray();
            //字符串拼接 -- Format
            str2 = string.Format("{0}{1}", "123", "321");
            Console.WriteLine(str2);
            //str2 = string.Format("111");
            //Console.WriteLine(str2);

            //正向查询字符位置 -- IndexArray
            //若是没有查找到会返回 -1
            str2 = "向日葵的花语";
            int index = str2.IndexOf("花");
            Console.WriteLine(index);//4

            //反向查找字符位置 -- LastIndexArray
            index = str2.LastIndexOf("花");
            Console.WriteLine(index);//4

            //移除指定位置后面的所有字符 -- Remove
            str2 = str2.Remove(3);
            Console.WriteLine(str2);//向日葵
            //指定位置和个数的写法 -- (位置,个数)
            str2 = "向日葵的花语集";
            str2 = str2.Remove(3, 2);
            Console.WriteLine(str2);//向日葵语集

            //替换指定位置 -- Replace
            str2 = "向日葵的花语集";
            str2 = str2.Replace("花语", "太阳花");
            Console.WriteLine(str2);//向日葵的太阳花集

            //大小写转换 -- ToUpper 大  ToLower 小
            str2 = "you know？";
            str2 = str2.ToUpper();
            Console.WriteLine(str2);//YOU KNOW?
            str2 = str2.ToLower();
            Console.WriteLine(str2);

            //字符串截取 -- Substring
            //一个参数--截取从指定位置开始之后的字符串
            str2 = "向日葵的花语集";
            str2 = str2.Substring(4);
            Console.WriteLine(str2);//花语集
            //两个参数-- 开始位置、指定个数
            str2 = "向日葵的花语集";
            str2 = str2.Substring(1, 5);
            Console.WriteLine(str2);//日葵的花语

            //字符串切割 -- Split
            str2 = "向|日|葵|的|花|语|集";
            string[] strs = str2.Split('|');
            for (int j = 0; j < strs.Length; j++)
            {
                Console.WriteLine(strs[j]);
            }



            //StringBuilder
            StringBuilder str0 = new StringBuilder("虽九死其犹未悔");
            Console.WriteLine(str0);
            //获取容量 -- Capacity
            Console.WriteLine(str0.Capacity);
            //获取长度
            Console.WriteLine(str0.Length);
            //增 -- Append
            str0.Append("12345");
            Console.WriteLine(str0);
            Console.WriteLine(str0.Capacity);
            Console.WriteLine(str0.Length);
            str0.AppendFormat("{0}{1}", "678", "987");
            Console.WriteLine(str0);
            Console.WriteLine(str0.Capacity);
            Console.WriteLine(str0.Length);

            //插入 -- Insert
            str0.Insert(3, "--");
            Console.WriteLine(str0);

            //删除 -- Remove
            str0.Remove(2, 1);
            Console.WriteLine(str0);//虽九--其犹未悔12345678987

            //清除 -- Clear
            //str0.Clear();
            //Console.WriteLine(str0);

            //查
            Console.WriteLine(str0[5]);

            //替换 -- Replace
            str0 = str0.Replace("九", "？");
            Console.WriteLine(str0);

            //结构体和类的区别

            //抽象类和接口的区别

            #endregion


            #endregion

        }

        //变长参数
        public void Test(string name, char ch, params int[] arrays)
        {

        }

        //递归
        public static void Test2(int i)
        {
            Console.WriteLine(i);
            ++i;
            if (i < 10)
            {
                Test2(i);
            }
        }

    }
}

告诫自己的：

多回来看看！

2024.1.10