day1
上课代码自己敲三遍(1. 先自己抄写 2~3 关掉我的自己写 )
上午绝对不能犯困
请假 尽量下午
作业认真做 做不完不要抄!!!
最后测试: 阶段尾 测试机试 分数100 数据结构 40
老大有一票否决权
计算机硬件：
1，CPU center Unit
2.存储器；
硬盘
内存
计算机
十进制（D）：逢十进一 十进制没有十
0
1
2
3
4
5
6
7
8
9
10（D）
二进制(B)：逢二进一 二进制没有二
十进制 二进制
0 0
1 1
2 10(B)
3 11
八进制(O)：逢八进一 八进制没有八
十进制 八进制
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 10（O）
9 11（O）
十六进制（H）：逢16进一 十六进制没有十六
十进制 十六进制
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 A(a)
11 B
12 C
13 D
14 E
15 F(f)
十进制和二进制的转换
十进制 转换 二进制
辗转相除法
十进制数 循环除以 当前进制（2） 直到 商为0
从下往上 余数 连接 就是我们的二进制
二进制 转换 十进制
十进制数 = 当前位的值 * 几进制数^(n-1)+...
位数 10 9 8 7 6 5 4 3 2 1 0
权重值 1024 512 256 128 64 32 16 8 4 2 1
十进制 和 八进制 的转换
十进制 转换 八进制
法1.辗转相除法
法2：十进制 转换 二进制 转换 八进制
10（D）--> 1010(B)--->12(O))
八进制 转换 十进制
12（o）-->1010(b)
十进制 和 十六进制 转换
十进制 转换 十六进制
法1.辗转相除法
法2：十进制 转换 二进制 转换 十六进制
十六进制 转 十进制
十六进制 转换 二进制 转换十进制
存储单位
字位 一个二进制位 bit
字节 8个二进制位 1byte = 8bit
1kb = 1024byte;
1MB= 1024kb;
1GB=1024mb
1TB=1024GB
1PB=1024TB
1EB=1024PB
1.新建项目
顶部菜单栏–> 文件—> 新建–>项目
模板：VisualC# 控制台应用程序
2.字体大小设置
工具—>选项—>环境—->字体和颜色
可使用 ctrl+滚轮 进行界面大小缩放
3.文件结构
.sln 项目解决方案 通过双击他 进入我们的项目
同目录 是我们的 各个项目
4.using System;
使用命名空间 using System（命名空间的名称）
5.程序调试方式：
Ctrl+F5
6.程序执行 入口
Main函数
区分大小写
Main01
7.关键字
Static 静态的 在内存中只有一个
void 空
8.Main中一行代码 以英文下; 结束。表示当前语句结束
9.命名空间 类 方法都是以{}包裹
{}中为代码内容
10.代码的执行顺序
从上到下 顺序执行
11.只有分号 也是一个语句 我们称为空语句
12.注释
格式：// /**/(多行注释)
作用：程序走到这里是不会执行当前行的
1.解释说明我们当前行的逻辑意义
2.注释掉无用的代码
3.程序员表达你才华的地方
快捷键：注释：Ctrl + K, Ctrl+C
取消注释：Ctrl+K,Ctrl+U
13.命名规范
关键字：
int 整型
字母、数字、下划线
遵循 驼峰命名法
见字知意 看见单词 知道干嘛的
14.常量和 变量
变量 可变 可控 可该的量
常量 声明赋值之后 不可改变 不可修改
15.值类型和引用类型
值类型 直接可以在栈中 获取数值
引用类型 在栈中存储地址 通过地址 在堆中 获取值
16.值类型
值类型分为结构类型和枚举类型
字符类型：char 表示一个字母 或者 汉字 单引号 标注‘’；
结构类型分为数值类型 布尔类型和用户自定义类型(struct)
数值类型:整数（int） 单精度浮点数（float） 双精度浮点数（double）超高精度 (decimal)一般用不到
布尔类型（bool）: true false
Struct 用户自定义
枚举（enum）:就是用一组数量有限的标识符来表示一组连续的整型常数，使能够更清晰的表示出现实世界
17.
关键字：string 字符串 双引号“”；
作业：
课上代码
至少三遍 五遍（3-5）；
笔记：
可以抄一遍 把笔记敲一遍（1-2遍）
明天默写关键字
1.cw+tab –快捷键 Console.WriteLine(“”);
2.重命名 选中变量 右键—>重构—>重命名
3.快速移动光标 到单词或者数字的最前、最后
ctrl+ ←→
视图面板上下移动
ctrl+↑↓
4.选中文本块 shift+← →
5.占位符{number}
占位符 从0开始
字符串结束第一个开始占位
Console.WriteLine(“{0},{1},{2},{3},{4},{5}”,shiWan,wan,qian,bai,shi,ge);
强制性转换 强转
6.
++i
先执行 i=i+1; 再执行当前语句；
i++
先执行当前语句，再执行i++（i=i+1）
7.三目运算符
int i = 3;
i = (i == 10) ? 8 : 10
i= 赋值
： 连接的是
可以赋值的两个参数
参数类型 需要和 前面要赋值的数据类型保持一致
()内：条件满足 赋值为？后的第一位
条件不满足 赋值为： 后面的一位
8.程序调试
开始调试 ctrl+F5
打断点 F9 或者 可以点击面板最左边
看数据 可以把光标放在 变量上 进行数据查看
底部 自动窗口查看数据
断点执行位置：
在该行 停止运行 并不会执行该行语句
如果想看该行执行后的数据结果 打断点到下一行
断点继续执行 F10
停止调试：顶部小红块（shift+f5）;
作业：
今天上课代码3遍 敲5遍
笔记：
笔记本上 结合 课堂笔记 和 代码注释 进行整理
笔记敲一遍
1.程序在主函数 Main函数中从上往下 依次执行
2.这种代码执行方式 我们称之为 顺序流程
3.
key 索引
value 值
数据类型 变量名 = value；
变量名 = （条件<bool>）? value1 : value2;
4.if else
-if(条件)
{
//满足条件之后 所需执行的逻辑
}else
{
// 不满足条件 执行的逻辑
}
tip：
1.() {} 先写括号 再填充括号中的内容
-if else if else if(没有数量限制) else
if(条件<bool>)
{
//满足条件之后的逻辑
}else if(条件)
{
}else if(条件)
{
}else
{
//以上条件 均不满足 执行的逻辑
}
eg：输入一个学生成绩 判断级别 进行输出 90-100 A 80-90 B 70-80 C 60-70 D
-if(条件<bool>) 语句;
-满足条件之后 只执行if()之后的一个语句
-if() {}
-满足条件 进入逻辑块
-switch,case
和if else
-switch 变量 == case 才会执行 相应的逻辑；
-if else 一定范围 或者 a==b
作用：对代码的流程进行控制
格式：
（int） （2）
数据类型 变量名 = value；
Switch(变量名) // 关键字 （） 变量的数据类型：可以自己设置的 float int
｛
case 1： //case关键字 和 需要对比的值 中间 一空格（space键）连接
//条件 和 逻辑之间 以冒号 分割
**； //冒号之后写对应逻辑
break；//贯穿：
1.要贯穿的case后 无代码逻辑 无break；
2.贯穿case 2 之后的所有case
//若只执行其中和变量相等的case 需要加一个关键字 break
case 2：
case 3：
case 4：
default： //默认执行的代码逻辑 冒号隔开 关键字 default 和 之后的代码逻辑
******； //缺省
｝
case value：
之后的代码逻辑 可以使用｛｝进行包裹；
一行代码 表示不完 需要多行的时候
不包裹 也可以执行
-逻辑运算符
//& | ~ 位运算符
//逻辑运算符
格式：
&& 与 短路与
|| 或 短路或
！ 非
要求：只能对bool 类型 进行操作
if(score>=90 && score<=100)
{
// 90=<score<=100 非法
}
15.从Console控制台读取输入的数据
. 相当于的
//控制 读取 字符串
开辟空间 接看到的东西 | 拿到透视镜 看下 返回数据
string msg = Console.ReadLine();
//string ---> int
int score = Convert.ToInt32(msg);
-快捷键
复制多个内容: shift + ← →
复制一行：光标直接定位到 需要复制的行 Ctrl+C
Ctrl + s 保存
ctrl + shift +s
--------------------------
-今天代码 敲三遍
-结合代码 和 课堂笔记 整理到自己笔记本上 敲笔记一遍
-作业 自己整合思路 敲代码
初级：
1.设计一个程序 交换两个变量
2.输入两个不相等的数 按从小到大的顺序输出
3.输入一个数，判断这个数能否被3和5同时整除，可以输出yes，不可以输出no
4.编写一个程序实现以下功能；
输出1，2，3，4，5，6，7，8，9，10，11，12中的任何一个数字
便能输出12生肖相应的中文名称 如输入：1 输出：老鼠
5.写一个程序 判断某一年 是否为闰年（被4整出但不能被100整出 或者能被400整出）
高级：
1.输入一个数字，判断这个数字是否为三位数，如果是三位数，
再判断是否为水仙花数。
水仙花数：三位数中的每一位的立方相加等于这个数本身
eg ： 1^3+5^3+3^3 = 153
例子：
bool key ;
do
{
Console.WriteLine(“请输入一个数字(三位数)：”);
int count = Convert.ToInt32(Console.ReadLine());
//判断输入的数字是否为三位数
if((99
1.代码三遍 整理笔记
2.作业；
1.书写一个方法，传入五个int整数，求取他们的平均值；
2.书写一个方法，传入五个int整数，求取他们的最大值；
3.书写一个方法，传入五个int整数，求取他们的最小值；
4.书写一个方法，传入参数为int 变量名为times 输出times遍 九九乘法表；
5.书写一个方法，传入一个int 1，2，3….7，对应输出 “Monday”…..”Sunday”
6.书写一个方法，传入动物，获取叫声，
eg:传入dog,输出 wongwong~
传入Cat，输出MiaoMiao~
传入Mouse，输出ZIZI~
7.定义一个数组｛10，21，32，43，56，67｝
求取数组长度；
遍历数组中数据；
更换数组中 值为5的value为500；
1.函数的折叠方法：
1.光标需要定位在函数中
2.Ctrl+M（两下）
2.排序（VIP very important part）
将数组中的值，按照一定的规则进行排序；
常见排序规则：
升序
降序
倒序
int[] array = new int[] {2,3,6,8,4,5};
倒序：
拿到数组，从后往前倒序排列；
方法：
输入一个数组 返回一个数组
升序：
3.排序算法：
1.选择排序(Selection Sort)
比较思路：
固定下标，然后获取下标对应的值，依次和后续值进行那个比较。
比较一圈之后，会获取剩余值中最小的一位数
int[] array = new int[]{2,6,9,-6,85,65,59,45,32};
2.冒泡排序(Bubble Sort)
比较思路：
相邻的两个值进行 进行比较 按指定规则（升序 或者降序）进行交换
4.查找
从一个数组中找到指定值的下标；
1.顺序查找（Sequential Search）
遍历数组中的每一个值，和目标值进行比较，如果相同。记录index输出
2.二分查找（Binary Search）
前提条件：
数组必须是排序的；
5.快捷键
alt+tab
6.二维数组
int[][] arrays = new int[][]{};
----------------------------
1.课堂代码例子敲5遍 整理笔记
2.作业暂定
1、设计一个方法，传入一个数组，返回这个数组的字符串表示形式
例如：传入数组为 new int[] {1, 2, 3, 4, 5, 6}, 返回字符串 “{ 1, 2, 3, 4, 5, 6 }”
2.设计一个比较方法，传入两个数组，返回两个数组的大小情况
大小比较规则：如果长度不同，长度大的数组大
如果长度相同，依次比较数组的每个元素，如果有一个元素可以确定大小了，那么整体的数组就可以确定大小了
例如：{1, 4, 3} 比 {2, 2, 3} 小
3.设计一个程序,实现下列方法：
找出数组最大数的 int Max(int[] arr)
找出数组最小数的 int Min(int[] arr)
-语言
面向对象：C# Java C++ JavaScript
面向过程：C，Lua
-eg：
事件：狗蛋想组装一台电脑；
面向过程 面向对象
1.狗蛋去电脑市场买配件 1.让二叔替他买电脑配件
2.狗蛋把电脑配件运回家中 2.让二哥把电脑配件送回村里
3.狗蛋组装电脑 3.让隔壁计算机专业老王组装电脑
建一栋方法：
1.我自己打地基 1.找建筑工队
2.自己搬砖，自己和泥。
3.自己粉刷 3.找装修公司
4.自己设计房屋风格。 4.找设计师
得到一个组装完毕的电脑
面向过程：凡事亲力亲为，自己的事情，自己做。
面向对象：需要我们找打一个可以解决问题的实体，让它去完成我们需要的工作。
注意：
并不是使用面向对象的语言，写出来的代码就是面向对象的，你要有面向对象的思想。
面向过程的语言 可不可 面向对象开发？ 可以 前期自己做一些事情。-------Lua
面向对象是解决问题的思路，着眼点是能够解决问题的实体。
面向过程是解决问题的思路，着眼点在解决问题的一步步流程。
1.面向对象
面向对象是一种思想，C#面向对象的高级语言。
2.类和对象：
类是一系列具有相同属性和功能的 抽象。
类是具有相同属性和功能的集合。
举例：
人类：
属性：五官，四肢
功能（方法）：吃饭，睡觉，直立行走。
生物学：
界门纲目科属种
对象：
可以解决问题的实例，隶属于类。对象中的属性和方法来源于类；
类 对象
人类 一个人，张三，李四，王五，赵六
狗类 一条狗：柯基，藏獒，金毛，二哈，泰迪，土狗。
标识符：在编程语言中，程序员自己规定的具有特殊含义的词。例如：变量名，类名，属性名
格式： Person
class 类名（标识符）
{
//类名首字母大写
//每个单词首字母大写
//类的书写位置：
如有命名空间，在命名空间下
没有命名空间，最外层；
和类平级（其实类中可以声明类，叫做内部类，不推荐，很少用，了解）
//在类中可以定义该类共有的属性和方法
//属性是以变量的形式存在的
//属性名
string name;
//功能是以方法（函数）的形式存在的
//功能 （方法）
void Eat()
{
}
}
3.对象的实例化
从类 生成一个对象的过程 叫做对象的实例化；
-类，也是一个数据类型，引用类型。
格式：类 类名 = new 类名();
4.static 关键字
静态的
static修饰的类中的属性和方法叫做静态的属性和方法；
static 属性 —->静态属性（没有static修饰的叫 非静态属性）
static 方法—–>静态方法（没有static修饰的叫 非静态方法）
调用规则：
静态的 属性 和 方法 是属于类的，在访问该属性和方法的时候，需要用类调用；
非静态的 属性 和 方法 是属于 对象，在访问该属性和方法的时候，需要用对象来调用；
静态和非静态的应用
静态的属性和方法：
一般用于工具的书写
非静态属于每一个对象：
一般用于多个实例的时候
规则：
在静态方法 直接访问静态的属性和方法是可以的
不允许 直接 访问非静态属性 和 调用非静态的方法，通过对象访问；
在非静态方法中 可不可以访问静态的属性和方法？
可以直接访问静态的属性和方法
可以直接访问非静态的属性和非方法
5.null是一种数据类型
float int string bool…..
null 空
6.this关键字
作业：课堂案例 两到三遍 笔记：自己整理
作业
1. 设计一个圆类，圆具有属性（圆心点坐标，半径）
圆具有方法（求面积）（π*r^2）
- 设计一个三角形类，具有属性（三条边）
具有方法（ 2. 计算周长， 3. 判断是否是等腰三角形， 4. 判断是否是直角三角形） - 西游记中角色定义:
唐僧: 姓名/性别/年龄/ 念经
悟空: 姓名/性别/年龄/ 七十二变, 打妖怪
八戒: 姓名/性别/年龄/ 三十六变, 调戏嫦娥
沙僧: 姓名/性别/年龄/ 挑担, 求救
白龙马: 姓名/性别/年龄/ 走
1.面向对象三大特性
封装、继承、多态
封装：
把一段具有重复性的代码抽取，封装成方法，供多次调用；
2.构造方法
是一个方法；
要求：
-构造方法是一个 没有返回值 的方法
-构造方法要求方法名和类名相同
-构造方法在对象实例化的时候自动调用
对象生命周期：new---->gc
应用场景：
用于给实例化的 对象赋值。
3.构造方法的重载
复习下方法的重载；
在一个类中方法中，如果满足以下条件，几个方法之间构成重载；
1.方法名相同；
2.参数属列表不同
-参数的个数不同
-参数的类型不同
构造方法
有参构造 和 无参构造
构造方法重载
[访问权限修饰符] 和类名相同的方法名([参数列表])
{
}
4.对象的实例化
格式：
类名 变量名 = new 类名([实参,实参]);
实参的排列顺序 要和 构造中保持一致
5.构造方法中需注意
-如果 没有给类写构造方法（有参 无参），在进行对象实例化的时候，系统会默认提供一个无参的构造
-如果 给类写了构造方法（有参 无参），在进行对象实例化的时候，系统不会再提供一个无参的构造
6.构造方法中调构造方法
三个参数得构造
6个参数构造():this(参数列表)
{
}
在调用6个参数构造之前，先调用三个参数得构造 对共有属性进行赋值
7.静态构造方法
由static 修饰得构造方法 叫做静态构造方法
注意：
静态构造 没有访问权限修饰符，也没参数
调用时机:
第一次使用当前类的时候会调用 静态构造方法
在程序执行中 只会执行一次，以后再不会执行。
10.面向对象
作业：
课堂案例2-3遍 整理笔记
练习作业
1.设计一个人类, 属性: 姓名、年龄、性别、配偶
方法: 约会(打印: xxx和xxx在约会)
2.设计一个英雄类: 属性: 姓名、年龄、特长
3.设计一个电脑类, 属性: CPU, 主板, 硬盘, 内存, 显卡
CPU/主板/硬盘/内存/显卡 都是单独的类， 属性: 名称/价格
电脑类方法: 计算这个电脑的价格
4.乌鸡国国王老王在检查唐僧的通关文牒，如果是大唐的通关文牒则盖玉玺，否则盖印章
分析：
类：
国王类：
特征： 姓名(String)、性别(char)、年龄(int)
行为： 检查 —>形参：通关文牒 ，返回值类型：String
和尚类：
特征：姓名(String)、性别(char)、年龄(int)、通关文牒类型(String)
行为：过关乌鸡国 —>形参：空，返回值类型：空
“注： 所有类都要有构造方法”
1.程序执行
在Main 方法中一行一行执行（在没流程控制语句情况下）
遇见方法 调入方法体执行
执行完方法之后， 回到Main函数继续往下执行。
2.属性访问器
简称访问器
private int age;
格式：
public
[访问权限修饰符] 数据类型 标识符
｛
//设置 写 set
关键字
set
｛
age = value; //value 关键字
｝
//获取 读 get
get
{
retrun age；
}
｝
-属性访问器在 = 左边 设置 value
-属性访问器在 = 右边 获取 value
-set get 可以不同时存在
-set中是可以书写逻辑判断的 可以做数值拦截
3.面向对象三大特性
封装 把一段具有重复性 或者规律性的逻辑代码 进行抽取，封装成一个方法；
继承
多态
4.继承
动物类：姓名，性别，年龄， 吃饭
狗类：姓名，性别，年龄，颜色 吃饭，看家
猫类：姓名，性别，年龄， 吃饭，睡觉
老鼠类：姓名，性别，年龄， 吃饭，打洞
-定义：
如果多个类中由相同的属性和方法，那么我们可以把相同的部分进行抽取，单独做一个类。
被抽取的类：基类 父类
具有相同属性和方法的类 ：派生类 子类
关系：子类继承父类
-格式：
子类名 ： 父类名
-特点：
-子类拥有父类中所有的属性和方法（构造方法除外）
-子类在继承父类所有的属性和方法的同时，还可以拥有自己特有的属性 和 方法；
-一个子类 只能由一个父类， C#不支持多继承。
5.继承中的构造方法
-无论父类 的构造是系统提供的 还是自己写的 父类中的构造都不会被继承。（子类的对象可不可以调用父类的构造函数）
-子类的构造方法 在执行之前会默认执行父类中的构造方法；
6.Sealed关键字
sealed密封的 修饰类 表示当前类不可继承 密封类
7.访问权限修饰符
用来修饰 某个属性、方法和类 的使用范围的关键字
关键字 可修饰 约束范围
——————————————————————–
public 属性 方法 类 任意位置可以访问
internal 属性 方法 类 仅当前项目可访问
protected 属性和方法 当前类 和 子类中可以访问
private 属性和方法 只在当前类中可以访问
8.打断点
F9：打断点
F10：逐过程
F11:逐语句
小箭头位置为：当前程序执行到的位置
笔记：自己整理
课堂案例：遍数自己掌握 1-2
作业：
一、继承
方法的隐藏
对于父类中的方法（同名），子类有自己实现方式，
需要使用关键字new 修饰，表示隐藏父类中的方法
使用子类中
如果子类中隐藏父类中的放方法，那么父类中的方法和子类中的方法，虽同名，但是为两个方法。
base关键字 ： 父类 调用父类中的方法
方法的重写
方法名也是相同：
对于同一个方法，子类和父类有不同的实现。
在子类中重新实现这个方法，叫做方法的重写。
继承中方法的重写 需要父类中的方法是虚方法（virtual关键字）；
子类重写 关键字 override
隐藏和重写的区别
二、多态：
面向对象 三大特性
封装 继承 多态
多态：多个状态（数据类型），引用类型
向上转型：
子类实例化时候，用父类去接
将子类的数据类型 转换为 父类
向上转型之后的对对象，将只能访问父类中共有的属性和方法，
将不能访问子类中特有属性和方法
向下转型：
将父类类型的对象 转换成 子类 类型
向下转型有可能失败；
强制性类型转换：需要转换的数据类型 变量名 = （需要转换的数据类型） 原数据类型的变量
is 关键字 是 判断当前对象是否为目标类型
三、静态类
用static 修饰的类 我们称之为静态类
注意：
静态类不能被实例化
不能声明该静态数据类型的变量
静态类不能有非静态构造
可以静态构造 在类第一次使用的时候调用
在静态类中 不能有非静态的属性和方法
方法 和属性 必须是静态的
用途：
用来包装工具类 Math.Abs PI
1.写一个取经四人组类，
属性（姓名、年龄、性别）
方法（念经）
实例化两个对象
唐僧 隐藏父类 特有紧箍咒
孙猴子 重写父类 假装念经
2.写一个静态工具类
求数组中的最大值
求数组中的最小值
3.写一个静态工具类
获取输入字符串的第一个字符
一、抽象
1.抽象方法
使用关键字 abstract 修饰的方法 就是抽象方法；
-抽象方法只有方法声明，没有方法实现
[访问权限修饰符] [其他权限修饰符] 返回值类型 变量名([参数列表])
{
//方法的实现
}
//抽象方法
public abstract void Show();
抽象方法 默认不能私有
抽象方法只能在抽象类中声明，不能在非抽象类中声明；
抽象方法可以有 参数列表 和 返回值
2.抽象类
使用关键字 abstract 修饰的类，就是抽象类；
-抽象类不能被实例化，抽象类存在的意义 为子类提供相同的属性和方法；
-抽象类中可以有非抽象的属性和方法；
-抽象类 可以有自己的 构造方法 同样是 先执行父类中的构造，再执行子类的构造。
-一个非抽象子类，在继承抽象类之后，必须实现父类中的 所有 抽象方法；
抽象方法的实现 使用关键字 override
-一个抽象子类，在继承抽象类之后，可以实现抽象方法，也可以不实现。可以实现全部，也可以都不实现。
abstract 不能修饰字段 属性
二、接口
程序猿 口头说的： 黑盒 方法 传 XXX 返回 ###
程序中；接口是一种规范
USB 可以充电 可以传输数据
接口书写的位置 和 类平级
不允许接口中写类
不允许 在类中写接口。
interface（关键字） USB（标识符）//接口的标识符在命名的时候 一般以I开头
{
}
-只有方法的声明，没有方法的实现；
-接口没有访问权限修饰符，也不是默认的Private
-接口 不是抽象类 不能abstract修饰
-接口也是可以有返回值 和 参数
-接口是为了让别人实现用的
格式： 类名：接口名
就是写一个和接口中同名的方法，返回值类型 和 参数保持一致
不需要override修饰
一个类在实现一个接口的时候，需要实现接口中所有的方法；
一个类可以同时继承父类 和 实现接口，且 继承的父类需要在最前面，
三、接口实现的特点：
1.一个子类只能有一个父类，一个父类可以多个子类
一个接口可以被多个子类实现，一个子类可以有多个接口。
多个接口名称相同 实现一个即可
2.接口之间也可以有继承
最后继承类 要实现所有的接口中方法
3.多态在接口的体现
1.接口也是一种数据类型，引用类型
2.把实现类 数据类型 转换为接口类型 我们称之为 向上转型
把接口数据类型 转换为 实现类 数据类型 我们称之为 向下转型
1、设计一个交通工具抽象类，提供抽象方法–驾驶
汽车作为交通工具的一种，实现了驾驶的方法(在马路上驾驶)
火车作为交通工具的一种，实现了驾驶的方法(在铁路上驾驶)
飞机作为交通工具的一种，实现了驾驶的方法(在天上驾驶)
需求：做一个测试类，在测试类的Main函数中，分别实例化一个汽车的对象，火车的对象和飞机的对象，并分别描述驾驶行为
2、设计一个数据传输接口：Type-C标准
设计一个防水的接口：防水
设计一个手机类，实现这个数据传输接口，采用Type-C；同时实现了防水的接口
1.char
2.string
3.泛型
泛指的类型 不确定的类型
就是一种数据类型
4.委托
也是一种数据类型
是一种方法类型的数据
委托的声明位置 和 类平级
关键字 delegate
5.匿名函数
匿名 没有函数名称
代码敲3遍 整理笔记
复习
1.数据类型
值类型
int float bool enum char double decimal struct
引用类型
string 集合 数组 类 接口
2.object类
在C#中 object类型 是所有数据结构的父类 祖宗类 最基类
数据的装箱与拆箱
装箱： 从值类型 转换 为引用类型
拆箱： 从引用类型 转换 为值类型
3.集合
集合就是一个容器 用来存储数据
和数组区别：
数组在声明实例化的时候，长度确定，不可改变
集合是可以随时改变 长度 值
1.ArrayList 存不同数据 ***
引入命名空间
using System.Collections;
就是一种数据类型 引用类型
2.List 必须限定数据类型 *****
引入命名空间
using System.Collections.Generic;
3.Stack **
引入命名空间
using System.Collections;
4.Queue ***
引入命名空间
using System.Collections;
键值对
5.HashTable 存不同数据 *
引入命名空间
using System.Collections;
6.Dictionary 必须限定数据类型 ****
引入命名空间
using System.Collections.Generic;
课堂代码2-3 整理笔记
复习