笔记与心得：C#基础知识知识点

归一 9年前 (2015-08-07) C# 3581人围观 20481字抢沙发百度已收录

----------------------以下为我在黑马程序员学习期间整理的笔记和心得，期待与您交流！ ----------------------
--1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

-引用命名空间

--2

namespace 追溯
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

-定义了一个命名空间，叫：追溯

--3

    class Program
    {
        static void Main(string[] args)
        {
        }
    }

-定义了一个名称为Programm的类

--4


        static void Main(string[] args)
        {
        }

-这是一个方法，叫做Main

--5
.sln是解决方案文件

--6
.csproj是项目文件

--7
Console.WriteLine("你想显示的内容");

--8
Console.ReadKey();
当程序执行到Console.ReadKey();时，程序会停到这里，等待用户从键盘上键入后，程序才继续执行

--9
WriteLine，光标出现在下一行

--10
Write，光标出现在这句话后面

--11
第一种：单行注释，以//开始，到本行结束

第二种：多行注释/*开始 /*结束，之间的都为注释

第三种：文档注释，用于对类和方法进行注释
，在类或方法前面连续输入3个/

--12
namespace 我的第一个项目
{
/// <summary>
/// 在这个类中有一个Main方法，使我们程序的入口方法。
/// </summary>

--13

 class Program
    {
        /// <summary>
        /// 程序运行时，从这里执行代码
        /// </summary>
        /// <param name="args"></param>

--14
Home 无论光标在哪，按下后跳转到该行最前面

--15
End 无论光标在哪，按下后跳转到该行最后面

--16
Page up 上翻一页

--17
Page down 下翻一页

--18
Shift 选中多个字符

--19
Ctrl+End 整个文档最后面

--20
Delete 删除光标后面的

--21
Backspace 删除光标前面的

--22
Insert 覆盖字符

--23
over 插入字符

--24
Ctrl Z/X/C/V 撤销/剪贴/复制/粘贴

--25
F5调试程序

--26
.F6生成程序

--27
#Region和#Endregion 折叠语段

#region 我的第一个程序
Console.WriteLine("***************************");
Console.WriteLine("* 这是我的第一个程序 *");
Console.WriteLine("***************************");
Console.ReadKey();
#endregion

--*
CLR：公共语言运行时

CLS：公共语言规范

CTS：通用类型系统

JIT：即时编译器

--28
用户存储正在运行的程序数据（不准备）

RAM:内存有个特点，断电后里面的数据丢失。

变量：变量代表着一块内存空间，我们可以通过变量名称向内存存/取数据，有变量就不需要我们记忆复杂的内存地数据类型

--29
整数字在C#中的数据类型叫做INT

int number

number=1000 //把1000放进去

赋值：变量名=值

PS:number加引号显示number，不加引号显示值

--30
1.A.整型:int
......

B.非整型：double （小数）
decimal （金钱）

2.非数值
char
String

--31
nt 所包含的值前后20万

double:小数

char:字符型只能存储一个字符，并且存储的这个字符要求用单引号引起来

string:字符串把0个或1个或多个字符连接以来，字符串要求用双引号连接起来

int： 3 5 100

double： 3.14 10.5 -3.14

char： 'A' 'b' 'a'

string: "zhangsan" "李四" "计算"

decimal：（存储金钱）5.26
__decimal d=5.55m

十几位以上的数字用decimal
十几位以下用double
注意：在C#开发环境中，直接写一个有小数点的数字，这个数字是double类型的。
在一个小数后面加一个m/M，就告诉编译器这个数字是decimal。

--32
变量声明的三种方法：

1.先声明后赋值 int a; a=3

2.定义变量时直接赋值 int a=3;

3.可以一次声明多个同类型的变量，多个变量之间用，相隔最后以；结束

string zsname, lsname, wwname;
zsname = "zs";
lsname = "ls";
wwname = "ww"

--33
变量的命名规则：

1.必须以“子母”或@符号

2.后面可以跟任意“子母”，数字，下划线

注意

1.起的变量名不要和c#系统中的关键字重复（关键词会变为蓝色）

2.在c#中，大小写是敏感的

3.同一个变量名不允许重复定义（不严谨）

--*
c#变量名编码规范

Camel 命名法：
首个单词的首字母小写，其余单词的的首字母大写

Pascal ，命名规范：
每个单词的第一个字母都大写

如果使用到英文单词的缩写，全部使用大写

--34
赋值运算符：=

a=a+1；这里的=号是赋值运算符，不是数学意义上的相等。

变量可以重复赋值，一旦给一个变量赋了新值，那么变量中的老值就不复存在了。

右边代码的输出结果：

int age = 10;

age = 20;

Console.WriteLine(age);

--35
“+”在C#中有两个意义

1.是数学中的加法运算：两边参与加法运算的数据类型为数字类型，则“+”表示数学上的加法的意义

2.是连接意义：两边参与加号运算的数据，有一个是字符类型，那么这个“+”就是连接意义

string a = "1";
int b = 2;
Console.WriteLine(a+b);
输出的值为12

--36
在Conslole.Writeline("")中，第一个变量/字符串中可以使用占位符

占位符由｛数字｝组成，数字由0开始编号

第一个占位符:{0}
第二个占位符:{1}
第三个占位符:{2}

--37
长数字用string

string wname="张三";
int wage=18;
char wsex='男';
string phone="010-110-2";
Console.WriteLine("我叫{0},今年{1}岁了,性别{2},电话{3}",wname,wage,wsex,phone);

--38
变量交换

int a = 10;
int b = 5;
int temp;
temp = a;
a = b;
b = temp;
Console.WriteLine("a={0},b={1}",a,b);

--39
用于让用户从键盘上输入一句话，当程序执行到下面这句话，就会暂停，然后等待用户从键盘上输入一句话，按回车程序会继续执行。如果想得到用户输入的内容，就

需要定义一个string类型的变量，写在下面这句话前面接受用户输出的内容。

Console.ReadLine().

---40
用户输入
接受用户输入的内容，必须定义一个字符串来进行接受
string input=Consloe.ReadLine();

--41
在屏幕上显示：c#用的字符用“”包含起来

\+一个字符，组成转义字符，他由一个+一个子母来组成具有特殊意义的一个字符

Console.WriteLine("c#中的字符要用\"\"引起来");
c#用的字符用“”包含起来

--42
\n 换行
Console.WriteLine("1\n2");

--43
\b baskspace 退格
Console.WriteLine("1\b2\b3");

--44
\t tab键由多个空格组成的一个字符，具有行与行之间的对其功能
Console.WriteLine("1\t2\t3\t4\t5\t");
Console.WriteLine("1\t22\t333\t4444\t55555\t");

--45
\\ 表示一个

--46
在字符串前面加@符号有两种意义

1.字符串中如果有，则不再理解为转义符。
Console.WriteLine(@"C:\Users\Zank\Desktop\NET听课笔记");

2.使字符串可以换行
Console.WriteLine(@"C:\Users\Zank
\Desktop
\NET听课笔记");

如果字符串前面加了@符号，在字符串上用两个双引号代表一个双引号
Console.WriteLine(@"C:\Users\Zank""\Desktop\NET听课笔记");

--47
算术运算符及算数表达式

算术运算符： + — * / % (去余数取模)

算数表达式：由算数运算符连接起来的式子。如：1+1 a-b （变量ab前面已经声明并赋初值）

优先级：先乘除，后加减，有括号先算括号里面的，相同级别从左至右运算

小括号可以无限制的套用，但一定要成对出现。
int chinese = 90;
int math = 80;
int english = 91;
int sun = chinese + math + english;
int avg = sun / 3;
Console.WriteLine("您的总成绩是{0},平局成绩是{1}", sun, avg);

--48
发生自动转换的条件
1.参与运算的两个数据类型必须相兼容
2.必须一边的数据类型表示范围小，一边的范围大，比且把小的转向大的不丢失精度

Double中包含int
//int a = 10, b = 3;
//int mod = a % 3; 【%取余数，输出1】
//double quo = a / b; 【/取模，输出3，将int转化为double类型】
//Console.WriteLine("mod={0} qup={1}", mod, quo);

--49
一个表达式，如果其中一个操作数为double类型，那么整个数为double类型(double的精度为15)
int a = 10, b = 3;
int mod = a % 3;
double quo = 1.0*a / b;
Console.WriteLine("mod={0} qup={1}", mod, quo);

--50
这里quo输出的值为3.333333333333333，为double类型，这是double除以double，如果为int除以double则显示3

--51
Convert不再仅是内存级别的转换，而是老驴数据意义的转换。

Convert是一个加工、改造的过程

Convert.ToInt32(待转换字符串)

Convert.Tostring每种类型都还有.ToString()方法

一切类型都可以转换成为string类型

--52

int 变量=Consvert.ToInt32(待转字符串)
上面语句的意义：把待转字符串转换成int类型后赋给变量

string strsCore="90"；
int iScore = Convert.ToInt32(strScore);

--53
把strScroe转化成int类型并且付给iScroe

Console.WriteLine("请输入你的语文成绩?");
string chinese = Console.ReadLine();

Console.WriteLine("请输入你的数学成绩?");
string math = Console.ReadLine();

int chineseScroe = Convert.ToInt32(chinese);
int mathScroe =Convert.ToInt32(math);

--54
缩写直接赋值
int chinese =Convert.ToInt32( Console.ReadLine());

Console.WriteLine("你的总成绩为:{0}",chineseScroe + mathScroe);

--55
如果try中的代码没有出错，则程序正常运行try中的内容后，不会执行catch中的内容
如果try中的代码一旦出错，程序立即跳入catch中去执行代码，那么ray中的出错代码后面的内容

try
{
Console.WriteLine("请输入你的语文成绩？");
int chinese=Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入你的数学成绩？");
int math = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("你的总成绩为{0}",chinese+math);
}
catch
{
Console.WriteLine("你刚刚输入的代码有问题，请重新输入");
}
Console.ReadKey();

--56
//编程实现计算几天（如46天）是几周零几天. 46/7...4

Console.WriteLine("请输入你要计算的天数？");
int days = Convert.ToInt32(Console.ReadLine());
int week = days / 7;
int mod = days % 7;
Console.WriteLine("{0}中共有{1}周{2}天",days,week,mod);
Console.ReadKey();

--57
//编程实现107653秒是几天几小时几分钟几秒钟？
int seconds = Convert.ToInt32(Console.ReadLine());
int day = seconds / (3600 * 24);
int mod = seconds % (3600 * 24); //除去上面的天数还剩多少秒
int hour = mod / 3600; //看看剩余的秒数中海油多受啊3600秒
int min = mod / 60; //看看剩余的秒数中除去上面算的小时，还剩余多少时间
int second = mod % 60;
Console.WriteLine("{0}秒中共包含{1}天{2}小时{3}分钟{4}秒",seconds,day,hour,min,second);
Console.ReadKey();

--58
++ 自加一有前加和后加
-- 自减一有前减和后减
int age = 18;
age = age + 1;
age++;
age--;
Console.WriteLine("age={0}",age);
Console.ReadKey();

int age = 18;
int sum = age++ - 10;
Console.WriteLine("age={0}", age);
Console.WriteLine("sum={0}", sum);
Console.ReadKey();
//输出：age19 sum8

上面代码中age是后加，所以在进行语句运算时，age++取原值参与运算，所以sum=8

int age = 18;
int sum = ++age - 10;
Console.WriteLine("age={0}", age);
Console.WriteLine("sum={0}", sum);
Console.ReadKey();
//输出：age19 sum9

上面代码中age是欠佳，所以在进行语句运算时，++age取加一后的新值参与运算，所以sum=9

int age = 8;
int sum = age++ - 10;
相当于：
int age = 18;
int sum = age - 10;
age = age + 1;

int age = 8;
int age = ++age - 10；
相当于：
int age = 18；
age = age + 1;
int sum = age -10

--59
c#中一元二次运算符高于二元二次匀速符
int var1;
int var2 = 5;
int var3 = 6;
var1=var2++ * --var3;
Console.WriteLine("var1={0},var2={1},var3={2}",var1,var2,var3);
Console.ReadKey();
//输出var1=25，var2=6，var3=5.

--60
+=
例如：age=age+3 = age+=3;
；理解成在age的原值上加3

-=
例如：age=age-3 = age-=3;
；理解成在age的原值上减3

*=

/=

%=

能够改变变量值的：
++/--
=

--61
关系运算符
在c#中，有6个关系运算符，用于比较两个事物之间的关系。
>
<
== 比较相等
!= 比较不相等
>=
<=
关于表达式：由关系运算符链接起来的式子

--62
布尔（bool）类型
真：ture
假：false
关系表达式的运算结果为bool类型，bool类型只有两个值，一个是ture，一个是false。
如果关系运算表达式成立，则这个表达式的值为ture，否则为false
int zsage = 20;
int lsage = 18;
bool isRight = zsage < lsage;
Console.WriteLine(isRight);

--63
逻辑与运算:&&

bool isRight = 表达式1 && 表达式2

逻辑与连接的两个表达式,要能够求解成bool类型,一般情况都是关系表达式

整个逻辑与运算的结束也是bool类型

表达式1 表达式2 逻辑与结果
ture tureture
false false   false
false ture false
ture false false

当两个表达式全为ture时，结果才为ture

int age = 20;
int weight = 120;
bool result = age >= 18 && weight >= 100;
Console.WriteLine(result);
输出的结果为Ture

int age = 10;
int weight = 90;
bool result = age >= 18 && weight >= 100;
Console.WriteLine(result);
输出的结果为False

--64
逻辑与运算:||

bool isRight = 表达式1 || 表达式2

逻辑与连接的两个表达式,要能够求解成bool类型,一般情况都是关系表达式

整个逻辑与运算的结束也是bool类型

表达式1 表达式2 逻辑与结果
ture tureture
false false   ture
false ture ture
ture false false

只要有一个为ture，其结果都为ture

--65
逻辑非：！
这是一个一元运算符.
用法:
!(布尔类型的表达式)
作用:
如果:
布尔类型的表达式的表达式为ture，加！号后，其整个式子的结果为false.
布尔类型的表达式的表达式为false，加！号后，其整个式子的结果为ture.

Console.WriteLine(!result);
输出结果想反，真变假，假变真

表达式 !表达式
True False
False Ture

--66

if 结构的基本语法

if (条件)
语句1;
执行过程:
首先判断条件的结果,如果田间为Ture,则执行语句1.如果条件为False,则跳过语句1.执行后面的语句.
注意:
1.if如果括号中的条件,要能计算成一个bool类型的值.
2.默认情况下,if语句只能带1句话.即和if语句有关系的语句只有1.
//if语句基本用法
int a = 3;
if (a > 10) //这里没有;号
Console.WriteLine("成立"); //if默认只带这一句话
Console.WriteLine("程序结束"); //这句话和if没关系

--67

if-else 结构
语法:
if(条件)
{语句块1}
else
{语句快2}

执行过程:
如果条件为ture,则执行if带的语块1,并且跳过else带的语句块2
如果条件为false.则跳过if带的语句块1.执行else带的语句块2

int score = 95;
if (score >= 90)
{
Console.WriteLine("奖励100元");
}

else
{
Console.WriteLine("不准出去玩,写总结去");
}

--68
在if-esle if语句中,只有当上一个条件不成立时,才会进入下一个if语句并进行if语句后面的条件判断,一旦有一个if后面的条件为ture,则执行此if所带的语句(块),语句(块)执行完成后,程序跳出if-else if结构.如果所有的if条件都不成立,则如果最后有else则执行else,否则什么都不执行.

--69
switch(语法)

switch (语句块)
{
case 值1:语句块1
break;
case 值2:语句块2
break;
default:语句块3
break;
}

--70
执行过程:首先计算表达式,然后根据计算结果与匹配case后面的值.如果有匹配项,则执行匹配后面的语句,直到break语句跳出switch-case,如果所有的case值都不匹配,那么有defanlt则执行default后面的语句,直到break结束,如果没有default.则跳出switch-case,什么都不执行.

default://注意,匹配时和位置没有关系,只和值有关系.

--71

switch:一般只能用于等值比较

if-else of:可以处理范围

--72
while循环的语法:

while(条件) //条件叫:循环条件
{
要循环执行的N条程序; //循环体
}

执行过程:
1.先判断循环条件,如果条件为ture,则转向2,如果条件为false,则转向3
2.执行循环体,循环体执行完后,转向1
3.跳出循环,
循环结束

--73
do-while
语法:
do
{循环体}

while(条件);

执行过程:
1.执行循环体,执行完循环体转向2
2.判断条件是否成立,如果条件为ture,则转向1.如果条件为false,则转向3
3.跳出循环,循环结束

假如循环提交一开始就不成立,对于while循环,一次都不会执行,对于to-while循环体一般至少会执行一次

while:先判断,后执行
do-while:先执行,后判断

--74
检测异常
try
{
}

catch
{
}

如果try中的代码没有出异常,则不会执行catch中的代码
如果try中的代码出现异常,则程序立即跳到catch中

--76
设置断点
单步运行
观察变量

--77
For循环
语法:
for(表达式1;表达式2;表达式3;)
{
循环体
}

执行过程:
第1步计算表达式1,转向第2步
第2步计算表达式2(循环条件),如果表达式2的值为ture转向第3步.如果表达式2的值为false,转向第步
第3步执行循环体,转向第4步
第4步执行表达式3,转向第2步
第5步循环结束

一般情况下,表达式1用于定义循环变量和对循环变量赋初值

表达式2:循环条件

表达式3:用于改变循环变量的值

--78
判断输入的是否为数字
Console.WriteLine("请输入一个值");
bool flag = false;
int a = 0;
while (flag == false)
{
try
{
a = Convert.ToInt32(Console.ReadLine());
flag = true;
}
catch
{
Console.WriteLine("你输入的有误,请重新输入");
flag = false;
}
}
Console.WriteLine("你刚才输入的值是:{0}", a);
Console.ReadKey();

--79
1.可以用于switch-case判断中,用于跳出switch
2.用在循环中,用于立即跳出(终止)循环
注意:用于循环中,跳出的是break所在的循环

--80

continue
用于循环中,程序一旦执行到continue语句,立即结束本次循环(就是不再执行循环体中的continue下面的语句),直接进行下一次循环.(do-while/while直接进行下一次循环条件的判断.如果条件成立.则再次进入循环.对于for循环,先执行表达式三,再判断循环条件是否成立!)

--81
三元表达式
表1?表2:表3
执行过程:首先计算表达式1,表达式1应该是一个能够计算成bool类型的值,如果表达式1的值为true,则表达式2的值作为整个表达式的值,如果表1的值为false,则表达式3的值做为整个表达式的值.
表达式2和表达式3的类型一定要相同(相兼)
int a = 10;
int b =20;
Console.WriteLine(a > b ? a : b);

--82
顺序结构:语句顺序执行
分支结构:语句在满足条件下执行
if,if-else,switch-case,表1?表2:表3
循环结构:语句在满足条件下循环执行多次
while,do-while,for
跳转语句
brak,continue,goto

--83
goto语法
goto 标签
标签:
goto myLabel;
Console.WriteLine("a");

Console.ReadKey();

枚举:
让我们定义一种枚举类型并且在定义这种类型时,我们要制定这个类型的所有值
语法:
enum 自己起的;类型名称{值1,值2,值3....值n};
枚举的定义,一般和类定义在同一个级别,这样,在同一个命名空间下的类就都可以使用这个枚举了
enum Gender
{
男,
女
}

--84
枚举的作用:
1.限制用户不能随意复赋值,只能在定义枚举时列举的值中选择
2.不需要死记每个值是什么,只需要选择相应的值
注意:定义枚举时,值不能是int类型
枚举类型的变量都可以强制转换成一个int类型
枚举的值在定义时是有一个默认编号的,编号从0开始.

Gender sex;
sex = Gender.男;
Console.WriteLine((int)sex);
Console.ReadKey();

--85
如果把一个字符串转换成枚举类型:
(自枚)(Enum.Parse(typeof(自枚),"带转换的字符")

--86
为什么要用结构:
1.比如我们上课讲的为了存储一个人的信息,要声明一组变量,当我们要存储N个人的信息时,就要申明n组变量,麻烦
2.存储一个人信息的这几个变量间没有关系,容易记乱语法:

访问修饰符 struct 结构名
{
定义结构成员
}

--87
0计算机中最小的单位叫"位",bit,比特

就把8个二进制位分成一组,那么8个二进制位叫做字节
Byte B 计算机能够处理的最小的单位
1KB=1024B
1MB=1024KB
1GB=1024MB
1TB=1024GB
1Gb=128MB
bps 传输速度 bit per second

--88
数据:可以帮我们一次声明多个同类型的变量,这些变量在内存中是连续存储的.
数组声明语法:
数据类型:
数据类型[] 数组名=new 类型类型[数组长度];
Int a;表示声明一个int类型变量
例如:int[] score = new int[5];
这句话声明了一个长度为5的数组,数组叫是score
通俗点说:就是声明了一个数组,里面包含了5分int类型的变量
数组名叫:score 里面的5个int类型的变量叫做:数组的元素
int[] score = new int[5];
score[0] = 10;
score[4] = 20;
Console.WriteLine(score[0]);
Console.WriteLine(score[4]);
Console.WriteLine(score[3]);
Console.ReadKey();

--89
如何访问数组:通过下标(索引)来访问数组:数组名[编号]
比如:我们要向第0个元素赋一个3.可以这样写:
Score[0]=3;
Int类型数组一旦声明,里面的每一个元素被初始化成0
通过数组名.Length 可以获得数组的长度
//通过一个循环,求一个数组中所有元素的和
int[] score = new int[10];
int sum=0;
for (int i = 0; i < score.Length; i++)
{
Console.WriteLine("请输入第{0}个人的成绩?",i+1);
score[i] = Convert.ToInt32(Console.ReadLine());
sum += score[i];
}
Console.WriteLine("{0}个人的平均成绩为:{1}",score.Length,sum/score.Length);
Console.ReadKey();

--90
Console.Clear(); 清屏

--91
数组演示:
int[] score = new int[5];
int sum=0;
int max=0;
for (int i = 0; i < score.Length; i++)
{
Console.WriteLine("请输入第{0}个人的得分:",i+1);
score[i] = Convert.ToInt32(Console.ReadLine());
sum += score[i];
if (max < score[i])
{
max = score[i];
}
}
Console.Clear();
Console.WriteLine("这几个数中最大值为{0},和为{1},平均数为{2}",max,sum,sum/score.Length);
Console.ReadKey()

--92;
数组传输
Console.WriteLine("请输入你的年龄?");
int age = Readint();
Console.WriteLine("你刚刚输入的年龄为"+age);

Console.ReadLine();
}
public static int Readint()
{
int number = 0;
do
{
try
{
number = Convert.ToInt32(Console.ReadLine());
return number;
}
catch
{
Console.WriteLine("输入有误,请重新输入!");
}
}
while (true);

--93
冒泡排序:
让数组中的元素两两比较(第i个与第i+1个比较),经过n(i-1)遍两两比较,数组中的元素能按照我们预期的的规律排序.
要从大到小排序,我们进行两两比较的时候用<
(从大到小用<,从小到大用>)

N个数需要排n-1趟
第t趟比较的次数为:n-t次
i=0 第一趟
i=1 第二趟
趟数:i+1 t=i+1
For(int i = 0;i>n-1;i++)
{
for(int j = 0;j<n-i-1;j++)
{
int c=a;
a=b;
b=c
}
}

--94
函数就是将一堆代码进行重用的一种机制.函数就是一段代码,这段代码可能有输入的值(参数),可能会返回值.一个函数就像一个专门做这件事的人,我们调用它来做一些事情,它可能需要我们提供一些数据给它,它执行完成后可能会有一些执行结果给我们.要求的数据就叫做参数,返回的执行结果就是返回值.

String s = Console.ReadLine()就是一个有返回结果的函数;
Console.WriteLine("hello")就是一个执行参数的函数,只有告诉WriteLine被打印的数据它才知道如何打印;int i=COnvert.Toint32("22")则是一个既有参数又有返回值的函数.

有了函数写代码就像拼积木,C#中的各种各样的技术其实就是通过for、if等这些基础的语法将不同的函数按照一定的逻辑组织起来.

--95
方法
定义:
[访问修饰符][static]返回值类型方法名()
{
方法体;
}

命名规则:方法名开头大写,参数名开头小写,参数名,变量名要有意义
方法的调用,对于静态方法,如果在同一个类中,直接写名字调用就行了
return可以立即退出方法
功能:用来复用代码.当我们在一个程序中反复的写了同样的代码.那一般情况下,我们可以把需要重复写的代码定义在一个方法中,用的时候只需要调用就行了.

定义方法的语句:
[访问修饰符][static]返回值类型方法名()
{
方法体
}

        static void Main(string[] args)
        {
            ShowUI();
            Console.WriteLine("谢谢使用,按任意键退出!");
            Console.ReadKey();


        }


        public static void ShowUI()
        {
            Console.WriteLine("**********************************");
            Console.WriteLine("*     欢 迎 您 使 用 本 软 件    *");
            Console.WriteLine("**********************************");
        }

--96
定义方法的语法:
Public
[访问修饰符][static]返回值类型方法名[参数]
{
方法体
}
注意
1.一般情况下,方法一般要定义在类中
2.如果没有返回值,则返回值类型写void
3.如果方法没有参数,()不能省略

方法的调用:如果是静态方法(由static修饰的)则使用类名.方法名().
在类中调用本调的方法,可以只写方法名();

--97
转类型
int.Parse(string)

--98
在方法名后面的括号内定义变量,叫做定义这个方法的参数.这里定义的变量用于接受调用者传过来的数据
注意:如果一个方法一旦有参数,那么调用者就必须传参数,并且传参数的个数与对应位置上的类型必须一致

        static void Main(string[] args)
        {
            int a = 3;
            Text(a);
            Console.WriteLine(a);
            Console.ReadKey();
        }
        //被调用者
        public static void Text(int a)   
        {
            a = a + 3;
            Console.WriteLine(a);
        }

求两个整数的和(隐性)

        static void Main(string[] args)
        {
            Add(3,6);
            Console.ReadKey();
        }
        public static void Add(int a, int b)
        {
            Console.WriteLine("a+b={0}",a+b);
        }

--99
当调用者想访问我们方法中的变量时,可以通过返回值返回.
例如:
string s=Console.ReadLine()
int i= Convert.ToInt("22")
为什么方法前面能定义一个变量接受方法的值,是因为方法中使用了返回值
只要在方法中返回了值,那么在调用方法是,前面就应该用一个变量来接受方法的返回值
为什么使用返回值?因为变量规定了类型而不再是隐性
注意:一个方法只能有一个返回值
一旦一个方法有返回值,那注在这个方法值中,就必须通过rerurn语句返回一个值,并且这个值要与返回值类型是同样的
语法:
return result;

两个数求和(规定为int (有返回值)):

        static void Main(string[] args)
        {
            Console.WriteLine("请输入第一个数!");
            int a = int.Parse(Console.ReadLine());
            Console.WriteLine("请输入第二个数!");
            int b = int.Parse(Console.ReadLine());
            int sum = Add(a, b);
            Console.WriteLine("平均值为:{0}", sum / 2);
            Console.ReadKey();
        }
        public static int Add(int a, int b)
        {
            return a + b;
        }

--100
一个变量一旦定义在方法外,类的里面,就叫做类的字段,这个变量就可以被本类的所有方法所访问,但是要注意,静态方法只能访问静态字段.

--101
什么叫方法的重载:
一般在同一个类型中,方法名想通,并且方法的参数的个数不同或者对应位置上的类型不同,才能构成方法的重载

实现步骤:
1.在方法的参数类型前面加out,那么传参数的时候,也必须在number钱加out表明这个参数不是传入的,而是i用来传出值的
2.如果参数是以out形式传入的,那么在传入前可以不赋初值.
3.在方法中对于由out修饰的参数,必须赋值,并且必须在使用前赋值

--102
Tryparse
static void Main(string[] args)
{
string s = "123";
int re;
if (int.TryParse(s, out re) == true)
{
Console.WriteLine("能转换成功,转换后的数字为:" + re);
}
else
{
Console.WriteLine("转换失败");
}
Console.ReadKey();

--103
out用于传出值,大方法中必须对out修饰的传数进行赋值
ref双向,既可以传入,也可以传出
字啊传参数的过程中,如果参数有out或ref修饰的话,那么改变方法中的参数变量的值,调用者方法中变量的值也会相应改变

本站文章除注明转载/出处外，均为本站原创或翻译。若要转载请务必注明出处，尊重他人劳动成果共创和谐网络环境。

转载请注明 : 文章转载自深山的鹿笔记与心得：C#基础知识知识点

本文标题：《笔记与心得：C#基础知识知识点》

本文链接：http://www.noteet.com/369.html

上一篇 : 笔记与心得：C#面向对象

下一篇 : 笔记与心得：黑马程序员C#40课基础知识集合（一）

评论列表暂无评论

发表评论

归一

2927

1307

6747064

笔记与心得：C#基础知识知识点

« 2024年5月 »
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

笔记与心得：C#基础知识知识点

归一

2927

1307

6747064

User Login

帐号或密码错误,请重试.