C#基础知识学习笔记

1-注释方式

​ 1）//：单行注释

​ 2）/…/：多行注释

2-转义字符

• 制表符（\t）：用于定位显示的数据，相当于Tab

• 换行符（\n）:换行输出

• 单引号（'）

• 双引号（"）

3-常量声明：const关键字

const PI=3.14;  //使用const声明常量后不能在程序中再对值进行修改

4-占位符

将占位符中的值使用变量进行替换，占位符编号从0开始

int a=1,b=2,c=3;Console.WriteLine("a={0},b={1},c={2}",a,b,c)

5-算数运算符

取整（/）：小除大为0，大除小取整数

取余（%）：小除大为小，大除小取余

6-逻辑运算符

与&& 或|| 非！

7-关系运算符

条件？结果1：结果2 条件真=结果1，否则=结果2

8-数据类型转换

值–>字符串：.ToString()

int a = 100;
string b=a.ToString();
Console.WriteLine(b);

字符串–>值：.Parse

string a = "200";
int b=int.Parse(a);
Console.WriteLine(b);

9-一维数组

数组声明+定义

int [] arr=new int[index]; //index为数组的索引号，索引 从0开始

初始化数组

int [] arr={1，2，3，4};

//输入数组长度，并为每个索引赋值，赋值完成后输出每个索引的值
Console.WriteLine("请输入数组的长度：");
int length=int.Parse(Console.ReadLine());
int[] arr3 = new int[length];      
//定义数组
for (int j = 0; j < arr3.Length; j++){    
Console.WriteLine("请输入第{0}个数值",j+1);    
arr3[j]=int.Parse(Console.ReadLine());    
//为每个位置赋值
}    
Console.WriteLine("打印数组内容为：");    
for (int j = 0; j < length; j++){    
Console.WriteLine("第{0}个的值为：", arr3[j]);    
Console.WriteLine(arr3[j]);    
//输出
}

10-二维数组

数组声明+定义

int[,]=new int[2,3]{ {1,2},{2,3},{3,4} }; //声明一个2行3列的二维数组，并为数组赋值

//二维数组的遍历int[,] 
arr=new int[2,3]{ {1,2},{2,3},{3,4} }; 
for(i=0;i<arr.GetLength(0);i++)//循环行。GetLength(0)获取行数
{    
for(j=0;j<arr.GetLength(1);j++)//循环列。GetLength(1)获取列数    
{    
Console.Write(arr[i,j]);    
}    
}

11-函数

函数是一种封装起来能实现一定功能的代码

语法：修饰符 返回值类型 方法名(参数类型 参数名)

{

方法体;

return 返回值;

}

修饰符：static静态的，private私有的，public公有的

11.1-无参数、无返回值：void表示没有返回值

static void HelloWorld() {
    Console.WriteLine("hello world");
}

11.2-有参数、没有返回值

static void Sum(int a,int b)
{    
int Sum=a+b;    
Console.WriteLine(Sum);
}

11.3-有参数、有返回值

 static int Sum2(int a,int b)  
 //int为返回值类型
 {    
 int Sum2=a+b;               
 Console.WriteLine(Sum2);    
 return Sum2;  
 //使用return返回结果
 }

12-枚举

声明枚举：使用关键字enum

如：enum Motor{启动,停止,正转,反转} //定义一个名为Motor的枚举类型

引用枚举：

Motor mortor=new Mortor()； //实例化枚举

Motor mortor=new Mortor();    
//实例化枚举
motor=Motor.启动;
Console.WriteLine(motor);  
//以内容的形式显示
Console.WriteLine((int)motor);   
//以数值的形式显示

13-结构体

声明结构体：使用关键字struct

struct Motor
{
  public string Start;
  public string Stop;
}

引用结构体

Morot motor=new Motor();    
//实例化结构体
motor.Start="电机启动";
motor.Stop="电机停止";  
Console.WriteLine("motor.Start");  
//与西门子的博图软件中建立的结构体变量很类似。

14-类和对象

类是对象的一个抽象，一个模型

对象是类的实例，可以用类来实例化对象。

新建一个类，如果想使用类中的元素，需要实例化类。

如：新建Motor的类

internal class Motor  
//新建Motor类文件    
{        
public string Start;  
//定义全局变量        
public string Stop;        
public void Dianji()  
//定义全局函数        
{            
Console.WriteLine("电机状态有：{0}、{1}",this.Start,this.Stop);        
}    
}

引用类：

Motor motor = new Motor();    
//实例化类
motor.Start = "启动";        
//引用类中的元素
motor.Stop = "停止";
motor.Dianji();

15-类的静态成员

在类中声明成员时，加入static。此时调用类中的成员可以不用实例化类

internal class Motor    
{    
//在类型前面加static        
public static string Start;
//static静态成员        
public static string End;        
public static void Qidong()        
{            
Console.WriteLine("启动");        
}           
}

调用类

//静态成员调用 ，不需要实例化对象
//实例成员会单独占用一个内存
//静态成员共享一个内存
Motor.Start = "开始启动";
Motor.End = "开始停止";
Motor.Qidong();

16-重载

在同一个类中，方法名相同，参数类型或个数不同
在类中声明两个名称相同的方法，调用时即可选择性的传递自己需要的方法中的参数。

internal class Employee    
{        
//使用三斜杠解释代码块的具体含义
/// <summary>        
/// 计算A类工资        
/// </summary>        
/// <param name="baseSa">基本工资</param>        
/// <param name="workYear">工作年限</param>        
/// <param name="yearSa">工资年龄</param>        
/// <returns>总工资</returns>           
//将两个方法的名称设置一致，返回值也要一致，才能构成重载        
public double Salary(double baseSa,int workYear,double yearSa)        
{            
double sum = baseSa + workYear * yearSa;            
return sum;        
}        
/// <summary>        
/// 计算B类工资        
/// </summary>        
/// <param name="baseSa">基本工资</param>        
/// <param name="workYear">工作年限</param>        
/// <param name="yearSa">工资年龄</param>        
/// <param name="ProSa">项目资金</param>        
/// <returns>总工资</returns>        
public double Salary(double baseSa, int workYear, double yearSa,double ProSa)        
{            
double sum = baseSa + workYear * yearSa+ProSa*0.1;            
return sum;        
}    
}

调用类

Employee emp = new Employee();    
//实例化类
double Salary1 = emp.Salary(10, 10, 10);        
//调用方法1
double Salary2 = emp.Salary(10, 10, 10, 1000);   
//调用方法2
Console.WriteLine(Salary1);Console.WriteLine(Salary2);

17-get set访问器

将属性私有化，通过公有化的方式进行操作

get{}访问器：设置对象可读，用于获取字段的值，需要使用return返回字段的值。

set{}访问器：设置对象可写，用于设定字段的值，需要使用一个特殊的值，这个值就是在面向对象设计中，对字段设置的值。

public  数据类型 属性名
{        
get            
{                    
获取属性的语句块;                    
return 值;            
}       
set            
{                
设置属性得到语句块;            
}
}

在新建类中对属性进行定义时，使用Public则外部程序可以随意对类中的属性进行修改，使用private则外部程序又无法访问，此时可以对private定义的属性通过get，set访问器来进行访问。

private string status;     
public string Status    //通过Status访问status
{
//通过共有的Status对私有的status进行读写操作
//外部程序中调用Status，对Status的写操作经由set赋值给status。    
get { return status; }    //设置属性可读    
set //设置属性可写,value为外部传给过来的值。经过Status传给status   
{ //当外部程序输入的内容不是"正转"、"反转"的话显示输入错误       
if (value.Equals("正转")||value.Equals("反转"))       
{           
status = value;  //关键字、将外部输入的内容赋值给value然后由value写给status       
}       
else           
status = "输入错误";     
}   
}

static void Main(string[] args)        
{            
Motor motor=new Motor();            
motor.Num = 1;            
motor.Status = "正转";            
motor.MoStatus();        
}

访问流程-执行 motor.Status = “正转”;调用Status中的set访问器，将"正转"传给value，再经value传给private中的ststus

18-构造函数

特点—名字必须与定义它的类名完全相同，并且没有返回类型；

在使用new关键字创建对象时系统自动调用

主要作用为初始化对象时给对象成员赋初值

internal class Motor
{    
public string EquName { get; set; }    
public string EquStatus { get; set; }    
//构造一个与类名相同的函数，参数类型与类中的参数一致，并将参数进行传递    
public  Motor(string equName,string equstatus)//名称与类名相同，实例化的同时赋值    
{        
EquName = equName;        
EquStatus = equstatus;    
}    
public Motor()    //先实例化再赋值，即创建一个构造函数的重载    
{ 
}
public void MStatus()    
{        
Console.WriteLine("{0}电机{1}",EquName,EquStatus);    
}
}

static void Main(string[] args){     //创建对象时自动执行的函数     Motor M1= new Motor("行走","正转");     M1.MStatus();
Motor M2 = new Motor();      M2.EquName = "升降";     M2.EquStatus = "上升";     M2.MStatus();          }

19-继承

类与类之间可以形成继承的关系，即父类与子类之间的关系。

格式：子类:父类

实例化子类可以引用父类中的声明

建立子类SaleMan

internal class SaleMan:Employee  //表示Employee这个类是SaleMan这个类的父类    
{        
public string WorkYear { get; set; }    
}

​ 建立父类Employee

internal class Employee  
//父类中的元素在子类中均可用    
{        
public string Num { get; set; }        
public string Name { get; set; }        
public string Sex { get; set; }    
}

调用类

SaleMan Sale=new SaleMan();Sale.Name = "ABCD";  
//Name本为Employee中的元素，由于Employee为SaleMan的父类，故SaleMan实例化后有父类的属性

20-集合ArrayList、Hashtable

可以在集合中放不同的元素类型，编译不会报错但是运行会报错，为防止这种情况建议使用泛型集合

ArrayList类似于数组，大小可根据需要动态改变，可放多种类型数据，是有序的，由下标索引。

如：创建一个Motor的类，并在类中创建对应的构造函数

public Motor(string equName, string equStatus)//构造函数
{     
EquName = equName;     
EquStatus = equStatus;
}
public string EquName { get; set; }
public string EquStatus { get; set; }

通过ArrayList集合对其进行操作

//实例化多个类元素，并给其赋初值Motor M1 = new Motor("走行1", "正转");Motor M2 = new Motor("走行2", "反转");Motor M3 = new Motor("升降1", "正转");Motor M4 = new Motor("升降2", "反转");Motor M5 = new Motor("旋转1", "正转");Motor M6 = new Motor("旋转2", "正转");//声明集合 ArrayList list = new ArrayList(); //向集合添加元素list.Add(M1);list.Add(M2);list.Add(M3);list.Add(M4);list.Add(M5);list.Add(M6);//获取元素个数Console.WriteLine(list.Count);//获取指定的元素Console.WriteLine("第3个元素:" + ((Motor)list[2]).EquName);//将list中的元素进行强制转换，输出名称Console.WriteLine("第3个元素:" + ((Motor)list[2]).EquStatus);//将list中的元素进行强制转换，输出状态Console.WriteLine();//遍历集合Console.WriteLine("for 循环遍历----------------------------");for (int i = 0; i < list.Count-1; i++){    Motor tempM = (Motor)list[i];//将集合中的元素强制转换    Console.WriteLine("{0}电机{1}",tempM.EquName,tempM.EquStatus);}
Console.WriteLine(); //换行
Console.WriteLine("foreach循环遍历----------------------------");foreach (Motor item in list){    Console.WriteLine("{0}电机{1}", item.EquName, item.EquStatus);}Console.WriteLine();//删除元素list.Remove(M1);//根据对象删除list.RemoveAt(1);   //根据下标删除//插入元素Motor M7 = new Motor("走行3", "正转");list.insert(2,M7);//在指定索引处插入元素Console.WriteLine();//清除list.Clear();

Hashtable类代表了一系列基于键的哈希代码组织起来的键值对。无序的，没有下标,以键值对的方式存储

如：创建一个Motor的类，以EquNo为键值对进行操作

public Motor(string equNo, string equName, string equStatus)
{
//根据equNo对集合进行操作   
EquNo = equNo;   
EquName = equName;   
EquStatus = equStatus;
}
public string EquNo{ get; set; }
public string EquName { get; set; }
public string EquStatus { get; set; }

通过HashTable集合对其进行操作

Motor M11 = new Motor("001", "走行1", "正转");//实例化类并赋值
Motor M12 = new Motor("002", "走行2", "反转");
Motor M13 = new Motor("003", "升降1", "正转");
Motor M14 = new Motor("004", "升降2", "反转");  
Hashtable hslist = new Hashtable(); //声明集合并实例化
hslist.Add(M11.EquNo, M11); //M11.EquNo为唯一的键值对，
hslist.Add(M12.EquNo, M12);
hslist.Add(M13.EquNo, M13);//要添加元素的键和元素的值
//获取某个元素
Console.WriteLine("编号为001的设备:" + ((Motor)hslist["001"]).EquName);
Console.WriteLine("编号为002的设备:" + ((Motor)hslist["002"]).EquStatus);          
Console.WriteLine("编号为001的设备:" + ((Motor)hslist[M14.EquNo]).EquName);//获取M14对应编号的设备名
Console.WriteLine();
//循环遍历(遍历键、遍历值)
Console.WriteLine("遍历键-----------------------");
foreach (string item in hslist.Keys)//键的类型全部为字符串类型
{
    Console.WriteLine(item+"   ");
}
Console.WriteLine();
Console.WriteLine("遍历值----------------------------");
foreach (Motor item in hslist.Values)   //将键值对的值进行组合
{
     Console.WriteLine("设备号:{0},设备名:{1},设备状态:{2}", item.EquNo, item.EquName, item.EquStatus);
}
Console.WriteLine();
//删除，通过键值对删除
hslist.Remove("001");
//添加元素
hslist.Add(M14.EquNo,M14);
foreach (Motor item in hslist.Values)   //将键值对的值进行组合
{
   Console.WriteLine("设备号:{0},设备名:{1},设备状态:{2}", item.EquNo, item.EquName, item.EquStatus);
}
//清除
hslist.Clear();

21-泛型集合List、Dictionary

只能在泛型集合中存放相同的类元素

List是可以与任何数据类型一起工作的类或方法，用来创建集合类，使用方法与ArrarList方法类似

创建Travel的类，并为其创建构造函数赋初值

public Travel(string trNo,string trName)    //构造函数，在声明时赋值
{
    TRNo = trNo;
    TRName = trName;
}
public string TRNo;
public string TRName;

通过List泛型集合对其进行操作

Travel TR1 = new Travel("001", "走行1");
Travel TR2 = new Travel("002", "走行2");
List<Travel> list=new List<Travel>();   //list里面只能添加Travel类中的元素
//添加
list.Add(TR1);
list.Add(TR2);           
//获取元素个数
Console.WriteLine("共有"+list.Count+"个元素");            
//获取指定的元素
Console.WriteLine("第2个元素：" + ((Travel)list[1]).TRName);
//插入
Travel TR3 = new Travel("003", "走行3");
list.insert(0, TR3);//将TR3插入到索引0的位置
//删除
list.Remove(TR2);
list.RemoveAt(0);
//遍历
foreach (Travel item in list)
{
    Console.WriteLine("遍历设备编号:{0},设备名称{1}", item.TRNo, item.TRName);
}
//清除
list.Clear();

Dictionary(数据字典)通过键值对进行操作，可以通过键值对进行快速访问，操作方法与HashTable类似。

创建Travel的类，并为其创建构造函数赋初值

public Travel(string trNo,string trName)    //构造函数，在声明时赋值
{
    TRNo = trNo;
    TRName = trName;
}
public string TRNo;
public string TRName;

通过Dictionary对其进行操作

Travel TR1 = new Travel("001", "走行1");
Travel TR2 = new Travel("002", "走行2");
//<>中是键值对的类型，值
Dictionary<string, Travel> dict = new Dictionary<string, Travel>();   //指定键和值的类型
//添加
dict.Add(TR1.TRNo, TR1);
dict.Add(TR2.TRNo, TR2);
//获取元素个数
Console.WriteLine("共有："+dict.Count +"个元素");
//删除，通过键值对删除
dict.Remove("001");      
//遍历键值对
foreach (string item in dict.Keys)
{
    Console.WriteLine(item);
}
//遍历值
foreach (Travel item in dict.Values)
{
    Console.WriteLine("设备编号:{0},设备名称{1}", item.TRNo, item.TRName);
}
//清除
dict.Clear();