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 整理笔记
复习