c#学习总结，三天学习成果总结

c#学习笔记

day 20/07/10

1、关键字

保留关键字
abstract	as	base	bool	break	byte	case
catch	char	checked	class	const	continue	decimal
default	delegate	do	double	else	enum	event
explicit	extern	false	finally	fixed	float	for
foreach	goto	if	implicit	in	in (generic
modifier)	int
interface	internal	is	lock	long	namespace	new
null	object	operator	out	out
(generic
modifier)	override	params
private	protected	public	readonly	ref	return	sbyte
sealed	short	sizeof	stackalloc	static	string	struct
switch	this	throw	true	try	typeof	uint
ulong	unchecked	unsafe	ushort	using	virtual	void
volatile	while					
上下文关键字
add	alias	ascending	descending	dynamic	from	get
global	group	into	join	let	orderby	partial
(type)
partial
(method)	remove	select	set		

using 关键字:

在任何 C# 程序中的第一条语句都是：

using System;

using 关键字用于在程序中包含命名空间。一个程序可以包含多个 using 语句。

class 关键字:

class 关键字用于声明一个类。

C# 中的注释

注释是用于解释代码。编译器会忽略注释的条目。在 C# 程序中，多行注释以 /* 开始，并以字符 */ 终止，如下所示：

/* This program demonstrates
The basic syntax of C# programming 
Language */

单行注释是用 ‘//’ 符号表示。例如：

}//end class Rectangle 

文档注释：’///‘，vs2019自动生成

/// <summary>
/// 这是注释主体
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>

2、基本结构

using System;
/*命名空间，和Java不同的是文件名可以和类名不同*/
namespace HelloWorldApplication
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

3、基本数据类型

类型	描述	范围	默认值
bool	布尔值	True 或 False	False
byte	8 位无符号整数	0 到 255	0
char	16 位 Unicode 字符	U +0000 到 U +ffff	‘\0’
decimal	128 位精确的十进制值，28-29 有效位数	(-7.9 x 10^28 到 7.9 x 10^28) / 10^0 到 10^28	0.0M
double	64 位双精度浮点型	(+/-)5.0 x 10^-324 到 (+/-)1.7 x 10^308	0.0D
float	32 位单精度浮点型	-3.4 x 10^38 到 + 3.4 x 10^38	0.0F
int	32 位有符号整数类型	-2,147,483,648 到 2,147,483,647	0
long	64 位有符号整数类型	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0L
sbyte	8 位有符号整数类型	-128 到 127	0
short	16 位有符号整数类型	-32,768 到 32,767	0
uint	32 位无符号整数类型	0 到 4,294,967,295	0
ulong	64 位无符号整数类型	0 到 18,446,744,073,709,551,615	0
ushort	16 位无符号整数类型	0 到 65,535	0

判断数据类型长度代码：

using System;

namespace DataTypeApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

4、引用数据类型

string:
	字符串（String）类型 允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。
C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
string str = @"C:\Windows";
等价于：
string str = "C:\\Windows";

object:
	对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。
当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。
object obj;
obj = 100; // 这是装箱

dynamic:
	可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
声明动态类型的语法：
dynamic <variable_name> = value;
例如：
dynamic d = 20;
动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。
    
指针类型（Pointer types）:
	指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法：
type* identifier;
例如：
char* cptr;
int* iptr;

day 20/07/11

5、运算符

算术运算符

下表显示了 C# 支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
–	自减运算符，整数值减少 1	A-- 将得到 9

逻辑运算符

下表显示了 C# 支持的所有逻辑运算符。假设变量 A 为布尔值 true，变量 B 为布尔值 false，则：

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A || B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

下表列出了 C# 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A | B) 将得到 61，即为 0011 1101
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

赋值运算符

下表列出了 C# 支持的赋值运算符：

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
|=	按位或且赋值运算符	C |= 2 等同于 C = C | 2

其他运算符

下表列出了 C# 支持的其他一些重要的运算符，包括 sizeof、typeof 和 ? :。

运算符	描述	实例
sizeof()	返回数据类型的大小。	sizeof(int)，将返回 4.
??	如果第一个为null，返回第二个，否则返回第一个	null??“123”，将返回123；
typeof()	返回 class 的类型。	typeof(StreamReader);
&	返回变量的地址。	&a; 将得到变量的实际地址。
*	变量的指针。	*a; 将指向一个变量。
? :	条件表达式	如果条件为真 ? 则为 X : 否则为 Y
is	判断对象是否为某一类型。	If( Ford is Car) // 检查 Ford 是否是 Car 类的一个对象。
as	强制转换，即使转换失败也不会抛出异常。	Object obj = new StringReader(“Hello”); StringReader r = obj as StringReader;

C# 中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。

例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。

下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	||	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= |=	从右到左
逗号	,	从左到右

day 20/07/12

6、函数参数修饰符

无修饰符

如果一个参数没有用参数修饰符修饰，则认为将按值进行传递，这将意味着调用的方法收到原始数据的副本

//主方法
void diaoyong(){
	string msg = "hello lisi,are you ok?";
    beidiaoyong(msg);
    Console.WriteLine(msg);//输出“hello lisi,are you ok?”
}
//被待用方法
void beidiaoyong(string msg){
    msg = "are you ok?";
    Console.WriteLine(msg);//输出“are you ok?”
}

out

输出参数由被调用的方法赋值，因此按引用传递，如果被调用的方法没有给输出参数赋值，就会出现编译错误，out最大的壅土就是调用者只使用一次方法的调用就能返回多个值

//主方法
void diaoyong(){
	string msg = "hello lisi,are you ok?";//此处可以不赋值
    beidiaoyong(out msg);
    Console.WriteLine(msg);//输出“are you ok?”
}
//被待用方法
void beidiaoyong(string msg){
    msg = "are you ok?";//必须修改
    Console.WriteLine(out msg);//输出“are you ok?”
}

ref

调用者赋值，并且可以由被调用的方法可选的重新赋值（数据是按引用传递的），如果被调用的方法未能给ref赋值，也不会有编译错误

//主方法
void diaoyong(){
	string msg = "hello lisi,are you ok?";//此处必须要赋值
    beidiaoyong(ref msg);
    Console.WriteLine(msg);//输出“are you ok?”
}
//被待用方法
void beidiaoyong(string msg){
    msg = "are you ok?";//可以修改，也可以不修改
    Console.WriteLine(ref msg);//输出“are you ok?”
}

params

这个参数修饰符允许将一组课变得数量的参数作为单独的逻辑参数进行传递，方法只能有一个params修饰符，而且必须是方法的最后一个参数

7、封装

封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。

一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

• public：所有对象都可以访问；
• private：对象本身在对象内部可以访问；
• protected：只有该类对象及其子类对象可以访问
• internal：同一个程序集的对象可以访问；
• protected internal：访问限于当前程序集或派生自包含类的类型。

public double Buy(int x,int y){
    return x+y;
}

8、面向对象（OOP）

基本概念：

面向过程：怎么做？
1）、把完成某一个需求的所有步骤 从头到尾 逐步实现
2）、根据开发需求，将这些 功能独立 的代码 封装 成一个有一个 函数
3）、最后完成的代码，就是顺序的调用不同的函数
面向对象：谁来做？
相比较函数，面向对象是更大的封装，根据职责，在一个对象封装多个方法
1）、在完成某一个需求前，首先确定职责，要做的事情（方法）
2）、根据职责确定不同的 对象，在 对象 内部封装多个不同的方法（多个）
3）、最后完成的代码，就是顺序的让 不同的对象 调用不同的方法

特点

1. 注重对象和职责，不同的对象承担不同的职责
2. 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供固定套路
3. 需要在面向过程的基础上，再学习一些面向对象的语法

9、类和对象

类: 类是一群具有相同 特征 或者行为 的事务的一个统称，是抽象的，不能直接使用

​ 特征：被称为属性 行为：被称为方法

对象: 对象是由类创造出来的一个具体存在，可以直接使用

类和对象的关系:

• 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
• 类只有一个，而对象可以有很多个
• 不同对象之间属性的具体内容可能各不相同
• 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少

总结

c#语法和java类似，因为我学习过java，所以理解起来就比较简单了，可能有些地方不一样，c#的分支结构和循环结构就不加了，现在开始学习oracle数据库，c#基础告别，之后再学习.NET和windows窗体，微微吐槽一下，c#的窗体比swing好看，哈哈哈哈
个人网站：LoongLove站点1；LoongLove站点2
个人Github：github
推荐学习站点：bilibili，菜鸟教程，我要自学网，mdn等