C#入门基础

那么由 = 连接起来的这个式子 就叫赋值表达式 

 

 

 

 

 

解决异常的 办法

 

 

for循环

常量

常量在程序中  怎么定义: const 类型   常量名= 值;

在程序中可以改变常量的值吗  不可以  一旦改变  出错了  

变量

在程序中 是不是可以改变的？ 答案是肯定的 

三元表达式  

表达式1？表达式2:表达式3;

如果表达式1 的结果为true 时候 执行表达式2  如果为 false 执行 表达式3

比如说这个string str = 3 < 4 ? "哈哈" : "呵呵";

如果  3<4 成立 就显示哈哈

如果不成立   显示 呵呵

？: 

if (条件)  bool

{

// 语句1；

}

else

{

//语句2;

}

成立 就执行 语句1

不成立就执行 语句2

枚举:

存储的是确定的值   比如: 性别:男女  只有这么两个值 

方向 ：东 南 西 北  只有四个  目前只考虑 四个 

枚举的定义：

在命名空间的大括号里 

需要一个 关键字 enum  名

｛

｝

枚举用法 ：

在主函数中

直接 枚举的那个名. 就可以了

注: 参数2和参数3 是雌雄共体的 

//为什么要用枚举

好处 1

更加规范了

好处 2

有智能提示  更加方便了 

在 主函数  里面 先 定义一个 枚举类型  后面跟一个 变量名  进行赋值  

枚举类型   枚举名 (变量名)  =  枚举类型名.值

如果想把字符串转换成枚举  怎么做 可以通过下面的 这个 “公式” 进行转换

//(Gender)(Enum.Parse( typeof(Gender),"male"));

(待转换的枚举类型)(Enum.Parse(typeof(待转换的类型),”字符串”))

XingBie xb=(XingBie)(Enum.Parse(typeof(XingBie), str));

枚举类型可以和int类型相互转换

//Direction fx = Direction.北;

//int num = (int)fx;

//Console.WriteLine(num);

//Console.ReadKey();

结构 

为什么要用结构

我可以一次声明多个不同类型的变量

结构的语法 :

[访问修饰符] struct  结构的名字(自己定义的名字)

访问修饰符 可以省略不写  但是我们现在是初学者 所以 必须写  public

public struct Penrson

{

\

//结构体 

}

结构体里  如何声明变量 

[访问修饰符] 数据类型  变量名 ;

public string name ;

public char sex ;

结构的使用方法

在主函数(目前代码都在主函数里写的)

首先声明一个结构的 类型 如 :

怎么用？

直接 变量名.age  就可以使用了

定义一个 Person 的结构

在结构体里有姓名 年龄 性别  工资 

然后在主函数里 声明 这个结构 

进行赋值

显示出那个人的信息

l 数组

如何声明 ？

数据类型 [ ] 变量名= new 数据类型[] {};

int [] nums=new int[]{};  

声明数组的几种方法

下面是三种声明数组的方式

四种方式

怎么用 ？

 

笔记

Int [] nums=new int[]{};

数组的声明

我要做升序 排列 两两比较 用大于号  如果前面的数 大于后面的这个数 成立  我就交换 

9 8 7 6 5

第一趟 比较

第一趟  8 7 6 5 9  做了 4次比较  

第二趟  7 6 5 8 9  做了 3次比较

第三趟  6 5 7 8 9  做了 2次比较

第四趟  5 6 7 8 9  做了 1次比较

Int temp=0;

// for(int j=0;j<nums.Length-1;j++)

{

For(int i=0;i<nums.Length-1-j;i++)

{

If(nums[i]>nums[i+1])

{

Temp=nums[i];

Nums[i]=nums[i+1];

Nums[i+1]=temp;

}

}

}

5 ，6 ，7， 8，9 

方法的好处  第一: 方法就是代码重用的一种机制

第二： 一个方法 可以说完成一个功能 

方法 (函数)

语法:

[访问修饰符]  static  返回值类型  方法名 ([参数列表])

{

//方法体  (一些代码)

}

访问修饰符 可以省略  但是 我们现在 刚学   所以 都要写  public  

Static  关键字   返回值类型  不能省略 现在由于 我们是初学者 还有说讲 返回值

所以  都写 void 

方法名 :  就是自己起的名字  遵循 首字母大写 

（）  不可以省略 

[参数列表] 或者说 里面的参数  可以省略  因为现在我们是初学者 学最简单的 

方法的使用 

如何调这个方法 ？

现在我们写的方法 在访问修饰符 后面用的是static 关键字  所以 我们的这个方法 叫静态方法      怎么用这个方法  我们在 静态方法中 类名.方法名();

如果没有static 的方法 可以理解为非静态方法   或者说 是实例方法  (后面会讲的)

就可以使用了 

如果我们定义(我们写的那个方法)方法 在同一个类中  我在其他方法中调用的时候

可以省略 那个类名 

直接 写  方法名() 括号不可以省略

就能用了 

局部变量  及变量的作用域 

在方法中定义的变量称为局部变量,其作用域从定义开始,到其所在的大括号结束为止.

如果你真的不理解  你可以在主函数中 定义一个变量  然后在其他的方法中 用这个变量  试一试  其结果是不是报错了

在一个方法中想要访问另一个方法中的变量,怎么办?

第一 :通过参数 来解决  还有第二种方法  一会就说 

我可以定一个方法 或者说写个方法  然后在方法的括号里 定义一个变量  或者 自己 给写了一个参数  

然后在主函数中 调用这个方法   在调用的时候  我要给这个方法的括号  一个参数  

//谁调用 谁   谁就是 调用者  被调用者  就是谁

以上是通过参数的形式 来解决 方法中想要访问 另一个方法中的变量  

第二  通过 return 返回值 

Public static  void Add(int num1,int num2)

{

Int sum=Num1+num2;

}

这么做 就是把两个数 返回了 

有返回值了  我们 主要用到 的就是 return   通过return  把 我想要的给我返回来了  

如果你把变量 定义到方法的外边 或者说定义到这个类中  如果想在静态方法中 访问这个变量   要在定义的时候 加上static  修饰  这个时候 我们通常叫 “字段” 静态字段 或者通俗的说 静态变量 

 

方法返回值

方法返回值  现在返回多个值 

刚刚我们采用是返回一个数组的方式  来完成 题目的要求 返回了多个值

我们虽然很高兴的做到了

但是  事情有时候是可悲的  返回来的值的类型 都是一样的  这令我不爽

我想要的是 返回多个值 并且 类型 不一定是相同的 

那么 我能不能做到 

答案是肯定  我有办法

什么办法  ？

我们可以用 out  ref  做到   那么具体 怎么做  

我们想要得到方法中多个返回值  可以用 out

一旦 我在方法的参数列表中用out 那么 我后面的 那个变量 要赋初值

=============================================

如何使用out  ===

===

我们现在需要返回多个值 怎么做? ===

===

在方法中  ===

Public static void ShowNumber(out int num) ===

{ ===

//这个时候 我们给这个num 赋值 ===

} ===

在其他方法中怎么用这个方法呢？ ===

===

static void Main(string [] args) ===

{ ======

//这是主函数，现在在这要调用那个方法 具体怎么做？==

int num=0; ======

ShowNumber(out num); ===

}  ===

// 这样就可以了   =========

简单的理解就是  我们可以用out 解决想返回多个返回值的问题 =

上面的是通过  out 得到多个返回值 

下面 的 是通过ref 得到多个返回值 

这两种方法  我们都可以得到多个返回值 

区别:

out  通过大家观察  他只能 把方法内的值 传到 外边

ref 可以传进去  也可以传出来 

 

方法定义

[访问修饰符] static  返回值类型 方法名 ([参数列表])

{

//方法体

}

public   static  void  ShowHello()

{

} 

Out  ref  

Out 只能把方法中的值 传出来 

Ref 可以传出来 也可以传进去

今天 主要内容  骑士飞行棋 

输入玩家名字的时候 不能为空  而且  也不能与 另一个玩家的名字相同 

另一个玩家的名字 也不能为空 

如果 现在掷骰子的 玩家 踩到了 对方  对方 返回原点了 

两个玩家掷骰子  可以用 循环来做 

骑士飞行棋 两大块 

第一 画地图   画

第二 掷骰子   玩

画图  用 0 代表  方块  

当 数组中的 值为0时 我就画 方块 

If(nums[i]==0)

{

Console.WriteLine(“方块”);

}

0表示普通,显示给用户就是 □

1幸运轮盘,显示组用户就 ◎

2地雷,显示给用户就是 ☆

3暂停,显示给用户就是 ▲

4时空隧道,显示组用户就 卐

骑士飞行棋 

首先 初始化地图

然后画地图 

利用循环画地图

用到的几个坐标

画第一行地图的时候 要进行各种的判断  画里面的小图标

画第二行的时候 也要进行各种判断  这样 有很多代码要重复 

所以 把 画小图标的那些代码 写到一个方法里  然后 用循环的方式画图

在循环里分别调那个画小图标的方法 

这样利用坐标以及循环 地图就完成了  

要注意的是 坐标可能会 出现问题 有的坐标是从做到右 有的坐标是 从右到左

然后呢 就开始 玩家掷骰子了 

掷骰子的时候 是要产生随机数的 

这个随机数 我们要用到Random r=new Random

每次 走的时候要提醒玩家 按任意键掷骰子  然后 再走路 

在这里 每次走完后 我们都要进行 坐标的判断

接下来要考虑的是 玩家A有可能踩到 玩家B 

一旦踩到了 就要 进行  判断了   

如果踩到了 就要 把对方踩到原点了

如果没踩到 就要进行 管卡的 判断了 

如何进行管卡的判断就要看Map里面的值了 

另外 至此 关于管卡颜色的问题 还留了个陷阱

 

面向对象

程序员  

万物皆 对象 

什么是对象 

对象  就是指  看的见 摸得着 实实在在存在的  

对象  特征 和行为 

赵老师   特征 ：  

白   放到煤堆里看不见

高  1.56m

帅  和杨老师不帅

富 天天请杨老师吃饭

姓名 赵老师……

性别  ,男

年龄 43

行为

吃饭

睡觉

喝水  蹭饭 

辅导大家学习   我们用 方法的

学生   张三的       上课 

姓名

性别 

年龄

穷

矮 

我们用方法 来 体现这个 行为 

l 张三(一个学生)\杨老师\邻居售货员张阿姨\李四的爸爸\李四的妈妈

这些对象 都有什么属性 

名字

年龄

名族 

性别  

吃饭

睡觉

喝水

都有轮子

品牌

行驶证号

生产厂家

价格 

行为 开  停  跑  能载人 

是不是人？

声明

两条腿 

类  是对象的抽象  这么理解起来 比较抽象 

类   也可以理解成 是对 对象的 一个总称 

张三  这个 对象   他的属性     姓名 ：  张三

年龄    20

上面的内容  是让 大家  分清 对象 和类  

======================================================================-

下面介绍 如何   代码  写 一个类 

人类 张三;       int a;

类的语法

[访问修饰符] class 类名 

{

成员;

......

}

访问修饰符 可写  可不写  但是因为 我们是初学者  要写 

Class 关键字  

类名:  我们自己起的   大家要记住  类名后面 没东西了

｛

成员 ;

｝

public class  Person

{

成员;

} 

对象 有一些  特征 和行为 

那么在我们 程序中 如何 表示 这个特征 和行为 

我们用 属性  和 方法来表示 

类的实例化

类的实例化,用关键字new

语法:

类   实例名 = new 类();

类的成员的访问:

    实例名.属性    实例名.方法名();

张三 和李四 的名字 都存进去了  都跑哪去了 ?

访问级别   没听过 

访问修饰符  听过 

封装  ？  什么玩意  ？

访问修饰符 ： 有好多啊 

Public     private     (internal   protected)

都不认识 …..

Public  我们熟悉 而且 非常 熟悉 

在类中 如果方法 加上了static  那么 在我们的主函数中 （说的不严谨）

想调用这个方法  就用类名.方法名(); 就可以用这个方法了

加上static  后的方法 叫静态方法

没加呢 ?  实例方法 

为什么我们要单独的添加一个类的文件呢？

是有原因的，什么原因呢 ？ 你猜

简述 private、 protected、 public、 internal 修饰符的访问权限。

private : 私有成员, 在类的内部才可以访问。

类中字段和方法默认的访问修饰符 是private 

public : 公共成员，完全公开，没有访问限制。

internal: 当前程序集内可以访问。

protected : 保护成员，该类内部和继承类中可以访问。

继承 可以简单的理解  儿子 继承 父亲 的一些东西  (长相 )

类中字段和方法默认的访问修饰符 是private 

如果在类中 我们定义的那个字段  不加上访问修饰符  默认的是private 

那么这样  这个字段 只能在本类中使用  

在其他的地方不能用 

如果加上public 了 那么也就是说在其他的地方也可以使用 

属性的定义 ：

private string name;  这个是字段 

private int age;  这也是个字段 

我们在调用的时候  实例名.属性

//姓名  性别 年龄    身高  体重   职业   工资  爱好  QQ号码 邮件 

Private string name;

Public string Name

{

get{return name;}

set{name=value;}

}

要么痛苦的继续游戏着, 坚持到最后  可能升级

要么结束游戏继续痛苦, 现在就放弃  一无所有

属性 和字段 

静态方法  只能 访问 静态字段 

 

属性的 快捷键  Ctrl+R+E

类的构造方法;

在我们 写一个类的时候  自动的给我们写了一个构造函数 

而 构造函数 是无参数的  

构造函数是用来创建  对象的特殊方法

方法名 和类名一样 没有返回值，连void都不用。

在创建对象的时候  就

构造函数的重载 

this    指示代词

属性  共有的  任何地方可以调用

字段  私有的   在本类中调用

属性可以控制 只读或者只写 、读写 

字段呢？

总结起来 就这么两句话  

在get中判断的时候 我写的那个方法中用到的那个参数 是Age(属性)

在set 中判断的时候  我写的那个方法中用到的那个参数 是_age(字段)

出来   out

进去 出来  ref 

字符串  处理

string   和String   前面的是 字符串 （数据类型）  后面的是类 

但是看起来 没什么区别 

转换数组的 一个方法

转换 小写的一个方法

转换 大写 的一个方法

转换字符串的一个方法

又是一个方法

这又是一个方法 

只要通过.(点) 就可以调用很多很多的方法啦 

一点就通 哪里不会点哪里 so easy

F1 更神奇  哪里不会 按哪里 

 

类是不是可以继承

Person

Student

Teacher

三个类

因为学生和老师  他们 都是人

所以 抽象 出来了一个 “人”类

然后呢 我让 学生和老师 都继承 了Person

需要怎么做呢 ?  在 Student后面加上一个冒号:Perosn

在Person中可以有构造函数

子类中也可以有构造函数

既然 都能构造函数

那我 可不可以 也 调用一下 父类中的 构造函数呢   

第一 如果子类继承父类

是不是可以自动的用到了 父类的字段 或者说属性

通过一个有参的构造函数再用一个关键字base （）把参数传过去了

子类 就能用到父类的构造函数 然后间接的 给父类的字段赋值了 

里氏替换

is 的语法：

布尔类型 变量 = 子类对象 is 父类

如果布尔类型的变量为true 转换成功了

如果为false  就是不能转换 没成功

is的用法

：

对象或者是实例 is 类型名

这个表达式可以返回一个bool值，表示是否可以转化

判断父类能否转化为子类的时候常常使用

父类要想转成子类  要强制转换  和之前的 in t和double 之间转换很像

as 语法:

类型名 变量名 = 某个对象或实例 as 类型名;

类可以进行转换

隐式转换  显示转换(强制转换)

有的时候转换可能会 出问题 

可以通过  is  或者as 进行 判断转换 

这样 就 不会报错了

 

 

里氏转换

Person  p1=new  Person();

Strudent stu=new Student();

Person  p2=stu;

Student stu2=(Student)p1;

隐式转换 强制转换    

is 或者 as   判断 两者的区别   先判断再转换

Hashtable

同样的  也可以添加 和 删除 

hsb.Contains("234");

hsb.ContainsKey(123);

两种方法 都是 找里面的键 存不存在   没什么不一样的   只是方便而已

就是查找这个 hashtable 里面 有没有这个键 

因为 Hashtable

的add()方法里 的参数是obj类型 

那如果我想 把里面的内容  读出来的时候 是不是涉及到了 里氏转换 

foreach 语法:   的用法

foreach(要循环访问的集合中对象的类型 表示集合中的元素的标识符 in 要循环访问的集合或数组的名称)

{

}

循环的过程

-> 总是从开始，一直循环到结束，中间不会停下来，除了break

临时变量的类型

-> 设断点查看

-> 使用var判断

1、泛型集合

就是为了专门处理某种类型

ArrayList对应的是 List<类型名>

-> 在尖括号中写什么类型，这个集合就变成了什么类型的集合

-> 添加数据、插入数据、索引访问数据都是这个类型的，不用考虑所有的转化问题

Hashtable对应的是 Dictionary<键的类型, 值的类型>

-> 在尖括号中填入键的类型与值的类型，那么这个集合就变成了一个指定的键值对模型

-> 其使用方式与Hashtable一样

2、Hashtable

ArrayList为什么要有ArrayList

-> 因为数组的长度问题

-> 提供很多方法

泛型集合

List<T>集合 与Arrayist的区别是什么？

-> 类型可以自定义

Hashtable集合，为什么要有这个集合

-> 查找

-> 想要查找，就得有一个对应关系

-> 就是通过键值来提供

-> 就需要将键与值用一种办法绑定到一起

-> Add(键, 值)

-> 访问键的时候，可以直接找到值

-> 用什么方法，通过键访问到值

-> hashtable[键] 返回一个值

-> 但是hashtable中都是object类型，因此使用时要考虑强传

泛型集合

Dictionary<TKey, TValue>集合 与Hashtable的区别

还是类型问题

泛型类型

List<类型名>

用int做示例

1、创建：

List<int> intList = new List<int>();

2、加数据

intList.Add(int类型的数据);

intList.AddRange(int类型的数组与集合);

3、插入数据

intList.Insert(位子索引, 要插入的数据);

4、移除

intList.Remove(要删除的数据);

intList.RemoveAt(要删除的索引);

5、清空

intList.Clear();

6、如何获得集合的长度

intList.Count

7、怎么访问某一个数据

intList[index];

8、如果想要修改索引为8的数据

intList[8] = 80;

 

 

 

//这些都是多年前学习的一点杂乱的东西  对我来说有些意义  所以今天就搬上来。