C#编程基础（五）

一、C#程序的基本结构

1、C#程序的基本结构

     using System;
 ​
     namespace xxxx   //定义一个命名空间
     {
         class yyyy  //定义一个类
         {
             //Main函数:主函数，程序的入口和出口
             public static void Main()
             {
 ​
             }
         }
         
     }

2、如何实现程序输出?

     Console.Write("输出的内容");   //不会换行    
     Console.WriteLine("输出的内容");  //自带换行
     Console.WriteLine("格式占位符",数据);
    eg:
     Console.WriteLine("你好,张三!");
     Console.WriteLine("你好,{0}!","张三");
     Console.WriteLine("你好,{0}!我是{1}!","张三","你爸");

3、如何控制输出内容的格式？

     常见的转义字符
     \n  Enter键效果、换行
     \t  Tab键效果、制表符
     \\  \
     \"  "
     \'  '
     @   取消转义
 ​
   Console.WriteLine("你好,{0}!\n我是{1}!","张三","你爸");
   Console.WriteLine("姓名\t年龄");
   Console.WriteLine("小明\t\"10\"");
   Console.WriteLine("小小明\t2");
   Console.WriteLine("C:\\1.txt");
   Console.WriteLine(@"C:\1.txt");
   Console.WriteLine(@"aaaa\nbbbb"); //aaaa\nbbbb

二、数据类型

1、程序经常要处理各种各样的数据，要处理的数据首先要在程序中表示出来，如何表示程序的数据呢？

2、程序中的数据如何表示？

1）第一点就是要知道数据是何种类型：在C#中，数据常见的基本类型有：
 1、数据类型常见的有：
 ​
       类型      关键字    占用的空间大小    举例  
       
     整型         int         4字节        月份：9
     单精度浮点型  float       4字节        圆周率:3.14f
     双精度浮点型  double      8字节        圆周率:3.14
     decimal型    decimal                 财产:1000000.0m
     布尔型       bool                    true/false
     单字符       char         1字节      一个字符:'A','\n',' ','9'
     字符串       string                 任意个字符:"小明","男","A",""
     
     
 2、数据类型：
         整型:int
         
         浮点型：
                 单精度：float   3.14f
                 双精度：double  3.14
                 
         decimal型:财务计算、金额的表示
                 decimal  3.14m
                 
         布尔型: bool    ---> true/false
         
         单字符：char    'A','1'
         
         字符串：string  "abc","","a"
 ​

 

a、整型：
     整数类型，比如年份2021，年龄18等都是整型
     最常用的关键字是:int  (用4个字节来存储)
     表示数据的范围是-2(31)~2(31)-1
     超出这个范围，就不能正确表示
b、浮点型:
 带小数点的数，比如身高1.8、体重50.5等分成单精度浮点型和双精度浮点型
 ​
     单精度浮点型：float (用4个字节来存储)
         精确到7位以内
         
     双精度浮点型：double (用8个字节来存储)
         精确到15/16位以内
         
     如果在表示数据时没有说明，默认是双精度的。
     比如  1.5是双精度的后面加f或F就是单精度的：1.5F
c、decimal型：
 关键字是decimal,通常用于财务方面的计算。
 ​
     128位高精度的十进制数！！精确小数28位！
     
     后面加m/M就表示它是decimal型：
     比如 1.5m
d、布尔型：
     关键字是bool
     用于表示两种逻辑值：true、false
     
     true：真的，正确的，是
     false：假的，错误的，否
e、单字符型：
     关键字是char
	表示一个字符，比如一个字母，一个标点符号
	要用单引号引起来
	eg:	'a'、' ' (一个字母、空格) 
		':' (一个标点) 
		'0' (一个数字符号)  
		'\n'(一个转义字符)
f、字符串型:
    关键字是string
	表示多个/任意个字符组成的文本，要用双引号引起来
	eg:
		"张三"、"15991654646"、
		"a"、""(空字符串：0个字符)、
		"0"、"123"
		
举例：表示数据第一步就要确定数据是什么类型？
    
    图书序号：
    图书名称
    价格
    作者
    出版社
    出版年份
    是否借出
2）要保存数据，还要有一块存储空间。
意味着我们要在内存中开辟一块存储空间出来，才能保存数据。
 
 变量：就是在内存中开辟一块存储空间。相当于酒店中的一间单人房。
a、 如何开辟存储空间？（定义变量）
1、变量：在内存中开辟的一块存储空间，用于保存数据。

	变量的定义：数据类型 变量名;
	eg:
		string a="tom";	//定义一个字符串型的变量a
		string b,c;	//一次定义多个变量
		
		decimal bookPrice=9.9m; // 骆驼命名法
		
		bookPrice=29.9m; //再次赋值
	
	往变量（存储空间）中保存数据：赋值

2、把变量输出到控制台中：

	Console.WriteLine("价格:{0}",bookPrice);
	

语法：
		数据类型 变量名;  //多个变量用,隔开
	eg:
		int age;     // 定义一个整型的变量age
		string name; // 定义一个字符串的变量name
		int a,b,c;   //定义三个整型变量a，b，c
		float a1,b1; //定义单精度浮点型变量a1,b1
		string qq;
		
		2、变量：存储数据的一块存储空间（内存中的）
        定义变量，并存入数据(=赋值),输出：
            int a=2021,b=1000;

            Console.WriteLine("{0}",a);  //2021
            a=b; 
            Console.WriteLine("xxxx:{0}",a);  //1000
b、变量的命名规则：
	（1）变量名只能有数字、字母和下划线组成；
	
	（2）不能以数字开头；
	
	（3）不能跟C#关键字、函数名一样，
		比如
			int char;// 错误的
			
	（4）建议用骆驼命名法命名,从第二个单词开始首字母大写;
	     一般用含义相近的英文单词表示变量名，可提高程序的可读性。
	     比如：
			string xingMing;
			int age;
			string yourCode;
			string myName;
			string myBankCard;
3）赋值

接下来，就可以将数据存入变量（存储空间）中，用=就可以将数据存入变量了（赋值）。 int a1=100; //定义变量a1，存入整数100 int a2=100,a3=200;//定义变量a2和a3，分别存入100和200 float a4=1.9f; //单精度后加f double a5=1.9; decimal a6=10000.0m; //decimal型后加m bool a7=true; //布尔型 char a8='A'; //单字符要单引号引起来 string a9="hello"; //字符串要双引号 注意： =左右两边的类型要一致。 赋值，还可以： // 定义变量时赋值 int a=1,b=2; int c=a+b; //把表达式结果赋给变量 int d=c; // 把一个变量赋给另一个变量 // 针对变量进行多次赋值 d=100; // 在定义变量之后赋值 d=200; d=10000; int x; x=1000; // 在定义变量之后赋值

3、如何在控制台输出变量中的数据。

        string name="李四";
        int age=100;
        float height=1.5f,weight=30.5f;

        // 输出变量的值
        Console.WriteLine(name);
        
        // 要加上提示:
        Console.WriteLine("姓名:" + name);// +表示连接
        
        // 最常用的：格式占位符
        Console.WriteLine("姓名:{0}",name);
        Console.WriteLine("姓名:{0},年龄:{1}岁",name,age);

4、类型转换：

类型转换：
   在赋值过程中，一般都是要保证=两边类型一致，比如：
   int a=100+200; // 两边都是整型
   float b=1.5f;  // 两边都单精度浮点型

   在实际中，也有可能出现两边类型不一致的情况，比如:
   float c=100;   // 左边是float，右边是int

   如果类型不一致时，就要进行类型转换，让两边类型保持一致。
1）隐式转换:
类型转换的方式有3种：
隐式转换：由系统自动进行，不需要我们干预。
     在什么情况下会发生隐式转换？
	左边类型大，右边类型小的时候发生隐式转换，
	系统会自动把右边的小类型转成左边的大类型数据！
     
 类型的大小关系:
 	char<int<=float<double

 eg:
 	float a=100;	//float>int
double b=1.5f;  //double>float
int c='A';	//int>char
float d='B';	//float>char
这些都是正确的写法。

系统自动(左边大，右边小的时候)
        int a='A';
        float b=100;    //char<int<=float<double
        double c=b;
        double d='C';
2）显式转换：
显式转换:也叫强制转换。
  在左边类型小，右边类型大的时候需要显式转换。
  eg:
int a=1.5;   // 左边int,右边double
char b=100; // char<int
这些编译会出错！

   显式转换的语法：  (要转成的类型)(表达式)
  eg:

  	int a=(int)1.5;  //左边是什么类型就写什么类型的关键字
char b=(char)100;

注意：显式转换不能用于string、bool类型。

左边小，右边大的时候(string,bool不可用)
            int a=(int)1.5;
            double d=10.2;
            float b=(float)(a+d);
            decimal c=(decimal)(10.5+5.5);
3）转换方法：
a、Parse()方法：
  使用特定方法进行类型转换：
parse()方法：用于字符串类型转成其它类型
	eg:
		string str="123";	//字符串
		int a=int.Parse(str);   // 将str转成int类型
通过控制台输入各种类型的数据：
输入字符串：
	string a=Console.ReadLine();
	
输入整数:
	int b=int.Parse(Console.ReadLine());
	
输入浮点数：
	float c=float.Parse(Console.ReadLine());
	double d=double.Parse(Console.ReadLine());
	decimal e=decimal.Parse(Console.ReadLine());
	
输入单字符：
	char f=char.Parse(Console.ReadLine());
 
 string--->其它类型
            int a=int.Parse("13123");
b、ToString()方法:
(2)ToString():其它类型转成字符串类型
    该方法来源于Object类。

    语法： 数据.ToString()
   eg:
   	//int-->string 
	string a=123.ToString();  //整数123转字符串
	//等价写法：
	//123.ToString()与123+""是一样效果
	int b=12312312;
	string c=b.ToString();	 //整型变量转字符串


其它类型--->string
            int number=123123.5;
            string a=number.ToString();
            string b=number+"";
            string c=number.ToString("F2");//带上格式
            Console.WriteLine("{0:F2}",number);
c、Convert类：
Convert类：“万能”类型转换，实现任意两种类型之间的转换

   1、Convert.ToInt32():其它类型转成int型
	  eg:
		int a=Convert.ToInt32("123");
		int b=Convert.ToInt32(1.5+2);

	2、Convert.ToSingle():其它类型转成float型
	  eg:
		float a=Convert.ToSingle("123");
		float b=Convert.ToSingle('A'+1.5);
		//float c=(float)('A'+1.5);

	3、Convert.ToDouble():其它类型转成double型
	  eg:
	  	double a=Convert.ToDouble("123.5");

	4、Convert.ToBoolean():其它类型转成bool型
	   eg:
	  	bool a=Convert.ToBoolean("true");
	  	
	5、Convert.ToChar():其它类型转成char型
	   eg:
	  	char a=Convert.ToChar("A");
		//char b=char.Parse("A");

	6、Convert.ToString():其它类型转成string型
	    eg:
	  	string a=Convert.ToString(123.5);//不建议使用
		string b=123.5.ToString();
		string c=123.5+"";

	7、Convert.ToDecimal():其它类型转成decimal型
	 eg:
	  	decimal a=Convert.ToDecimal("1.25");
	  	
	  	具体应用：
   //输入整数
       int x=int.Parse(Console.ReadLine());
       int y=Convert.ToInt32(Console.ReadLine());

   //输入单精度
       float x=float.Parse(Console.ReadLine());
       float y=Convert.ToSingle(Console.ReadLine());

任意两种类型之间的互转
             Convert.ToInt32()
             Convert.ToSingle()
             Convert.ToDouble()
             Convert.ToDecimal()
             Convert.ToBoolean()
             Convert.ToChar()
             Convert.ToString()
             
             int a=Convert.ToInt32(1.5+10+20.1);

5、输入函数:

   1、输入函数：Console.ReadLine()
   可以接收一行数据的输入，接收的数据默认是string类型。
   只负责接收输入，不负责存储，需要用变量进行保存。

   eg:
	string name=Console.ReadLine(); //接收字符串数据
        
        string s1=Console.ReadLine(); // 输入字符串
        int a=int.Parse(Console.ReadLine()); // 输入整数
        int a=Convert.ToInt32(Console.ReadLine()); // 输入整数

三、运算符

1、运算符有4类：赋值运算符

赋值符号左边一定是变量名
1）基本赋值：
     =,把数据赋给变量
      用法:  变量名=值
      int a=10;
      a=20;
      a=10+20+30;
2）复合赋值：
      +=（累加）、-=、*=、/=、%=
      
      int a=10;
      a+=20;     //相当于a=a+20 ，所以a=30
      
      a+=30;	 //相当于a=a+30， 所以a=60

      a-=20;    // 相当于a=a-20; 所以a=40

      a*=3;	// 相当于a=a*3；所以a=120
      
      a*=2+1;	// 相当于a=a*(2+1)，所以a=360
      
      a/=5;	// 相当于a=a/5；所以a=72

      a%=5;	// 相当于a=a%5; 所以a=2

2、算术运算符：

1) ++ : 自增1
   eg:
	int a=10;

	//想让a增加1，变成11
	//a=a+1;
	//a+=1;
	//a++; //a=11
	//a++; //a=12

	a++;  // 后缀++
	++a;  // 前缀++

	//如果计算式子只有一个++的符号，前缀和后缀没有区别
	//如果计算式子有多个符号，前缀和后缀就有区别
	//区别在于优先级的不同：
		前缀优先级很高（要先计算），
		后缀优先级很低（最后计算）。
   eg:
		int a=10;
		
		//int x=a++; //后缀++最后计算
			     //x=10 a=11

		int x=++a;  //前缀++要先计算
		            //a=11  x=11
		

   eg:
		int a=1,b=2;

		//int x=a+(++b); //x=4
		int x=a+(b++);	 //()不影响++的优先级。x=3



	eg:
		int a=10;
		
		//int x=a--;  //x=10 a=9
		int x=--a;    //x=9 a=9
   
  2） +、-、*、/、%、++、--

	int a=+1,b=2; //+1：正1 （正号）
	int c=a+b;   //加法，c=3
	string s1="2020";
	string s2=s1+"年"+10+"月"; //字符串连接,s2="2020年10月"

	int d=-100; // 负号
	int e=a-b;  // 减法

	int f=a*b; // 乘法

	int g=a/b;  // 除法

	%:求余数，两个相除后的余数。也叫“取模运算”

	int x=10%3;  //10除以3，余数是1 。故x=1

3、关系运算符：

>、>=、<、<=、==(等于),!=(不等于)
主要用于两个数大小的比较。

关系表达式的结果只有两种:true和false(布尔类型的结果)

4、逻辑运算符:

&&(与)、||(或)、!(非)
1） &&：与运算符
1、表示并且的含义。在多个条件同时要满足的时候使用！
   运算规则：A&&B
	A和B同时为true，式子结果为true
	A和B只要一个为false，式子结果就为false

      eg:判断一个数x是否在0~100区间内的情况。
          x>=0&&x<=100

      当x=30，式子结果是：true
	 当x=150，式子结果是：false
	 当x=-1，式子结果是：false

  2、&&运算符有短路运算的特点：
     当第一个条件为false，后面条件就不需要计算
      	 eg:  int a=1,b=2;
	      bool c=a>b&&(b=3)<3;
	      
	      Console.WriteLine("b={0}",b); //b=2
2）||：或运算符
1、表示或者的含义。在多个条件只要满足其中一个就可以的时候使用！
      运算规则：A||B
	  A和B同时为false，式子结果为false
	  A和B只要一个为true，式子结果就为true

      eg:期末要考理论x和上机y两门课，只要一门不及格，
         全部要重考！
           x<60||y<60

	   当x=40，y=80，式子结果是：true
	   当x=90，y=70，式子结果是：false

2、||运算符有短路运算的特点：
   当第一个条件为true，后面条件就不需要计算
      	 eg:  int a=1,b=2;
	      bool c=a<b||(b=3)<3;
	      
	      Console.WriteLine("b={0}",b); //b=2
3）!：非运算符
  1、表示不的意思。
  	  运算规则：!A 得到条件的相反的结果
		A为true，结果是false
		A为false，结果是true
	eg:
		int a=10;
		
		Console.WriteLine("{0}",!(a>1)); //false
		Console.WriteLine("{0}",!(a>100)); //true
    有了非运算符，写条件时就可以有正面、反面的不同角度。
  
	eg:判断一个数a是否大于0
	   条件的写法：
	   	a>0     从正面角度写条件
	    !(a<=0) 从反面角度写条件

四、C#中程序常见的3种结构：

 

1、选择结构（流程分支结构）

1）选择分支结构:if
第一种形式的语法：
	
	if(条件)
	{
	    条件满足的时候要做的事情;
	}

   条件是通过关系运算符、逻辑运算符组成布尔型的表达式！
   
选择结构：
   f语句：有3种形式
 
   a、形式1：
        if(条件)
        {
            条件成立时，要做的事情;
        }

   b、 形式2：提供了两个分支（两种情况二选一的时候用）

	if(条件)
	{
		条件成立时，要做的事情;
	}
	else //否则
	{
		条件不成立时，要做的事情;
	}

	如果xxx，就做什么；否则，就做别的什么
	
	条件运算符:   ?:
	eg:
		int a=-10;
		int b=a>0?100:200;  //b=200
		double c=a<100?1.0:2.0; //c=1.0
		string d=a==0?"hello":"hi";d="hi"
		
  c、形式3：阶梯if

	if(条件1)
	{
		当条件1成立时，要做的事情;
	} 
	else if(条件2)
	{
		当条件2成立时，要做的事情;
	}
	else if(条件3)
	{
		当条件3成立时，要做的事情;
	}
	....
	else
	{
		当所有条件不成立时，要做的事情;
	}
2）switch语句： 
开关语句，多路选择结构。常用于等值判断。
   
   语法：

   switch(判断对象)   
   {	
	case 值1:语句块;break;
	case 值2:语句块;break;
        ...  
	default:语句块;break;
   }

   说明：
   1、判断对象常是bool、int、char、string型的变量或表达式;
      不能是float、double、decimal类型
      
   2、case语句可以有多个，每个case代表一种情形；
   
   3、case后一般跟常量/变量值，表示当判断对象等于该值时，就会执行后面的语句块！
   
   4、break语句:跳出switch结构；执行到break语句时，就意味着switch结构执行完成！
   
   5、default:默认。当判断对象跟case后任何一个值都不相等的时候，就会执行default语句。
      default语句相当于if结构中的else语句！
      default语句最多只有1条.
      
   6、case和default语句的顺序可以调整！

2、循环结构：

1）C#中有4种循环结构：for、while、do...while、foreach
循环结构用于解决什么样的问题？
	解决某种操作（比如输入、输出、计算、判断等）重复做的问题。
	
   eg:输出1~10000.  (输出这个动作是重复的)
   	Console.WriteLine("1");
	Console.WriteLine("2");
	...
	Console.WriteLine("10000");
a、for循环的语法：
     for(表达式1;表达式2;表达式3)
	{
		循环体(要重复做的事情);//4
	}

	表达式1：用于表示循环的起点，从什么时候开始循环。一般是赋值表达式。
		 eg:
		 	int i=1;
		 	
	表达式2: 用于表示循环进行的条件，条件成立时继续循环过程；条件不成立，循环就结束。
		(也说明了循环的终点在哪！)
		一般是布尔表达式。
		eg:
			i<=100
			
	表达式3: 用于表示循环变化过程。
	        这个式子一般叫“步长”。
		    一般是(复合)赋值表达式。
		 eg: 步长是1（每步增加1）
		 	i++;
			或
			i=i+1； // i+=1

	循环执行过程：
b、while循环：
1、当型循环
while(条件)
{
	重复做的操作;(循环体)
}

含义：当条件成立时，一直重复做...操作。
      当条件不成立，循环结束。
      一个for循环改成while循环：

for(1;2;3)		1;	
{			             while(2)
	4;      ==>	{
}				                 4;
			            	     3;
			    }
c、do...while循环：
do
{
	重复做的操作;

}while(条件);   //有分号结束！！

含义:
	重复做什么操作，直到条件不成立；
2）do...while和while/for的区别：

1、while/for循环是先判断条件，再执行循环体； 2、do...while循环是先执行一次循环体，再判断条件； 3、while/for循环最少的循环次数为0次，do...while循环最少的循环次数为1次。

3）死循环改写：
一般情况下,一个for循环改成do...while循环：

1、for(1;2;3)  		1;	
{			               do
	4;      ==>  	{
}				               4;
				               3;
                     }while(2);	
                     

 2、	for(;;)			while(true)
 	{			 {
			==> 
	}			 }	

	eg:
	   for(int i=1;i<=10;i++)
	   {
	   	  Cw(i);
	   }
       
	   等价于:
	   int i=1;
	   while(i<=10)
	   {
	   	  Cw(i);
		  i++;
	   }		

3、 for(;;)		 	    do
   {			     {
		==> 
   }			     }while(true);	

eg:
   for(int i=1;i<=10;i++)
   {
   	  Cw(i);
   }
   
   等价于:
   int i=1;
   while(i<=10)
   {
   	  Cw(i);
	  i++;
   }

五、VS

1、VS常见文件后缀：

    .sln:解决方案文件
    .csproj:c#项目文件
    .cs：c#源代码文件

2、C#项目的运行目录:

   bin/debug

3、程序运行和其它快捷键

    F5：调试运行
	（自动退出界面，解决办法：
	
		在代码最后加一句Console.ReadLine();
	）
	Ctrl+F5：不调试运行（不会自动关闭）

	注释代码：ctrl+K+C
	解除注释：ctrl+K+U
	全屏/解除全屏:alt+shift+enter

六、数组

1、程序中经常要存储数据：

1）用变量来存储。
  eg:
		int age=18;
		string name="张三";
	     一个变量存一个数。

问题：存储36个同学的考试成绩，怎么存？
如果用变量存储，要定义36个变量！！
	eg:
		int a,b,c,d,e,f,g...; //36个
这样写是很麻烦，或许说是不现实的。
2）用数组来存储。
数组：存储多个相同类型数据的集合。

一个数组可以保存多个同类型的数据！！

2、定义数组：

数据类型[] 数组名称;

数组名称跟变量名一样，要符合命名规则。
eg:
	int[] arr; //定义了一个int类型的数组arr
	string[] arr2; //定义了一个string的数组arr2

3、数组初始化:

数组要经过初始化之后才能使用。
初始化写法:
1）直接赋值
数组能够存多少个数，取决于它有多少个存储空间
存储空间的个数叫数组的长度。
   eg:
   	int[] arr={1,2,3,4,5};//数组长度为5
	string[] names={"张三","李四","王五"};//数组长度为3
	char[] cs={'A','B','C','D'};//数组长度为4
2）用new关键字:
如果一开始不知道存哪些具体的数。
   eg:
   	int[] arr=new int[5];//数组长度为5
	string[] names=new string[3];//数组长度为3
	char[] cs=new char[4];//数组长度为4
3）前2种混合写法：
eg:
   	int[] arr=new int[5]{1,2,3,4,5};
	int[] arr=new int[]{1,2,3,4,5};//省掉长度，正确的
	int[] arr=new int[5]{1,2}; //错误的
	int[] arr=new int[2]{1,2,3,4,5};//错误的

注意：数组一旦初始化完成后，长度将不能变化。
eg:
	int[] arr=new int[5];
	就只能存储5个数，不能自动扩容变成可以存更多数的数组。

4、数组中存储多个数，如何去访问其中的某个数？

   数组元素的访问方式：通过下标(索引)访问元素
   下标从0开始，第一个数下标为0，第二个数为1，....
   最后一个数下标为"数组长度-1"
   eg:
	int[] a={100,123,12,33,412,123,4};
	Console.WriteLine(a[0]); //100

5、数组输入输出（遍历）：配合循环结构！

           int[] arr = new int[5];// 保存5个人的年龄

            // 输入
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write("输入第{0}个人的年龄:",i+1);
                arr[i]= int.Parse(Console.ReadLine());
            }

            // 输出
            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine("第{0}个:{1}",i+1,arr[i]);
            }

6、foreach循环：通常用于遍历数组或集合。

语法：
	foreach(数据类型 变量 in 数组名)
	{
		要重复做的操作;
	}

eg:
	  int[] arr = { 10, 123, 123, 4, 314, 4, 23, 4 };
       

            // foreach遍历
            // var:匿名类型,运行时自动确定变量的类型
            // item：是一个迭代变量，用来保存遍历到的某个元素
            //           代表数组元素
            // 注意: 不能给变量item赋值
            // 数组的输入不能用foreach
            
            foreach (var item in arr)
            {
                //if (item>200)
                //{
                //    break;
                //}
                Console.WriteLine(item);

                //if (item%2==1)
                //{
                //    Console.WriteLine(item);
                //}
            }

七、回顾数据在程序的表示和存储

1、保存一个人的姓名，一个数据

    保存方式：定义变量
     string name="张三";

     保存某一个值的时候用变量。

2、保存10个人的姓名，用数组。

  数组：用来保存多个同类型的数据！
    string[] names={.....};

3、保存一个人的姓名、年龄、性别、电话等信息，怎么做？

   一般想到，用多个变量保存：
    string name="张三";
    int age=10;
    string sex="男";
    string phone="15646473";

    问题在于：数据之间没有关联性（没有关系）
    解决办法：用类与对象的知识！！

八、类与对象：

1、类：

字面意思就是类型，类别，分类。
    类用于表示某一类事物，
    一种事物就是一个类。
    
    eg:所有的人，就是人“类”;
       所有的狗，就是狗“类”
1）定义类：
语法：

   [访问修饰符] class 类名
   {
   	类的成员；
   }

   说明:
   1)class是定义类的关键字
   
   2)访问修饰符可选的，修饰类的访问修饰有：
   	public:公开的，本项目和其它项目都可以用
	internal:内部的，本项目可以用（默认）
	
   3)类名:要用大写字母开头,建议用帕斯卡命名法
   	class Student
	{
		
	}

	骆驼命名法:第二个单词开始字母大写
			eg:myStudentAge
			
	帕斯卡命名法:所有单词首字母大写
			eg:NanFangStudent
			
			
复习类的定义

	class Teacher
	{
		//字段
		int code;
		//属性
		public int Code
		{
			get{return code;}
			set{code=value;}
		}
		
		//==>简化：自动属性
		//pubic int Code{get;set;}

		//构造函数：用于创建对象的数据初始化
		public Teacher()
		{
		}
		public Teacher(int code) //带参
		{
			this.Code=code;
		}
	}
2）类的成员：
1）字段：用于保存特征值的变量
    语法：
	[访问修饰符] 数据类型 字段名;

    eg：
    	int code; // 学号字段
	string name; // 姓名字段
   说明：字段的访问修饰符常用的有：
   	public：公开的
	private: 私有的（默认，一般都用这个）
     字段名一般小写开头！！

2）属性：用于包装字段，间接对外公开字段，方便外部使用
    语法：
	[访问修饰符] 数据类型 属性名
	{
		get{return 字段名;} 
		set{字段名=value;}
	}
     访问修饰符一般用public!!
     属性名一般大写开头！！

     get访问器：包装读操作
     set访问器：包装写操作

   属性分成三种类型：
   (1)可读可写属性：get和set同时有（最常见）
   (2)只读属性:只有get
   (3)只写属性：只有set

2、对象：

 表示事物中的具体一个。
    eg:所有学生中，“张三”这个学生是具体的一个，
       就称为对象.

    对象的三要素：属性、方法、事件
    
    属性：表示对象的特征，比如说
          一个人的姓名、性别、年龄、身高等就是属性。
          
    方法：表示对象的行为，它能做什么。
          比如学生会学习、会开小差等
          
    事件: （暂时不学！）
          表示对某个动作产生的反应。

     拿具体的两个人来说：
     张三有姓名、年龄、性别的特征（属性），有学习的行为
     李四也有这些特征和行为
     王五也有。。。。
     
     N个对象都有共同的特征和行为，就可以把他们归为一类。
     所以在这类事物中，每个个体（对象）
     都有共同的特征和行为。
1）定义对象:用new关键字
 语法：
	类名 对象名=new 类名();
	（对象名就是变量名）
      eg:
      	Student zs=new Student();//创建一个对象zs
        
总结：
1）创建类的模板代码：（到今天为止）
 
    class 类名
    {
    	private 数据类型 字段名;
	....  // 字段可以有N个

	public 数据类型 属性名  //属性跟字段对应
	{
		get{return 字段名;}
		set{字段名=value;}
	}
    }

2）创建对象和对象使用的模板代码：
    
    类名  对象名=new 类名();  //创建对象
    对象名.属性名=值;         //给属性赋值
    Cw(对象名.属性名);	      //使用属性
2）对象的创建
    Teacher t1=new Teacher();//调用无参构造
	Teacher t2=new Teacher(1000);//调用带参构造
	//如何访问属性: 对象名.属性名
	// t2.Code

 

3、类与对象的关系：

     类表示群体，泛指的
	对象表示个体，特指的
    类是对象的模板，对象是类的实例（实际存在的一个例子）。

九、方法 

1、
	一种事物		   类
	外观/特征(是什么)	 属性
	能做什么？（作用）  方法
	
2、
	class Computer
	{
		//型号、厂家、价格
		// 字段
		string type;
		string factory;
		decimal price;
		
		// 属性：为了把字段对外公开
		public string Type
		{
			get{return type;}
			set{type=value;}
		}
		...
		
		//构造函数
		public Computer()
		{
		}
		public Computer(string t,string f,decimal p)
		{
			this.Type=t;
			this.Factory=f;
			this.Price=p;
		}

		// 方法：用于描述行为、功能
		// void：
		// 其它：int、char、float....
		public void Open() // 开机的方法
		{
			cw("电脑开机中....");
			//当类型为void时，
			//不能出现return语句
		}
		
		// 打印的方法：打印什么内容
		public bool Print(string content)
		{
			if(...)
			{
				Cw("打印"+content);
				return true;
			}
			else
			{
				return false;
			}
		}


	}


	Computer c1=new Computer();
	c1.Type="联想9527"; // 对象名.属性名
	c1.Factory="联想";
	c1.Price=5555;

	Computer c1=new Computer("联想9527","联想",5555);

	// 方法调用：对象名.方法名
	c1.Open(); 
	bool x=c1.Print("hello");// 有返回值
	
3、数组作为参数传递

4、方法两种类型：实例方法和静态方法两类。

 

1、方法的概念：

由一系列语句组成的代码块。
   在类中，方法用于描述对象的行为（能做什么，就是功能！）。
   一般来说，要实现一个功能，就可以用一个方法表示。
   eg:
   	软件的登录是一个功能，在实现时就可以写
	一个关于“登录”的方法。

2、 方法的意义：

1)降低软件的设计难度，把软件根据功能进行拆解，一个一个功能实现。
		这种思想叫“分治”。
		
2)实现代码的重用，方法写一次，可以被使用多次。
	    这种思想叫“复用”。

3、方法分类：实例方法和静态方法两类。

1）实例方法（非静态方法）：
		public void Study()
		{
			
		}

		对象名.Study(); // 调用

	静态方法：定义时多了一个关键字:static
		
		public static void Study()
		{
			
		}
		
		调用时不一样，要按“类名.方法名”进行调用
		类名.Study();
		

2）实例方法：属于对象，调用：对象名.方法名
	
	class Test
	{
		public void A()
		{
		}
	}

	调用:	
		Test t=new Test();
		t.A();


	静态方法：属于类，调用：类名.方法名

	class Test
	{
		public static void A()
		{
		}
	}

	调用：	
		Test.A();
1）实例方法的定义：
语法：
   	[访问修饰符] 数据类型 方法名([形式参数])
	{
		实现功能的代码;(方法体)
		[return 值;]
		
	}

   说明:
   1)访问修饰符：public/private，一般用public
	  因为方法一般都会给外面使用!
	  
   2)数据类型：表示该方法的反馈结果数据的类型。
	  反馈结果是以数据的形式给用户的。
	  这数据是什么类型，就写什么类型的关键字。
	  eg:
	  	查询余额时，反馈结果是decimal类型

	 常见类型关键字:
	  int\char\float\double\bool\decimal\string\数组\类
	  void:空的
     
      如果数据类型是void，表示没有反馈结果；
	 如果是其它关键字，表示有反馈结果。

	 反馈结果在这里叫“返回值”。
	 如何给使用者反馈？
	 在方法体中，通过return语句进行反馈！！
		return 值或表达式;  //返回某个值 

   3)方法名：公开的方法用大写开头
      
   4)方法的参数：可选，没有参数叫无参。
        定义语法：跟定义变量类似
	eg:
		int a,int b
		
       在方法调用过程中，实际参数的值
       会传递给形式参数接收。
       eg:
       	public int Add(int a,int b)
	{
		return a+b;
	}

	//调用
	对象名.Add(10,20);//其中：10传给a，20传给b
2）实例的方法的调用：
语法：
     如果方法无返回值:

     	对象名.方法名([实际参数])
   
     如果方法有返回值：

        变量=对象名.方法名([实际参数])

4、方法重载：

  问题:在一个类中，能否定义多个同名的方法？
        是可以的，但是参数个数或类型不同
        
   方法重载：在同一个类中，多个方法名称相同，但参数个数或类型不同

5、字符串类的使用（属性和方法）

 
posted @   一只菜喵程序媛  阅读(110)  评论(0)  编辑  收藏  举报
相关博文：
· CS架构编程（六）
· Java程序编程（十）
· C#基础学习
· C#基本语法
· C#第二课基础语法
阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· 葡萄城 AI 搜索升级：DeepSeek 加持，客户体验更智能
· 什么是nginx的强缓存和协商缓存
· 一文读懂知识蒸馏
点击右上角即可分享
微信分享提示