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判断

一、泛型集合

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

ArrayList对应的是 List<类型名>

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

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

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

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

-> 其使用方式与Hashtable同样

二、Hashtable

ArrayList为何要有ArrayList

-> 由于数组的长度问题

-> 提供不少方法

泛型集合

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

-> 类型能够自定义

Hashtable集合，为何要有这个集合

-> 查找

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

-> 就是经过键值来提供

-> 就须要将键与值用一种办法绑定到一块儿

-> Add(键, 值)

-> 访问键的时候，能够直接找到值

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

-> hashtable[键] 返回一个值

-> 可是hashtable中都是object类型，所以使用时要考虑强传

泛型集合

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

仍是类型问题

泛型类型

List<类型名>

用int作示例

一、建立：

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

二、加数据

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

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

三、插入数据

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

四、移除

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

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

五、清空

intList.Clear();

六、如何得到集合的长度

intList.Count

七、怎么访问某一个数据

intList[index];

八、若是想要修改索引为8的数据

intList[8] = 80;

 

 

 

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