C基础知识(需要特别注意知识点)

来源:普通话 发布时间:2021-04-12 点击:

 《C#4.0 本质论 》 学习笔记

 一、

 值类型和引用类型 的区别 值类型 引用类型 1. 直接包含值,变量引用的位置就是值在内存中实际存储的位置。

 存储是对一个内存位置的引用(内存地址),要去那个位置才能找到真正的数据 2. 数据存储在 栈的内存区域中 数据存储在 堆的内存区域 3. 在 编译时确定内存量 在 运行时,从变量中读取内存地址,然后到指定内存地址中读取数据。

 4. 复制数据的一个 副本 只复制数据的 地址 5. 将 new 用于值类型,会使用默认值初始化内存 new,调用构造函数生成一个对象(实例)

 二、

 装箱与拆箱 1. 装箱:将一个值类型转换成一个引用类型 1)

 首先在堆中分配好内存; 2)

 一次内存复制:栈上的值类型数据复制到堆上分配好的位置; 3)

 对象或接口引用得到更新,指向堆上的位置。

 2. 拆箱:将一个引用类型转换为值类型 3. 装箱频繁发生,会大幅影响性能; 4. 不允许在 lock()语句中使用值类型。

 三、

 String 与 与 StringBuilder 1. String 对象称为不可变的(只读),因为一旦创建了该对象,就不能修改该对象的值 2. StringBuilder 此类表示值为可变字符序列的类似字符串的对象 3. String 对象串联操作总是用现有字符串和新数据创建新的对象。StringBuilder 对象维护一个缓冲区,以便容纳新数据的串联。如果有足够的空间,新数据将被追加到缓冲区的末尾;否则,将分配一个新的、更大的缓冲区,原始缓冲区中的数据被复制到新的缓冲区,然后将新数据追加到新的缓冲区。

 4. String 或 StringBuilder 对象的串联操作的性能取决于内存分配的发生频率。String 串联操作每次都分配内存,而 StringBuilder 串联操作仅当 StringBuilder 对象缓冲区太小而无法容纳新数据时才分配内存。因此,如果串联固定数量的 String 对象,则 String 类更适合串联操作。这种情况下,编译器甚至会将各个串联操作组合到一个操作中。如果串联任意数量的字符串,则 StringBuilder 对象更适合串联操作;例如,某个循环对用户输入的任意数量的字符串进行串联 。

 四、

 ? 和 ?? 的使用 1. 可空修饰符 ?:为了声明可以存 null 的值类型变量。int ?x=null; 2. 使用 ?? 运算符分配默认值:expression1??expression2.检查第一个表达式是否为null,如果为 null,则返回第二个表达式。

 3. 当前值为空的可以为 null 的类型被赋值给非空类型时将应用该默认值,如 int? x =

 null; int y = x ?? -1;。

 三、 const 和 和 readonly 1. const:

 1)

 既然用于修饰字段,又可以修饰局部变量; 2)

 是在编译时确定的值,不可以在运行时改变; 3)

 自动成为静态字段,不能显式声明为 static 2. readonly:

 1)

 只能用于字段(不能用于局部变量), 2)

 指出字段值只能从构造函数中更改,或者直接在声明时指定。——可以在运行时赋值; 3)

 readony 字段既可以是实例字段,也可以是静态字段. 四、 静态 成员 和实例 成员

 1. 静态字段:主要存储的是对于类的数据,能由多个实例共享,需要使用 static 关键字 2. 实例字段:存储的是与对象关联的数据,只能从类的一个实例(对象)中访问实例字段。

 3. 静态方法:不能直接访问一个类中的实例字段,必须获取类的一个实例,才能调用任一实例成员(方法或字段)。

 4. 实例方法:将需要访问实例数据的方法声明为实例方法。

 5. 静态构造函数:用来对类(而不是类实例)进行初始化。

  运行时会在“访问类的一个静态方法或者字段时”自动调用静态构造函数。

 6. 静态类:不包含任何实例字段(或方法),声明时用 static 关键字。不能被实例化,不能被继承。

 五、 继承 :对一个现有的类型进行扩展,以包含附加的成员或实现对基类成员的定制。

 1. protected 访问修饰符:

 在基类中定义只有派生类才能访问的成员。

 规则:要从一个派生类中访问一个受保护的成员,必须在编译时确定受保护的成员是派生类(或者它的某个子类)的一个实例。

 2. C#是一种单一继承的语言,一个类不能直接从两个类派生。

 3. 可以使用聚合解决多重继承的问题 4. 使用 sealed 修饰符,实现密封类(不能被继承)

 5. C#支持重写实例方法和属性,但不支持重写字段或者任何静态成员。

 1)

 在基类中使用 virtual 修饰符标记每一个需要重写的成员, 2)

 在派生类中,用 override 进行修饰。C#要求重写方法显式地使用 override 关键字。

 3)

 重写一个成员时,会造成“运行时”调用派生得最远的实现。

 4)

 new 修饰符:在基类面前隐藏了派生类的重新声明的成员。

 6. 抽象类:

 1)

 仅供派生的类,不能被实例化。

 2)

 包含抽象成员:不具有实现的一个方法或属性,强制所有派生类提供实现。

 7. 多态性:同一个签名可以有多个实现。

 1)

 抽象成员是实现多态性的一个手段:基类指定方法的签名,派生类提供具体的实现; 2)

 可以利用多态性:调用基类的方法,当方法具体由派生类实现。

 8. is 和 as 运算符

 1)

 is 运算符验证基础类型 2)

 使用 as 运算符进行转换:将对象转换为一个特定的数据类型,若源类型不是固有的目标类型,as 运算符会将 null 值赋给目标。

 六、

 接口 1. 对接口的理解:

 1)接口定义了一系列成员,不包含任何实现,由继承该接口的类实现; 2)接口实现关系是一个“能做”关系:类“能做”接口要求的事情; 3)接口定义了一个“契约”:实现接口的类会使用与被实现的接口相同的签名来定义方法。

 4)

 接口的宗旨是:

 定义由多个类共同遵守的一个契约,所有成员都自动定义为public。

 5)

 C#不允许为接口成员使用访问修饰符。

 6)

 通过接口可以实现多态性; 7)

 不能被实例化,不能使用 new 关键字来创建一个接口。

 2. 接口实现:

 1)

 一个类只能从一个基类派生,但可以实现多个接口; 2)

 显式实现:

 为了声明一个显式接口成员实现,需要在 成员名之前附加接口名前缀。

 String[] IListable.ColumnValues {

 ……. } 通过接口本身来调用它——将对象转型为接口; Values=((IListable)contact1).Columnvalues 3)

 隐式实现:类成员的签名与接口成员的签名相符。

  调用时不需要转型,可以直接调用。

 4)

 成员若是核心的类功能,则隐式实现; 5)

 假如一个成员的用途在实现类中不是很明确,就考虑使用一个显式的实现; 6)

 已经有一个同名的类成员,则可以使用显式实现。

 3. 接口继承:

 1)

 一个接口可以从另一个接口派生,派生的接口将继承“基接口”的所有成员; 2)

 在用于显式接口成员实现的一个完全限定的接口成员名称中,必须引用最初声明它的那个接口的名称; 3)

 继承:接口代表一份契约,而一份契约可指定另一份契约也必须遵守的条款。

 4)

 通过接口可以实现多重继承。

 4. 接口与类的比较 抽象类 接口 仅供派生的类,不能被实例化 不能实例化 定义了基类必须实现的抽象成员签名 接口的所有成员要在基类中实现 可以包含存储在字段中的数据 不能存储任何数据。只能在派生类中指定字段。解决这个问题的办法,是在接口中定义属性,但不能包括实现。

 扩展性比接口好,不会破坏任何版本兼容性。在抽象类中,你可以添加附加的用更多的成员来扩展接口,会破坏版本兼容性。(只能再创建一个接口,该接口

 非抽象成员,它们可以由所有派生类继承 可以从原始接口派生)

 七、

 重写 Equals() 1. “对象同一性”和“相等的对象值” 1)

 对象同一性:两个引用,引用的是同一个实例; 2)

 相等的对象值:两个引用,引用不同的实例,但两个对象实例值是相等的。

 3)

 只有引用类型才可能引用相等,值类型不可能引用相等(ReferenceEquals()对值类型进行了装箱,由于每一个实参都被装到栈上的不同位置)。

 2. 实现 Equals():

 1)

 检查是否为 null; 2)

 如果是引用类型,就检查引用是否相等;(ReferenceEquals()方法来判断引用是否相等)

 3)

 检查数据类型是否相等; 4)

 调用一个指定了具体类型的辅助方法,它能将操作数视为要比较的类型,而不是一个对象; 5)

 可能要检查散列码是否相等。(相等的两个对象,不可能散列码不同)

 6)

 如果基类重写了 Equals(),就检查 base.Equals(); 7)

 比较每一个标识字段,判断是否相等; 8)

 重写 GetHashCode()。

 9)

 重写==和!=运算符。

 八、

 垃圾回收与资源清理 1. 垃圾回收

 内存 1)

 “运行时”的一个核心功能:回收不再被引用的对象所占用的内存。

 2)

 垃圾回收器只负责回收内存,不处理其他资源,比如数据库连接、句柄(文件、窗口等)、网络端口以及硬件设备(比如串口)等; 3)

 垃圾回收器处理的是引用对象,而且只回收堆上的内存;

 2. 终结器 释放资源 1)

 终结器:允许程序员编写代码来清理一个类的资源; 2)

 由垃圾回收器负责为一个对象实例调用终结器; 3)

 终结器会在上一次使用对象之后,并在应用程序关闭之前的某个时间运行。

 4)

 终结器不允许传递任何参数,不能被重载,不能被显式调用,不允许使用访问修饰符; 5)

 终结器负责释放像数据库连接和文件句柄这样的资源,不负责回收内存(回收内存是由垃圾回收器完成)

 6)

 避免在终结器中出现异常,比如采用空值检查。

 3. 使用 using 语句进行确定性终结:

 1)

 IDisposable 接口用一个名为 Dispose()的方法释放当前消耗的资源; 2)

 using 语句在对象离开作用域时自动调用 Dispose()方法释放资源。

 4. 垃圾回收和终结 1)

 f-reachable 队列(终结队列):是准备好进行垃圾回收,同时实现终结的所有对象的一个列表;

 2)

 假如一个对象有终结器,那么“运行时”只有在对象的终结方法被调用之后,才能对这个对象执行垃圾回收; 3)

 f-reachable 队列是一个“引用”列表,一个对象只有在它的终结方法得到调用,而且对象引用从 f-reachable 队列中删除之后,才会成为“垃圾”。

 九、

 泛型 1. 泛型类型概述:

 1)

 利用泛型,可以在声明变量时创建用来处理特定类型的特殊数据结构; 2)

 参数化类型,使特定泛型类型的每个变量都有相同的内部算法; 3)

 声明泛型类:

 public class Stack<T> {

 private T[] _Items; public void Push(T data) {

 …. } Public T Pop() {

 … } } 2. 泛型的优点:

 1)

 提供了一个强类型的编程模型:确保在参数化的类中,只有成员明确希望的数据类型才可以使用; 2)

 为泛型类成员使用值类型,不再造成到 object 的强制转换,它们不再需要装箱操作; 3)

 性能得到了提高:不再需要从 object 的强制转换,从而避免了类型检查;不再需要为值类型执行装箱操作 4)

 由于避免了装箱,因此减少了堆上的内存的消耗; 3. 泛型接口:

 1)

 声明一个泛型接口:

 Interface IPair<T> {

 T

 First {get;set;}

 T

 Second {get;set} } 2)

 使用泛型接口,就可以避免执行转型,因为参数化的接口能实现更强的编译时绑定; 3)

 在一个类中多次实现相同的接口:可以使用不同的类型参数来多次实现同一个接口。

 4. 多个类型参数:

 1)

 泛型类型可以使用任意数量的类型参数; 2)

 声明:

 Interface IPair<TFirst,TSecond> {

 TFirst

 First {get;set;}

 TSecond

 Second {get;set} } Public struct Pair<TFirst,TSecond>:IPair<TFirst,TSecond> {

 Public Pair(TFirst first,TSecond second) {

 _First=first;

  _Second=second; } . . . . }

 5. 约束 1)

 泛型允许为类型参数定义约束。这些约束强迫类型遵守各种规则; 2)

 约束声明了泛型要求的类型参数的特征。

 3)

 为了声明一个约束,需要使用 where 关键字,后跟一对“参数:要求”;其中,“参数”必须是泛型类型中定义的一个参数,而“要求”用于限制类型从中派生的类或接口,或者限制必须存在一个默认构造器,或者限制使用一个引用/值类型约束。

 4)

 接口约束:为了规定某个数据类型是必须实现某个接口,需要声明一个接口约束。不需要执行转型,就可以调用一个显式的接口成员实现。

 声明一个接口约束:

 public class BinaryTree<T>

  where T:System.IComparable<T> {

 …

 Public Pair<BinaryTree<T>> SubItems

 {

  get{return _SubItems;}

  set

  {

 IComparable<T> first;

 First=value.First.Item;

 …..

  } } } 5)

 基类约束:将构建的类型限制为一个特定的类派生。

 6)

 struct 约束:将类型参数限制为一个值类型; 7)

 class 约束:将类型参数限制为一个引用类型。

 8)

 多个约束:对于任何给定的类型参数,都可以指定任意数量的接口作为约束,但基类约束只能指定一个,因为一个类可以实现任意数量的接口,但肯定只能从一个类继承。

 public class EntityDictionary<Tkey,Tvalue> : Dictionary<TKey,TValue> where TKey: IComparable<TKey>,IFormattable

  //多个约束接口 where TValue: EntityBase

  //一个基类约束

 {

  …

 } 9)

 构造器约束:可以在指定了其他所有约束之后添加 new() ,指定类型参数必须有一个默认构造器。

 10)

 继承约束:约束可以由一个派生类继承,但必须在派生类中显式地指定这些约束。

 6. 泛型方法 1)

 即使包容类不是泛型类,或者方法包含的类型参数不在泛型类的类型参数列表中,也依然使用泛型的方法; 2)

 为了定义泛型方法,需要紧接在方法名之后添加类型参数语法;

 7. 协变性和逆变性 1)

 协变性:将一个较具体的类型赋给较泛化的类型。

 2)

 逆变性:将较泛化的类型赋给较具体的类型; 3)

 在 C#4.0 中使用 out 类型参数修饰符允许协变性; 4)

 在 C#4.0 中使用 int 类型参数修饰符允许逆变性; 8. 泛型的内部机制:

 1)

 基于值类型的泛型的实例化:“运行时”会为每个新的参数值类型创建新的具体化泛型类型。

 2)

 基于引用类型的泛型的实例化:使用一个引用类型作为类型参数来首次构造一个泛型类型时,“运行时”会创建一个具体化的泛型类型,并在 CIL 代码中用 object 引用替换类型参数。以后,“运行时”都会重用以前生...

推荐访问:知识点 基础知识 特别
上一篇:工商行政管理局流通领域假冒伪劣商品监督管理事中事后监督管理制度
下一篇:2020年邮政员工年度工作总结

Copyright @ 2013 - 2018 优秀啊教育网 All Rights Reserved

优秀啊教育网 版权所有