语句是为方法服务的，语句就是为了构成方法体。
操作符越多，能进行的运算逻辑越多，编程语言的功能越强大。
从上往下，优先级逐层降低。同一行的运算优先级一样，从左向右运算。
但是赋值操作符的运算顺序，是从右向左。
给我一个姑娘，我可以创造一个民族。
class Program
{
static void Main(string[] args)
{
Person person1 = new Person();
Person person2 = new Person();
person1.Name = "Deer";
person2.Name = "Deer's wife";
List<Person> nation = Person.GetMarry(person1, person2);
foreach (var p in nation)
{
Console.WriteLine(p.Name);
}
}
}
class Person
{
public string Name;
public static List<Person> GetMarry(Person p1, Person p2)
{
List<Person> people = new List<Person>();
people.Add(p1);
people.Add(p2);
for (int i = 0; i < 11; i++)
{
Person child = new Person();
child.Name = p1.Name + "&" + p2.Name + "'s child";
people.Add(child);
}
return people;
}
}
优先级
1）只有（）可以提升优先级。
[ ] ：访问索引器
{ }：body
2）赋值操作符从右向左运算。
a) =
int x;
x = 3 + 4 +5;
= 等号有赋值功能，从右向左，先算 = 右边，再算左边
+ 加号没有赋值功能，从左向右，先算 3+4， 再算 +5.
b) +=, 有赋值功能, 从右向左
a = a + b; 可以写成 a += b;
int a = 100;
int b = 200;
int c = 300;
a += b += c;
Console.WriteLine(a); // 600
Console.WriteLine(b); // 500
Console.WriteLine(c); // 300
基本操作符优先级最高。
基本表达式，最简单，最基础，不能再被拆分的表达式。基本运算符就是参与形成基本表达式的运算符。
1）“.” ：访问操作符
外层访问空间.子集名称空间.类型.静态成员
访问对象中的实例成员
2) 方法调用操作符 （）
3）元素访问操作符 [ ]：访问数组元素和字典的元素
访问数组中的元素
int[] myIntArray1 = new int[10]; //10个元素的数组，从0开始排序。
int[] myIntArray2 = new int[] {1,2,3,4,5}; //{ }初始化器
int[] myIntArray3 = new int[5] { 1, 2, 3, 4, 5 };
Console.WriteLine(myIntArray2[0]);
Console.WriteLine(myIntArray2[myIntArray2.Length -1]); //访问最后一个元素
不能下标越界，长度5，只能访问到myIntArray2[4]
Console.WriteLine(myIntArray2[5]); // 下标越界
访问字典中的元素
调用Dictionary，必须要using System.Collections.Generic;
带<>的类叫泛型类。泛型类不是一个完整的类，需要和其他的类型组合在一起，才能形成一个完整的类。
用string Name作为索引Tkey，用Student作为Tvalue，创建一个字典
Dictionary<string, Student> stuDic = new Dictionary<string, Student>();
for (int i = 1; i <=100; i++)
{
Student stu = new Student();
stu.Name = "s_" + i.ToString();
stu.Score = 100 + i;
stuDic.Add(stu.Name, stu);
}
Student number6 = stuDic["s_6"];
Console.WriteLine(number6.Score); // 106
}
class Student
{
public string Name;
public int Score;
}
4）后置的 ++ / -- ：后置的自增/自减
/// 后置的++ / -- ：后置的自增 / 自减
// x1++相当于 x1 = x1+1;
int x1 = 100;
x1++;
Console.WriteLine(x1++); // 101
// x2--相当于 x2 = x2-1;
int x2 = 100;
x2--;
Console.WriteLine(x2--); //99
//赋值操作符，从右向左，先把自己的值给左边变量，再+1
//相当于int y = x; 再执行x=x++;
int x3 = 100;
int y1 = x3++;
Console.WriteLine(y1); // 100
int x4 = 100;
int y2 = x4--;
Console.WriteLine(y2); // 100
务必牢记后置的++/--，跟前置++/--要区分开。
5）typeof，查看一个类型的内部结构（Metadata，元数据）
元数据包含一些数据的基本信息，数据名，名称空间，父类，包含的方法，属性，事件，等等
元数据信息可以帮助决定程序逻辑。
Type t1 = typeof(int);
Console.WriteLine(t1.Namespace);
Console.WriteLine(t1.FullName);
Console.WriteLine(t1.Name);
int t2 = t1.GetMethods().Length;
foreach (var mi in t1.GetMethods())
{
Console.WriteLine(mi.Name);
}
Console.WriteLine(t2); //打印出方法列表，共21种
6）default，获取一个类型的默认值
a）结构体类型（值类型）：e.g. int
int d1 = default(int);
Console.WriteLine(d1); // 0, int 的初始值为0
b）引用类型
FormatException myForm = default(FormatException);
Console.WriteLine(myForm == null); //True
c) 枚举类型（值类型）
声明枚举类型时，编译器会把枚举类型中的成员，跟整数值对应起来，从0开始，依次+1。
默认值为0，所以默认值是第一位
enum Level
{
Mid, //对应0， Mid = 0
Low, //之后依次+1，对应1 Low = 1
High //对应2, High = 2
}
注意：声明枚举类型时，枚举参数可以显示赋值。默认值为那个赋值是0的成员
enum Building
{
Mid = 1,
Low = 0,
High = 2
}
在使用枚举类型时，最好设置一个成员，赋值为0，避免在使用default时出错。
enum Lift
{
Mid = 1,
Low = 2,
High = 3
}
Console.WriteLine(lift); 返回值为0，并不在枚举类型里。逻辑上已经出错了。
在对枚举类型使用default，要小心这个问题。
