浅尝C艹艹

using Microsoft.Win32;
using System;//unsing指令 让我们的程序包含System的应用空间
using System.Threading.Channels;

namespace HelloWorldApplication {//声明了一个 命名空间
    class Recttangle
    {
        double length;
        double width;
        public void Acceptdetails()
        {
            length = 4.5;
            width = 3.5;
        }
        public double GetArea()
        {
            return length * width;
        }
        public void Display()
        {
            Console.WriteLine("Length:{0}", length);
            Console.WriteLine("Width:{0}", width);
            Console.WriteLine("Area:{0}", GetArea());
        }
    }
    class Helloworld//声明了一个 类
    {                //
        static void Main(string[] args)//这里是Main方法，C#程序的入口点
        {       //顺带一提，Static 是静态 Void是空，也就输静态空
            //为什么用静态空？原因很简单，这里是主方法，TA不需要返回任何值给谁，所以使用静态空
            /* C#练习 */
            Console.WriteLine("你好，C#！");
            Console.WriteLine("你好，Visual Studio!");
            //vs直接敲cw就可以出现 Console.WriteLine了
            //WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法
            Recttangle r = new Recttangle();//实例化这个类  盲猜是因为同一文件，所以就可以直接实例化上面那个类
            r.Acceptdetails();//调用方法
            r.Display();//方法


            //C#的数据类型
            //bool byte char decimal double float int long sbyte short uint ulong ushort
            //无符号整数被减会怎么样呢？
            //不同类型的数字可以一起运算吗？
            bool BoolOne = true;
            byte ByteOne = 6, ByteTwo = 5;
            char CharOne = 'a';
            char CharTwo = 'b';
            decimal DecimalOne = 0.0M;
            double DoubleOne = 111.111;
            float FloatOne = 111.111F;
            int IntOne = 111;
            long LongOne = 111;
            sbyte SbyleOne = 127;
            short ShortOne = 3456;
            uint UintOne = 111;
            ulong ulongOne = 222;
            ushort ushortOne = 333;

            Console.WriteLine("这是布尔类型:"+BoolOne);
            Console.WriteLine("这是byte类型："+ByteOne+ByteTwo);
            Console.WriteLine("这是字符类型:"+CharOne+CharTwo);
            Console.WriteLine("这是decimal类型："+DecimalOne);
            Console.WriteLine("这是Double类型："+DoubleOne);
            Console.WriteLine("这是Folat类型："+FloatOne);
            Console.WriteLine("这是Int类型："+IntOne);
            Console.WriteLine("这是long类型："+LongOne);
            Console.WriteLine("这是sbyte类型："+SbyleOne);
            Console.WriteLine("这是short类型："+ShortOne);
            Console.WriteLine("这是unit类型："+UintOne);
            Console.WriteLine("这是ulong类型:"+ulongOne);
            Console.WriteLine("这是ushort类型:"+ushortOne);
            Console.WriteLine("\n");//由于本身WirteLine就自动带一个\n，这样子就一下子空两行了。

            double DoubleThree = 3.3333;
            //先声明再初始化是良好的写法。
            int NumberOne;
            int NumberTwo;
            int NumberThree;

            NumberOne=111;
            NumberTwo=222;
            NumberThree=333;

            Console.WriteLine("随便输出几个数字:"+NumberOne+NumberTwo+NumberThree);
            Console.WriteLine("随便输出一个强制类型转换的数字:"+(int)DoubleThree);

            Console.WriteLine("输出字符串{0}", "啊输出字符串");
            Console.WriteLine("浅记一下逻辑运算符：");

            bool BoolTwo = false;
            bool BoolThree = false;
            bool BoolFour = false;

            if (NumberThree>NumberTwo)
            {
                BoolTwo = true;
            }
            if (NumberTwo>NumberOne)
            {
                BoolFour = true;
            }
            Console.WriteLine(BoolFour&&BoolTwo);
            Console.WriteLine(BoolFour&&BoolThree);
            Console.WriteLine(BoolFour||BoolThree);
            Console.WriteLine(!(BoolTwo && BoolThree));
            //差不多就这样了 ，接下来是位运算

            //One = 0011 1100
            //Two = 0000 1101
            int BitwiseNumberOne = 60;
            int BitwiseNumberTwo = 13;

            Console.WriteLine(BitwiseNumberOne&BitwiseNumberTwo);// 0000 1100 对每位执行AND运算符
            Console.WriteLine(BitwiseNumberOne|BitwiseNumberTwo);// 0011 1101 对每位执行OR运算符

            //什么是AND运算符 1 AND 1 = 1 1 AND 0 = 0 0 AND 1 = 0 0 AND 0 = 0
            //什么是OR运算符  1 OR 1 = 1 1 OR 0 = 1 0 OR 1 = 1 O OR O = 0

            //浅浅的写一下switch语句
            int NumberFive = 1;
            switch (NumberFive)
            {
                case 1:
                    Console.WriteLine("这个数字是1");
                    break;
                case 2:
                    Console.WriteLine("传透过来了。");//这里像写一下穿透的示例，但是C#居然是禁止穿透的，233333
                    break;
                case 3:
                    Console.WriteLine("但是问题不大哦");
                    break;
                default:
                    Console.WriteLine("233333");
                    break;
                    //如果不满足以上任何标签的条件，则执行default块的内容
                    //switch语句最后一行也要记得加break语句，否则无法脱离开关
                    //是否可以return一个函数呢？
            }       //我认为是有可能的。

            switch (NumberFive)//这里填变量就不会出现这个错误，如果直接填数字，编译器则会发现一个多余的case代码，它是不会被执行的，所以就会报一个警告
            {
                case 0:
                    Console.WriteLine("还有吗");
                    break;
                //这样写会有一个不影响编译的警告：warning CS0162: 检测到无法访问的代码
                //原因是：在switch语句中，没有匹配到执行的 case 中
                case 1:

                    Console.WriteLine("哈哈哈");
                    break;
            }
            int WhileNmuber = 3;
            while (WhileNmuber>0)
            {
                WhileNmuber--;
                Console.WriteLine("减减");
            }
            //接下来是for循环捏
            //for ( init; condition; increment )
            //语法如上，意思就是，for (初始化；判断；increment )
            //执行完 init 执行 condition 执行完 condition 执行循环主体 执行完循环主体 执行increment
            for (int i = 0; i<3;)
            {
                i++;
                Console.WriteLine("原来是这样！");
            }
            //foreach循环语句
            //使用foreach可以迭代数组或者一个集合对象。
            //什么是迭代？ 迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果......
            //说人话：执行程序中的循环，直到满足某条件为止，亦称为迭代。
            int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 };//创建一个整型数组
            foreach (int element in fibarray)//变量elementu遍历整个数组

            {
                System.Console.WriteLine(element);
            }
            //元素计算器 ：很简单的实现方式
            int count = 0;
            foreach (int element in fibarray)
            {
                count += 1;
                System.Console.WriteLine("Element #{0}: {1}:{2}", count, element, "我去", "2333");
            }                               //两个占位符，表示后面有两个需要输出的代码，而且占位符无关位置
                                            //值得一提的是，如果多写了一个占位符，程序会直接崩溃，如果少写了一个占位符，仅仅只会少输出后面部分的内容
                                            //接下来是，Do while循环~
                                            //理解很简单，就是先执行一次，再从尾部检查条件，再判断是否执行。
            do
            {
                Console.WriteLine("欸嘿我先执行一次辣~");
            } while (0>1);//逆天写法

            //哦对，C#中的循环也是可以嵌套的，不过我懒得写了。

            //接下来是封装
            //神马是封装？封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。
            //封装的意义：在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。
            //抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

            //如下是访问修饰符
            /*一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

                   public：所有对象都可以访问；
                   private：对象本身在对象内部可以访问；
                   protected：只有该类对象及其子类对象可以访问
                   internal：同一个程序集的对象可以访问；
                   protected internal：访问限于当前程序集或派生自包含类的类型。

            */
            //public中，即使是在一个类中，也可以通过public将函数暴露给其他成员

            //Private 访问修饰符允许一个类将其成员变量和成员函数对其他的函数和对象进行隐藏。只有同一个类中的函数可以访问它的私有成员。即使是类的实例也不能访问它的私有成员。

            //Protected 访问修饰符 Protected 访问修饰符允许子类访问它的基类的成员变量和成员函数。这样有助于实现继承。
            //什么是基类和成员函数呢？

            //Internal 访问修饰符 Internal 访问修饰符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。
            //当前函数的

            //接下来是 方法 捏~
            //<Access Specifier> <Return Type> <Method Name>(Parameter List)
            //格式如上
            //修饰符 返回类型 （不返回值的为void哦~） 方法名称 (括号里的参数捏)
            //欸嘿方法很简单辣

            //懒得写代码了~

            //递归方法调用
            //神马是递归呢 一个方法可以自我调用就是递归捏！
            NumberManipulator n = new NumberManipulator();
            Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));

            int NmubernullOne;//这个默认为0
            int? NmubernullTwo;//进行Null赋值，这个默认为null
            Console.WriteLine();
            //被赋予了null 值的类型，称为可空类型，就是可以变成null的类型

            //合并运算符 ??
            //如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。下面的实例演示了这点：
            double? num1 = null;
            double? num2 = 3.14157;
            double? num3 = new double?();
            num3 = num1 ?? num2;
            Console.WriteLine(num3);
            Console.WriteLine(num1 ?? num2);
            //C# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。

            //正好想到了，C#中上半部分的程序是否可以调用下半部分程序的方法呢
            //可是程序都是逐行阅读的来着？
            //经过实验，C#中是可以的，Python中我忘了行不行了
            //经过实验，Python中是不行的，因为Python是逐行阅读代码的脚本语言
            //这是一个处理数字的类，可以用来计算数学中的阶乘

            //C#的数组
            //注意，数组不可以重复声明
            //声明一个数组
            double[] balanceOne;
            //声明一个数组不会在内存中初始化数组
            double[] balance = new double[10];//声明数组的长度
            balance[0] = 4500.0;//然后单独赋值

            double[] balanceThree = { 2340.0, 4523.69, 3421.0 };//声明的时候给数组赋值

            int[] marksOne = new int[5] { 99, 98, 92, 97, 95 };//可以创建并初始化一个数组

            int[] marksTwo = new int[] { 99, 98, 92, 97, 95 };//可以省略数组的大小

            int[] marksThree = new int[] { 99, 98, 92, 97, 95 };//可以将一个数组变量赋值给另一个数组变量
            int[] score = marksThree;

            /*
            创建字符串的五种方法

            通过给 String 变量指定一个字符串
            通过使用 String 类构造函数
            通过使用字符串串联运算符（ + ）
            通过检索属性或调用一个返回字符串的方法
            通过格式化方法来转换一个值或对象为它的字符串表示形式

            */

            String StringOne;
            string stringOne;




    






             Console.ReadKey();//这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
        
        
        }


        //枚举
        //什么是枚举


        //包含很多变量的集合，可以调用集合

        /*
         C#的枚举类型(Enum)是用来定义变量，这些变量表示一组人工定义的常量。使用枚举允许程序员有效地标识变量，并更容易地处理枚举值。例如，一个颜色枚举类型可以包括红、绿、蓝等常量值。
 
         */

        enum EnmuOne { One, Two, Three, Four };
        int x = (int)EnmuOne.One;
        int y = (int)EnmuOne.Two;
        //枚举是这样的
    }

}




class NumberManipulator
    {
        public int factorial(int num)
        {
            /* 局部变量定义 */
            int result;

            if (num == 1)//仅在num等于1的时候返回1让循环终止
            {
                return 1;
            }
            else
            {
                result = factorial(num - 1) * num;
                return result;
            }
        }
    }