C#知识点

标签：知识点 C# 子类 photos new txt 构造函数

1. 注释符

a)        单行注释        //注释单行代码

b)        多行注释        /*要注释的内容*/

c)        文档注释        ///注释类和方法

d)        HTML             <!—要注释的内容 -->

e)        CSS                 /*要注释的内容*/

 

1. 命名规范

a)        Camel骆驼命名规范：要求首单词的首字母小写，其余单词单字母大写——变量、字段

b)        Pascal——类、字段

 

1. 面向对象的复习（三大特性：封装、继承、多态）

a)        类和对象

u  类：一种数据类型，用户自定义的数据类型

u  对象：是具体的，是类的具体实例。

b)        封装复习

u  字段：存储数据，访问修饰符应该设置为private私有的。

u  属性：保护字段，对字段的取值和赋值进行限定。

u  构造函数：初始化对象，当创建对象的时候，会调用构造函数。

u  对字段的保护方法：

• Get()
• Set()
• 构造函数

c)        继承复习

u  解决代码的冗余，实现多态，增加了代码的扩展性，便于维护。

u  单根性

u  传递性

u  子类并没有继承父类的构造函数，但会默认调用父类的无参构造函数。

u  如果子类继承了一个父类，那么这个子类除了可以使用自己的成员外，还可以使用从父类那么继承过来的成员。但是父类永远都只能使用自己的成员，而不能使用子类的成员。

u  子类之间也不能使用对方的成员。

d)        多态复习

u  虚方法 virtual

u  父类中如果有方法需要子类重写，则可以将该方法标记为virtual

u  虚方法在父类中必须有实现，哪怕是空实现

u  虚方法子类可以重写（override），也可以不重写

u  抽象类 abstract

u  抽象方法需要用abstract关键字标记。

u  抽象方法不能有任何方法实现。

u  抽象成员必须包含在抽象类中。

u  由于抽象成员没有任何实现，所以子类必须将抽象成员重写。

u  抽象类不能实例化。

u  抽象类的作用：抽象类的作用就是为了让子类继承。

u  抽象类中可以包含抽象成员，可以包括具有代码的成员。

u  还有抽象方法不能用static修饰。

u  接口 interface

u  接口中只能包含方法（属性、事件、索引器也都是方法）

u  接口中的成员都不能有任何实现。

u  接口不能被实例化

u  接口中的成员不能有任何访问修饰符。（默认为public）

u  实现接口的子类必须将接口中的所有成员全都实现。

u  子类实现接口的方法时，不需要任何关键字，直接实现即可。

u  接口存在的意义就是为了多态。

e)        里氏转换

u  子类可以赋值给父类

u  如果父类中装的是子类对象，那么可以将这个父类转换为子类对象。

f)         As和Is

u  Teacher t = person as Teacher();     //as将person转换为Teacher类。若成功，则返回转换后的值。若失败，则返回NULL。

u  If(person is Student)     //若可以转化，则返回true；否则，返回false

g)        访问修饰符

u  Public：公开的，公共的

u  Private：私有的，只能在当前类的内部访问。类中成员们，如果不加访问修饰符，默认就是private。

u  Procteced：受保护的，可以在当前类的内部访问，也可以在该类的子类中访问。

u  Internal：在当前项目中都可以访问。

u  Protected internal

u  能够修饰类的访问修饰符只有两个:internal和public

u  子类访问权限不能高于父类访问权限。

h)        常用关键字：

u  This

1. 代表当前类的对象
2. 调用自己的构造函数

u  Base

1. 调用父类的构造函数
2. 在子类中调用父类的重名方法。

u  New

1. 在堆中开辟空间
2. 在开辟空间中创建对象
3. 调用对象中的构造函数
4. 隐藏从父类那里继承过来的成员

u  Virtual：标记一个方法是虚方法

u  Abstract：抽象的

u  Override：重写

u  Interface：接口

u  Partial：部分类

u  Sealed：密封类（不可以继承别人）

u  Return

1. 立即结束本次方法
2. 在方法中返回要返回的值

u  Break：跳出当前循环

u  Continue：结束本次循环，回到循环条件进行判断

u  Static：静态的

u  Struct：结构

u  Enum：枚举

u  Const：常量

 

1. 字符串String

a)        字符串的不可变性

b)        字符串可以看成char类型的只读数组

c)        属性——Length（获取字符串中字符的个数）

d)        方法

u  String.isNullOrEmpty()                 静态方法，判定是否为NULL或者为””

u  str.ToCharArray()                           将string转换为char[]

u  str.ToLower()                                  小写，必须接受返回值

u  str.ToUpper()                                  大写

u  str1.Equals(str2)                                      比较两个字符串是否相同。

u  str1.Equals(str2, StringComparation.OrdinalIgnoreCase)                                                                                        忽略大小写的比较

u  str1.Contains(str2)                          是否包含

u  str.indexOf(ch)                                如果没有找到对应的数据，返回-1

u  str.LastIndexOf(ch)                        如果没有找到对应的数据，返回-1

u  SubString(index)                            从index位置，开始截取字符串

u  SubString(index,length)                 从index位置，开始截取length个字符

u  str.Split()                                         分割字符串，返回字符数组

• str=“Hello，World!C#”
• str.Split(new char[]{‘,’,’!’},StringSplitOptions.RemoveEmptyEntries)

u  String.Join()                                   静态方法，拼接字符串,返回字符串

• String[] names={”1”,”2”};
• String s= String.Join(“|”,names);

u  Replace()                                         将指定字符串替换成新字符串

• String str = “111”;
• str = str.Replace(“111”,”123”);

u  Trim()                                              去掉字符串两端的空格

e)        StringBuilder（当大量进行字符串操作的时候）

u  sb.Append();                                    追加字符

u  sb.Insert(index,”新字符串”);         将字符插入到指定位置。若该位置，已存在，替换。

u  sb.ToString();                                   把StringBuilder转换为字符串。

u  sb.Replace(”将要被替换的字符串”,”新字符串”);                替换指定字符串

1. 集合

a)        ArrayList

b)        Hashtable

c)        List<T>

• List<int> list = new List<int>();
• list.Add();                                        添加单个元素
• list.AddRange();                             添加集合
• list.Insert();                                      插入单个元素
• list.InsertRange();                           插入集合
• list.Remove();                                 移除指定元素
• list.RemoveAt();                             移除指定位置元素
• list.RemoveRange();                       移除一定范围内的元素
• list.Contains();                                 判断是否包含

d)        Dictionary<TKey,TValue>

u  Dictionary<int,string> dic = new Dictionary<int.string>();

u  dic.Add(key,value);

u  dic[key]=value;

u  foreach(KeyValuePair<int,string> kv in dic)

u  {

• Console.WriteLine(“{0}—{1}”,kv.Key,kv.Value)

u  }

u  Dic.ContainKey(ch);              //是否包含键值

 

1. 装箱或者拆箱（尽量避免）

• 装箱：就是将值类型转换为引用类型。
• 拆箱：就是将引用类型转换为值类型。
• 值类型：bool int double char struct enum decimal
• 引用类型：string 数组 集合 interface object 自定义类
• 装箱或者装箱的两种类型必须具有继承关系

 

1. 静态与非静态

静态	非静态
static关键字	无需static关键字
使用类名调用： Person().SayHello();	使用实例对象调用： Person p = new Person(); p.eat();
在静态方法中，只可以访问静态成员	在实例方法中，可以直接访问静态成员
在静态方法中，不可以直接访问实例成员	在实例方法中，可以直接访问实例成员
调用前初始化（*）	实例化对象时初始化（*）

 

 

1. 结构和类的区别

a)        类型

u  结构：值类型

u  类：引用类型

b)        声明的语法：_name字段；Name属性

u  类：public class Person{字段、属性、方法、构造函数}。

u  在类中，构造函数里，既可以给字段赋值，也可以给属性赋值。

u  结构：public struct Person{字段、属性、方法、构造函数}。

u  在结构中，构造函数里，必须只能给字段赋值。

c)        调用：

u  类：Person p = new Person();       //在堆中开辟空间。

u  结构：Person p = new Person();   //在栈中开辟空间。

d)        结构和类的构造函数

u  相同点：不管是结构还是类，本身都会有一个无参数的构造函数

u  不同点：

• 当你在类中写了一个新的构造函数之后，那个默认的无参构造函数将会被覆盖。可以选择性给字段赋值。
• 当你在结构中写了一个新的构造函数之后，那个默认的无参构造函数依然存在。必须给所有字段赋值。

e)        类和结构的使用场合

u  如果我们只是单纯的存储数据的话，我们推荐使用结构。保存在栈上，比较节省空间。

u  如果我们想要使用面向对象的思想来开发程序，我们推荐使用我们的Class。

u  结构不具备面向对象的特征。

 

1. Path类（对字符串操作）

a)        目录和文件操作的命名控件System.IO

b)        方法：

u  String path = @”D:\C#\photos\1（1）.jpg”;

u  Path.ChangExtension(path,”txt”);         修改文件的后缀名，仅仅修改字符串，而非文件本身。

u  path = Path.Combine(@” D:\C#\photos”,” 1（1）.jpg”);   将两个路径合并成一个路径，比用”+”好，省去特意加上”\”。

u  Path.GetDirectoryName(path);                              获取文件的路径名。

u  Path.GetFileName(path);                                       获取文件的文件名包括后缀名。

u  Path.GetFileNameWithoutExtension(path);         获取文件的文件名。

u  Path.GetFullPath(path);                                         获取文件的全路径。根据相对路径获得绝对路径。

 

1. File类

a)        操作文件

u  File.Create(@”D:\C#\photos\1.txt”);                                                      创建文件

u  File.Delete(@”D:\C#\photos\1.txt”);                                                      删除文件

u  File.Copy(@”D:\C#\photos\1.txt”, @”D:\C#\photos\2.txt”);        复制文件

u  File.Move(@”D:\C#\photos\1.txt”, @”D:\C#\photos\2.txt”);        剪切文件

b)        使用File类来读取数据（一次性，适用小文件）

u  File.ReadAllBytes();                               以字节形式读取数据

• Byte[] buffer = File.ReadAllBytes(@”D:\C#\photos\1.txt”);
• String str = Encoding.Default.GetString(buffer,0,buffer.Length);                //解码：二进制转化为字符串

u  File.ReadAllLines();                               一行一行读取数据

String[] str = File.ReadAllLines(@”D:\C#\photos\1.txt”,Encoding.Default);

u  File.ReadAllText();                                 把所有字符串读取数据

String str=File.ReadAllText(@”D:\C#\photos\1.txt”,Encoding.Default);

c)        使用File类来写入数据

u  String str=”今天是最后一天复习啦”;

u  Byte[] buffer = Encoding.Default.GetBytes(str);

u  File.WriteAllBytes(@”D:\C#\photos\1.txt”,buffer);

u  File.WriteAllLines(@”D:\C#\photos\1.txt”,new string[]{”1”,”2”,”3”,”4”});

u  File.WriteAllLines(@”D:\C#\photos\1.txt”,str);

u  File.AppendAllText(@”D:\C#\photos\1.txt”,”追加，不会覆盖文件中原内容”);

 

1. Directory类（静态类）

a)        Directory.CreateDirectory(@”D:\C#\新建文件夹”);   //创建一个文件夹

b)        Directory.DeleteDirectory(@”D:\C#\新建文件夹”,true);        //删除的目录中不能有文件(如果添加true，可以删除非空目录的文件夹)

c)        Directory.Move (@”D:\C#\新建文件夹”，@@”D:\C#\文件夹”);        //移动文件夹

d)        String[] path = Directory.GetFile(@”D:\C#\新建文件夹”,”*.txt”);            //返回路径文件夹下所有文件。(若添加删除的内容，则只显示该后缀名的文件)

1. 文件流

a)        FileStream类（操作字节）

u  读取

• using (FileStream fsRead = new FileStream

(@”D:\C#\photos\1.txt”,FileMode.OpenOrCreate,FileAccess.Read)){

•       byte[] buffer = new byte[fsRead.Length];
•       int r = fsRead.Read(buffer,0,buffer.Length);
•       String s = Encoding.Default.GetString(buffer,0,r);
•       Console.WriteLine(s);
• }

u  写入

• Using (FileStream fsWrite = new FileStream

(@”D:\C#\photos\1.txt”,FileMode.OpenOrCreate,FileAccess.Write)){

•       string s = ”12321321321eseqw”;
•       byte[] buffer = Encoding.Default.GetBytes(s);
•       fsRead.Read(buffer,0,buffer.Length);
• }

b)        StreamRead类和StreamWrite类（操作字符）

u  读取

• Using (FileStream fsRead = new FileStream

(@”D:\C#\photos\1.txt”,FileMode.OpenOrCreate,FileAccess.Read)){

• using(StreamReader sr = new StreamReader(fsRead,Encoding.Default)){
•      while(!sr.EndOfStream){
•           Console.WriteLine(sr.ReadLine());
•      }
• }

u  写入

• Byte[] buffer = new byte[1024*1024];
• using (StreamWriter sw = new StreamWriter
• (@”D:\C#\photos\1.txt”, true, Encoding.Default, buffer.Length)){
• //true表示是否追加
• //buffer.Length表示缓冲区大小
•      sw.WriteLine(”1212315345”);
• }

 

1. 序列化

a)        要将序列化对象的类 标记为可以被序列化的

u  [Serializable]         //标记为可以被序列化

u  public class Person{}

b)        序列化

Person p = new Person();

using (FileStream fsWrite = new FileStream)

(@”D:\C#\photos\1.txt”, FileMode.OpenOrCreate, FileAccess.Write))

{

BinaryFormatter bf = new BinaryFormatter();

bf.Serialize(fsWrite, p);

}

c)        反序列化

Person p;

using (FileStream fsRead = new FileStream

(@”D:\C#\photos\1.txt”, FileMode.OpenOrCreate,FileAccess.Read))

{

BinaryFormatter bf = new BinaryFormatter();

p = (Person)bf.Deserialize(fsRead);

}

 

1. 委托就是指向了一个方法。
2. XML 和 HTML

a)        XML：可扩展的标记语言

u  标签（可DIY）

u  存储数据。小型的数据库

u  严格区分大小写，标签成对出现

u  有且仅有一个根节点Books

• <Books>

  <Book></Book>

• </Books>

b)        HTML：超文本标记语言

u  标签<p> <img>。

u  显示网页内容，起到了一个显示的效果。

标签：知识点,C#,子类,photos,new,txt,构造函数
From： https://www.cnblogs.com/kaede/p/16824525.html