C#第三节（运算符、封装）

Love The Way You Lie 2022-05-26 12:41 226阅读 0赞

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C\#有丰富的内置运算符，分类如下：

1.  算术运算符
2.  关系运算符
3.  逻辑运算符
4.  位运算符
5.  赋值运算符
6.  其他运算符  
    **算术运算符**  
    下表展示C\#所支持的算术运算符，假设变量A的值为10，变量B的值为20，则：  
    ![这里写图片描述][70]  
    注意：++a是先对a的值进行自增运算，然后再赋值给变量；  
    **关系运算符**  
    下表显示了C\#支持的所有关系运算符，假设变量A的值为10，变量B的值为20，则：  
    ![这里写图片描述][70 1]  
    **逻辑运算符**  
    下表显示了C\#支持的所有逻辑运算符，假设变量A为true，变量B为布尔的false，则：  
    ![这里写图片描述][70 2]  
    **位运算符**  
    位运算符作用于位，并逐位执行操作。&、|和^的真值表如下所示：  
    ![这里写图片描述][70 3]  
    假如A等于60，且B=13,现在以二进制格式表示，他们如下所示：

A=0011 1100
    B=0000 1101 -------------------
    A&B=0000 1100   //与运算，11为1，其余为0
    A|B=0011 1101   //或运算，00为0，其余为1
    A^B=0011 0001   //异或运算，相同为0，不同为1
    ~A=1100 0011   //取反

下表勒出了C\#支持的位运算符，假设变量A的值为60，变量B的值为13，则：  
![这里写图片描述][70 4]  
**赋值运算符**  
![这里写图片描述][70 5]  
**其他运算符**  
下表列出了C\#支持的其他一些重要的运算符，包括sizeof,typeof,和？：。  
![这里写图片描述][70 6]

**C\#中运算符优先级**  
![这里写图片描述][70 7]  
笔记：  
其中&，|的运算结果与&&，||完全相同，但&&和||的性能更好。因为&&和||都是检查第一个操作数的值，如果已经能判断结果，就根本不处理第二个操作数

## C\#的判断 \#\# ##

1、if-else 组合

if（"条件表达式"）
                    {
    
                }else if("条件表达式"){
    
                }
                else
                {
    
                }

2、switch  
![这里写图片描述][70 8]  
demo:

static void Main(string[] args)
            {
                Console.WriteLine("请输入您的成绩等级：");
                char grade =Convert.ToChar(Console.ReadLine());
                switch(grade)//switch后面的表达式必须为整型或者枚举类型，或是一个class类型，其中class有一个单一的转换函数将其转换为整形或枚举类型
                {
                    case 'A'://case后面的表达式必须与switch中的变量具有相同的数据类型，且必须为常量
                        Console.WriteLine("you are so great！");
                        break;
                    case 'B':
                    case 'C':
                        Console.WriteLine("do well");
                        break;
                    case 'D'://在下一个case语句之前必须有break
                        Console.WriteLine("try again");
                        break;
                    default:
                        Console.WriteLine("this gread is invalid");
                        break;
                }
                Console.WriteLine("您的成绩为：{0}", grade);
                Console.ReadKey();
    }

3、嵌套switch  
![这里写图片描述][70 9]

static void Main(string[] args)
            {
                Console.WriteLine("select a integer from 100,200：");
                int a =Convert.ToInt32(Console.ReadLine());
                Console.WriteLine("select another integer from 100,200：");
                int b= Convert.ToInt32(Console.ReadLine());
                switch(a)
                {
                    case 100:
                        Console.WriteLine("第一个输入的值为100进入第二关");
                            switch(b)
                        {
                            case 100:
                                Console.WriteLine("第二关输入的值仍为100");
                                break;
                            case 200:
                                Console.WriteLine("第二关输入的值为200");
                                break;
                            default:
                                Console.WriteLine("第二关输入不正确，挑战失败");
                                break;
                        }
                        break;
                    default:
                        Console.WriteLine("第一关挑战失败，无法继续游戏");
                        break;
                }
                Console.WriteLine("第一次输入的值为：" + a+ ",第二次输入的值为：" + b);
                Console.ReadKey();
    }

**条件运算符 ？：**

## C\#循环 ##

1、while循环：如果条件为假时，会跳出循环主题，直接执行紧跟着while循环的下一句。  
2、for与foreach  
![这里写图片描述][70 10]  
demo:

static void Main(string[] args)
            {
                int[] inbarry = new int[] {
       11,4,5,9,66,8,59,78,5 };
                foreach(int i in inbarry)
                {
                    Console.WriteLine("使用foreach遍历结果："+i);
                }
                Console.WriteLine();
                for(int i=0;i<inbarry.Length;i++)
                {
                    Console.WriteLine("使用for遍历结果：" + inbarry[i]);
                }
                Console.WriteLine();
    
                //设置集合中元素的计算器
                int count = 0;
                foreach(int i in inbarry)
                {
                    Console.WriteLine("Element #{0}:{1}", count, i);
                    count++;
                }
                Console.WriteLine("Number of elements in the array:{0}", count);
     }

**do—While循环**  
do—While至少确保执行一次  
![这里写图片描述][70 11]

static void Main(string[] args)
            {
                int a = 66;
                do
                {
                    Console.WriteLine("do while里面的a的值：{0}", a);
                    a++;
                } while (a < 67);//注意此处有分号
    
    
    
                while(a<67)//此时的a已经变为了67所以已不再成立
                {
                    Console.WriteLine("while里面的a的值：{0}", a);
                    a++;
                }
                Console.ReadKey();
            }

**循环嵌套**  
eg:使用循环嵌套寻找2到100中的质数

class Program
        {
            static void Main(string[] args)
            {
                int i,j;
                //质数的定义是，一个大于1的自然数，除了1和它本身外,不能被其他自然数(质数)整除
                for (i=2;i<100;i++)
                {
                    for (j = 2; j <= (i / j); j++)
                        if (i % j == 0)
                            break;
                    if (j > (i / j))//当余数被商还大的时候证明这个数已经不能再除了
                        Console.Write("{0} ",i);
                    if(i%10==0)
                    {
                        Console.WriteLine();
                    }
                }
                Console.ReadKey();
            }
        }

运行结果：  
![这里写图片描述][70 12]

**循环控制语句**  
功能：更改执行的正常序列，当离开一个范围时，所有在该范围中穿件的对象都会被自动销毁  
![这里写图片描述][70 13]

**无限循环**  
for循环在传统意义上可用于实现无限循环，由于构成循环的三个表达式中任何一个都不是必须的，可以将某些表达式留空构成无限循环  
当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，程序员偏向于使用 for(;;) 结构来表示一个无限循环

class Program { 
            static void Main(string[] args)
            {
                int i;
                for (i=2;;i++)
                {
                        Console.Write(i+" ");
                }
                Console.ReadKey();
            }
        }

某一瞬间的截图  
![这里写图片描述][70 14]

ps笔记:斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368  
这个数列从第3项开始，每一项都等于前两项之和

static void Main(string[] args)
            {
                decimal[] de = new decimal[30];
                de[0] = 1;
                de[1] = 1;
                //de[2] = de[0] + de[1];
    
                for(int i =2;i<de.Length;i++)
                {
                    de[i] = de[i - 1] + de[i - 2];
                    //Console.WriteLine(de[i]);//这样读取出来的没有数组前两项，如果想得到数组所有元素，就遍历数组
                }
    
                //遍历数组元素
                foreach(decimal d in de)
                {
                    Console.WriteLine(d);
                }
                Console.ReadKey();
    
            }

运行结果：  
![这里写图片描述][70 15]

**C\#封装**  
目的：防止对实现细节的访问；

C\#的封装是根据具体需要，设置使用者的访问权限，并通过访问修饰符来实现。

*  public：所有对象都可以访问；
 *  private：对象本身在对象内部可以访问；
 *  protected：只有该类对象及其子类对象可以访问；
 *  internal：同一个程序集的对象可以访问；
 *  protected internal：访问限于当前程序集或派生自包含类的类型；  
    1、public访问修饰符：  
    允许一个类将其成员函数暴露给其他函数和对象；任何共有成员都能被外部类访问eg:

namespace Jdemo
    {
        public class Rectangle
        {
            public double reLength;
            public double reWidth;
            /// <summary>
            /// 将矩形的长和宽赋初值(第一行)
            /// <para>说明：（第二行）</para>
            /// <para> 赋值长和宽（第三行）</para>
            /// </summary>
            public double getArea()
            {
                return reLength * reWidth;
            }
            public void disPlay()
            {
                Console.WriteLine("length is {0}" , reLength);
                Console.WriteLine("width is {0}", reWidth);
                Console.WriteLine("Area is {0}", getArea());
    
            }
        }
    }

namespace JdemoTest { 
        class Test { 
            static void Main(string[] args)
            {
                Jdemo.Rectangle rectangle = new Jdemo.Rectangle();
                rectangle.reLength = 3.6;//可以访问到Rectangle类的变量
                rectangle.reWidth = 5.2;
                rectangle.getArea();
                rectangle.disPlay();
    
                Console.ReadKey();
            }
        }
    }

运行结果：  
![这里写图片描述][70 16]  
**总结1：public修饰的不同namespace 都能访问，不过需要在JdemoTest中引用Jdemo项目【命名空间外可见】**  
**总结2：private修饰的只能在同一个类内调用【出了类不可见】**  
2、private访问修饰符  
eg:[求100以内的质数及判断一个数是否为质数][100]

namespace JdemoTest
    {
        class Test { 
            static void Main(string[] args)
            {
                Console.WriteLine(isPrime(66));
                Console.WriteLine(isPrime(101));
    
                Console.ReadKey();
    
            }
            private static String isPrime(int num)
            {
                String str;
                if (num < 2)
                {
                    str = num + "小于2不满足质数的定义";
                    return str;
                }
                for (int j = 2; j < num; j++)
                {
                    if (num % j == 0)
                    {
                        str = num + "不是质数";
                        return str;
                    }
                }
                str = num + "是质数";
                return str;
            }
        }
    }

运行结果：  
![这里写图片描述][70 17]

3、Protected访问修饰符：  
允许子类访问它的基类的成员变量和成员函数，有助于实现继承  
**总结3、Protected继承可见**

4、Internal访问修饰符：  
允许类将其成员变量和函数暴露给*当前程序中的其他函数和对象*。即：带有internal访问修饰符的成员可以被定义在该成员所定义的应用 程序内的任何类或方法访问

namespace JdemoTest
    {
        class Class1
        {
            internal double reLength;//同一个命名空间下的可见
            internal double reWidth;
            /// <summary>
            /// 将矩形的长和宽赋初值(第一行)
            /// <para>说明：（第二行）</para>
            /// <para> 赋值长和宽（第三行）</para>
            /// </summary>
            public double getArea()
            {
                return reLength * reWidth;
            }
            public void disPlay()
            {
                Console.WriteLine("length is {0}", reLength);
                Console.WriteLine("width is {0}", reWidth);
                Console.WriteLine("Area is {0}", getArea());
    
            }
        }
    }

namespace JdemoTest { 
        class Program { 
            static void Main(string[] args)
            {
                JdemoTest.Class1 c = new JdemoTest.Class1();
                c.reWidth = 2.2;
                c.reLength = 9.9;
                c.getArea();
                c.disPlay();
    
                Console.ReadKey();
    
            }
          }
        }

运行结果：  
![这里写图片描述][70 18]  
**总结4、Internal 同一个namespace 下可见**  
声明的时候不带有任何访问修饰符即默认为private，出了类不可见

5、Protected Internal访问修饰符  
允许在本类，派生类或者包含该类的程序集中访问，也被用于实现继承

ps:笔记

比如说：一个人A为父类，他的儿子B，妻子C，私生子D（注：D不在他家里）  
如果我们给A的事情增加修饰符：  
public事件，地球人都知道，全公开  
protected事件，A，B，D知道（A和他的所有儿子知道，妻子C不知道）【本身及继承可见】  
private事件，只有A知道（隐私？心事？）  
internal事件，A，B，C知道（A家里人都知道，私生子D不知道）  
protected internal事件，A，B，C，D都知道,其它人不知道

[70]: /images/20220526/cc47c2012c864679865a3513d12f290c.png
[70 1]: /images/20220526/53d7eb1b16484feaab59ccc5960a65a8.png
[70 2]: /images/20220526/1b9750b5e2bf420d8859063b4ef7f474.png
[70 3]: /images/20220526/e735ce5ed9f745ea851a8468fa1f010b.png
[70 4]: /images/20220526/063756e85ae64987bb57f8c83dd1b0bb.png
[70 5]: /images/20220526/4103c66c687942b4b7599bddca4fb4ad.png
[70 6]: /images/20220526/6fc32402e06f4efd81557210be721098.png
[70 7]: /images/20220526/74500b646c944f99831edf2af63b59b5.png
[70 8]: /images/20220526/e0a5300457a943da8c28c368c4ea9df0.png
[70 9]: /images/20220526/0f957fa36ec54345bc7213f79e5ef6cf.png
[70 10]: /images/20220526/9e4b1876227b453c89585543616d441b.png
[70 11]: /images/20220526/a4f3d855c36a4a7180b12839b27cacd5.png
[70 12]: /images/20220526/09f0efefd0524c7a851e4c2b3c93a3d9.png
[70 13]: /images/20220526/6a2d56e8f6d44d04ac6eea441fb9240b.png
[70 14]: /images/20220526/1f3897bc1b8a4bf3989e5281900efe09.png
[70 15]: /images/20220526/5e0c43b3643c4592a70df8fcade6149c.png
[70 16]: /images/20220526/43b96a916a7a422d8d3d4348c63e53be.png
[100]: https://blog.csdn.net/weixin_39885282/article/details/80233694
[70 17]: /images/20220526/4fa3fd981d7c400fb96accb8f2e8d8c3.png
[70 18]: /images/20220526/58252f09ff7346d38d05017474b8ea7a.png