c#_基础知识3.0

1.循环语句

循环语句是c#中比较重要的一种语句。
循环语句是什么?
循环语句是一种基本循环如果满足循环条件则进行循环如果不满足则跳出循环的一种语句。循环语句解决了if条件下语句只执行一次的问题。
以下列举了几种循环语句：
(1).while循环
while(循环条件)是一种基本的循环，其中（）内的是循环条件循环条件为真时执行循环下的语句。
例如以下是前20个数的总和：

using System;
namespace A
{
	class B
	{		
	   static void Main(string[] args)
	   {
	   		int i=1;
	   		while(i<=20)
	   		{
	   		 s=s+i;
	   		 i++;
	   	    }
	   	   Console.WriteLine("前20个数的总和是：{0}",s);
	   	     Console.ReadKey();
	    }
	}
}

结果是：

前20个数的总和是：210

(2).do-while循环
do-while与while相似但与while不同的是do-while语句是执行循环内的语句再进行判断，因此do-while至少要执行一次循环。如：

using System;
namespace B
{class C
{
	static void Main(string[] args)
	{    int a;
	    do
	    {
	    a=1;
	    s=s+a;
	    a++;
	    }
	    while(a<=20)
	    Console.WriteLine("总值是{0}，a的数值为{1}",s,a);
	    Console.ReadKey();
	}
}
}

结果是：

总值是210，a的数值为21

(3).for循环
C#中for语句最方便的循环语句。

一般形式为for(表达式1；表达式2；表达式3) 表达式1是循环变量的赋值。如：i=0，1，2…。
表达式2为判断循环条件如果为真则继续执行循环语句如果为假则跳出循环体，表达式3将循环变量增加。

用for写出前20个数相加的和：

using System;
namespace B
{
class C
 {
    static void Main(string[] args)
    {
    int i,j;
    for(i=1;i<=20;i++)
    {
       s=i+s;
    }
    Console.WriteLine("总和是：{0}"，s);
    Console.ReadKey();
    }
 }
}

结果是：

总和是：210

2.循环的嵌套

在学习了循环后就可以学习循环最重要的部份循环的嵌套了。
故名思义循环的嵌套就是在循环中再套一个循环,这样就是双重循环，如果再在内部套一个循环就是三重循环，双重循环有whlie-whlie型，while-for型，for-for型等。

while(表达式)						while(表达式)
{...										{   ......
  while(表达式)							for(表达式1;表达式2;表达式3)
    {										       {
      ....													......
    }												}
}											}

for(表达式1;表达式2;表达式3)
{
    ......
    for(表达式1;表达式2;表达式3)
    {
       ......
    }
}

双重循环先执行最外层的循环再执行内层循环，只有在内层循环执行完后再回到外层循环，然后再执行内层循环，以此类推直到外层循环执行完，最后输出结果。
以下是用双重for循环写出的九九成法表

using System;
namespace chengfabiao
{
	class biao
	{
	static void Main(string[] args)
	{
		int i,j;
		for(i=1;i<=9;i++)
		{
		  for(j=1;j<=i;j++)
		   {
		     s=i*j;
		     Console.Write("{0}*{1}={2} ",i,j,s);
		   }
		   Console.Writeline();
		}
		   Console.ReadKey();
	}
	} 
}

结果是：

1*1=1
1*2=2  2*2=4 
1*3=3  2*3=6  3*3=9 
1*4=4  2*4=8  3*4=12 4*4=16
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

3.类型转换

类型转换分为显示转换和隐式转换。
(1).隐式转换
隐式转换是低级到高级的转换如int类型到double类型的转换隐式转换不需要特别说明而是由编译器自动完成。

int a = 10;
double b = a;//隐式转换

隐式转换规则是：任何类型A，只要其取值范围完全包含在类型B的取值范围内，就可以隐式转换为类型B。基于这个转换规则，C#的隐式转换不会导致数据丢失。需要注意的是我们最常用的简单类型bool和string没有隐式转换。

(2).显示转换
显式转换：从类型A到类型B的转换只能在某些情况下进行，转换规则比较复杂，应进行某种类型的额外处理。显式转换又叫强制类型转换，显式转换需要用户明确的指定转换类型。如将double类型数据转换成int类型数据。
例如：

double c = 10.5;
int d = (int)c;//显示转换

注意：

显式转换可能会导致错误。进行这种转换时编译器将对转换进行溢出检测。如果有溢出说明转换失败，就表明源类型不是一个合法的目标类型。无法进行类型转换。
强制类型转换会造成数据丢失，如上面的例子中，最终得到的d值为10。

4.封装

C#中的将一个或多个项目封在一个包中防止外部对项目细节的访问封装限制了外部的访问权限，封装可用访问修饰符来实现。
以下是访问修饰符和级别：

上图从外到内访问级别增加。
(1).private修饰符

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

(2).protected修饰符

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

(3).internal修饰符

internal 访问说明符允许一个类将其成员变量和成员函数暴露给当前程序中的其他函数和对象。换句话说，带有 internal
访问修饰符的任何成员可以被定义在该成员所定义的应用程序内的任何类或方法访问

(4).public修饰符

Public 访问修饰符允许一个类将其成员变量和成员函数暴露给其他的函数和对象。任何公有成员可以被外部的类访问。

注：除了可以用上述的修饰符外封装还可以用get，set来进行，其中get是可读，set为可写。