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、方法重载：
问题:在一个类中，能否定义多个同名的方法？
是可以的，但是参数个数或类型不同
方法重载：在同一个类中，多个方法名称相同，但参数个数或类型不同
浙公网安备 33010602011771号