CSharp 第 3 课笔记

循环结构

while 循环条件

while(条件表达式) {
	// 执行这里的代码（中间这段代码称为循环体）
	// 需要让上面的条件在某一次循环之后为假，跳出循环
}

如：重复 n 次打印文本

条件：次数
循环体：打印文本

int i = 0;
while (i < 10) {
	Console.WriteLine("文本");
	i++;
}

do-while 循环

do {
	// 这一段至少会执行一次
	// 如果 while 条件为真，则再执行一遍
} while(条件表达式)

以下是个案例

循环体：修改论文，询问老师是否通过
条件：老师给的答复

// 询问导师论文通过与否
do {
	Console.WriteLine("撰写论文中……");
	Console.WriteLine("论文写好啦！");
	Console.WriteLine("我的论文可以通过吗？");
	string answer = Console.ReadLine();
} while (answer.Equals("No"))；

for 循环

for (循环变量; 循环条件; 改变循环变量) {
	// 循环体
}

面向对象

与之对立的是面向过程，强调的是完成这件事情的动作。

概念

类：将相同属性和方法的对象进行封装，完成类的概念
- 人类：年龄、性别、身高 | 吃饭、睡觉
- 车类：速度、马力 | 行驶
字段：就是所存放的数据，如上面的年龄、性别、身高
属性
方法：就是这个类能执行的事情，如上面的吃饭、睡觉

public class Person
{
	// 字段
	private string _name; // 私有字段命名方式通常为 _ 开头
	private int _age;
	public bool IsMale;
	
	// 属性，声明的属性类型必须和他所对应的字段类型相符
	public string Name
	{
		get { return _name; }
		set { _name = value; } // value 是内置变量
	}
	
	// 属性可以用来让阻止用户输入越界
	public int Age
	{
		get { return _age; }
		set
		{
			if ( value < 0 || value > 104)
			{
				value = 18;
			}
			_age = value;
		}
	}
	
	// 构造函数
	public Person(string name, int age, bool isMale)
	{
		_name = name;
		_age = age;
		IsMale = isMale;
	}
	
	// 方法
	public void Eat() {}
}

声明对象并使用

public class Program
{
	public static void Main (string[] args)
	{
		Person person = new Person("小强", 21, true);
		
		// 修改 person 的名字
		person.Name = "小麦";
	}
}

对于属性，value 是内置的，是我们赋值的“值”
要访问对象的属性和方法，使用 . 运算符

三大特征——封装、继承、多态

继承

上面我们定义了一个 Person 类，那么程序员也属于 Person，我们可以继承他，获取人类有的能力，并且可以定义自己所需的能力。

一次继承只能有一个

public class Programmer : Person
{
	// 可以有自己的字段
	private string _language;
	private string _computer;
	
	// 构造函数
	public Programmer(string name, int age, bool isMale, string language, string computer) : // 用分号运算符来实现调用父类的方法
	base(name, age, isMale) // 调用父类构造函数（根据父类构造函数对应的参数，都要给上）
	{
		_language = language;
		_computer = computer;
	}
	
	// 可以有自己的属性
	
	// 可以有自己的方法
	public void Coding() {}
}

使用 : 运算符实现继承

这时候我们可以通过创建 Programmer 对象，可以访问 Person 的属性

public class Program
{
	public static void Main (string[] args)
	{
		Person person = new Person("小强", 21, true);
		
		// 修改 person 的名字
		person.Name = "小麦";
		
		Programmer programmer = new Programmer("小刘", 24, false, "C#", "Apple");
		// 可以调用 Programmer 定义的函数
		programmer.Coding();
		// 可以调用 Person 定义的函数
		programmer.Eat();
	}
}

继承的核心概念在于：
把所有相同的属性提高一个档次，称为父类。比如程序员类、学生类和老师类都有姓名、年龄等属性。那么我们就把这个属性提高成人类。让这程序员类、学生类和老师类都继承人类。
这样，程序员类、学生类和老师类都拥有人类的特征，并且还有自己的方法。

多态

同一个事件在不同的对象上会产生不同的效果

我们可以在同一个范围中定义多个相同名字的函数，但是函数的参数必须不同。可以是参数类型不同，可以是参数数量不同

public class TestPolymorphism
{

	public int Add(int a, int b, int c)   
	{
		return a + b + c;
	}
	
	public int Add(int a, int b)   
	{
		return a + b;
	}
}

public class Program
{
	public static void Main (string[] args)
	{
		TestPolymorphism dataClass = new TestPolymorphism();  
		int add1 = dataClass.Add(1, 2);
		int add2 = dataClass.Add(1, 2, 3);
		
		Console.WriteLine("add1 :" + add1);
		Console.WriteLine("add2 :" + add2);
	}
}

abstract 抽象类

用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

您不能创建一个抽象类的实例。
您不能在一个抽象类外部声明一个抽象方法。
通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。
抽象类是实现多态的一种方法

abstract class Shape
{
	abstract public int area();
}

class Rectangle: Shape
{  
	private int length;
	private int width;
	public Rectangle( int a=0, int b=0)
	{
		length = a;
		width = b;
	}
	public override int area ()
	{
		Console.WriteLine("Rectangle 类的面积：");
		return (width * length);
	}
}

class RectangleTester
{
	static void Main(string[] args)
	{
		Rectangle r = new Rectangle(10, 7);
		double a = r.area();
		Console.WriteLine("面积： {0}",a);
		Console.ReadKey();
	}
}