C#之基础3---⑤（Stream（流）、Directory、重写、重载、虚方法、抽象方法、多态、设计模式、接口、拆装箱、序列化）

最新推荐文章于 2023-05-01 19:38:46 发布

Elsa~

最新推荐文章于 2023-05-01 19:38:46 发布

阅读量843

点赞数 3

分类专栏：【C#】

本文链接：https://blog.csdn.net/Elsa15/article/details/87346778

版权

【C#】专栏收录该内容

43 篇文章 12 订阅

订阅专栏

一、概念类

①、什么是Stream流,什么情况下用Stream流？

Stream（流），类Stream为抽象类，需要引入命名空间: using System.IO，其中类Stream为抽象类，由此有三个派生类：
MemoryStream：对内存进行读取与写入
BufferedStream：对缓冲器进行读取/写入
FileStream：对文件执行读取与写入
TextReader/Writer为抽象类。由此派生类：
StreamReader/StreamWirter
StringReader/StreamWriter

为什么引入文件流：读取大文件时，无法一下子传送过去，只能一点一点的读取，这就好比水龙头流水一样，我要接一桶水，要水管一点一点的放入。当接满后（读取完后）要关闭水管（文件流），把文件流代码放入using( )括号内，using可自动释放资源。

②、什么是Directory？什么时候用？如何用？

Directory类位于System.IO命名空间，Directory类提供了在目录和子目录中进行创建移动和列举操作的静态方法。此外，Directory还可以访问和操作各种各种的目录属性。我个人善于把它理解为文件件的操作。

一般对文件夹进行操作时使用，Directory属于静态类，所以直接 “ . ”调取方法。

③、什么是子类，什么是父类，如何理解面向对象的继承性？

子类父类的名词来自对象的三个特征中的继承性，如果一个类A“继承自”另一个类B，就把这个A称为“B的子类”，而把B称为“A的父类”。

继承性子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

④、什么是重写，什么是重载，区别是什么？

重写（override）：子类重写父类中的方法，不管父类中是虚方法还是抽象方法，子类都可重写。

重载（overload）:重载是方法的名称相同，参数或类型不同，进行多次重载以适应不同的需要。

区别：重写：子类重写写父类的方法，面向对象。

重载：为方法添加不同参数不同类型的内容，面向过程。

⑤、什么是虚方法，什么是抽象方法，什么是抽象类，虚方法与抽象方法的异同？

虚方法（Virtual）：当类中的方法声明前加上了Virtual修饰符，我们称之为虚方法，反之为非需。使用了virtual修饰符后，不允许再有static,abstract,override修饰符；虚方法有内容。

抽象方法（Abstract）：在面向对象编程语言中抽象方法指一些只有方法声明，而没有具体方法体的方法。抽象方法一般存在与抽象类或接口中。

抽象类：如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。在编程语句中用abstract修饰的类是抽象类，抽象类是不完整的，它只能用作基类，抽象类不能实例化。

虚方法与抽象方法的区别：

⑥、什么是多态？干什么用的？什么时候用？

多态就是对象可以表现多个类型的能力。同一操作作用于不同的对象（比如：叫），可以有不同的解释，产生不同的执行结果（狗：汪汪叫，猫：喵喵叫...）

简单工厂设计模式，核心就是多态。

⑦、什么是设计模式？

世上本无路，走的人多了便形成了路。世上本无设计模式，遇到的问题多了，总结出了遇到一些项目用哪些方式解决了。设计模式：软件开发过程中的经验积累。特定问题经过实践检验的特定解决方法。

⑧、什么是接口？接口特点？实现接口与显示接口的区别？

接口是一种用来定义程序的协议，它描述可属于任何类或结构的一组相关行为。接口可有方法、属性、事件和索引器或这四种成员的任何组合类型，但不能包含字段。

接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员（说明：如类A继承接口B，那么A中必须实现B中定义的属性和方法等），接口就是用来实现的。

⑨、什么是装箱、拆箱？作用？

装箱：将值类型将数据项从栈内存自动复制到堆内存的行为。

拆箱：将引用类型转换为值类型。

作用：利用装箱和拆箱功能，可通过允许值类型的任何值与Object类型的值互相转换，将值类型与引用类型链接起来。

⑩、抽象类（abstract class）和接口（interface）有什么区别？

相同点：

都没有方法体，都不能被实例化，都可以通过继承实现期抽象方法。

不同点：

接口支持多实现，抽象类不能实现多继承。

接口只能定义行为，抽象类既可以定义行为，还可能提供实现。

⑪、序列化作用？为什么要有序列化？

当我们从控制台内读取内容时，读取出来的都是字符串，我们想要用不同类型的内容还需要进行转换，那样会很麻烦，那有没有什么办法可以让存入的时候就是不同的类型，取出的时候也是不同的类型取出呢，应这种需求便有了序列化，把不同类型的内容存储在类的属性里。

序列化和反序列化，我们可能经常会听到，其实通俗一点的解释，序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的时候把这个文件再转化成原来的对象使用。

二、代码类

①、Stream（流）的读取与写入

        static void Main(string[] args)
        {                                                  
            string path = @"C:\Users\Smile\Desktop\1.txt"; //创建读取文件的路径
                                                           //文件流的读
            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                                                           //寻找路径，打开方式，打开后操作（读，写），
                                                           //使用using不用考虑是否关闭文件流，是否释放资源，using里面自动释放资源
            {
                using (StreamReader sr = new StreamReader(fs, Encoding.Default))
                {
                //bool result = sr.EndOfStream;           //是否读到文件末尾
                //Console.WriteLine(sr.ReadLine());       //只读取文本文档的第一行
                //Console.WriteLine(sr.ReadToEnd());      // 从头到尾的读取
                //从头读到末尾的另一种方法
                    while (!sr.EndOfStream)                //判断是否到文件流末尾
                    {
                        Console.WriteLine(sr.ReadLine());  //如果没有到末尾继续读
                    }
                }
            }
             //文件流的写
            using (FileStream fs = new FileStream(path, FileMode.Open,FileAccess.Write,FileShare.Write))
            {
                using (StreamWriter sw = new StreamWriter(fs,Encoding.Default))
                {
                    sw.Write("哈哈哈");
                }
            }
            Console.ReadKey();

②、Directory（目录\文件夹）的使用

 static void Main(string[] args)
        {
            string path = @"C:\Users\Smile\Desktop\1";
            Directory.CreateDirectory(path);                    //①、 创建文件夹   在指定路径下创建一个文件夹，如果文件夹内有东西再创建时不报异常
            Directory.Delete(path);                             //②、 删除文件夹   在指定路径下删除一个文件夹，如果文件夹内有内容则报异常，除非用Delete的第二个重载。
            bool result = Directory.Exists(path);               //③、判断指定路径path下有没有路径中文件夹1
            string[] dir = Directory.GetDirectories(path);      //④、获取当前路径下的所有文件夹路径
            for (int i = 0; i < dir.Length; i++)
            {
                Console.WriteLine(dir[i]);
            }

            string[] stri = Directory.GetFiles(path);           //⑤、获取当前路径下这个文件夹下所有文件的全路径,不包含文件夹
            for (int i = 0; i < stri.Length; i++)
            {
                Console.WriteLine(stri[i]);
            }
            string str = Directory.GetCurrentDirectory();       //⑥、获取当前程序所在目录
            Console.ReadKey();
        }

③、装箱、拆箱代码

        static void Main(string[] args)
        {
            //装箱:将值类型、将数据项从内存中自动复制到堆内存中的行为
            int num = 10;                      //值类型
            object obj = num;                  //值类型num内容赋值给引用类型obj
            Console.WriteLine(obj);
            Console.ReadKey();

            //拆箱：将引用类型转换为值类型
            int num = 10;
            object obj = num;
            int number = (int)obj;            //引用类型强制转换为值类型
            Console.WriteLine(number);
            Console.ReadKey();
        }

④、序列化

    class Program
    {
        static void Main(string[] args)
        {
            #region 序列化(写)：多个类型的存值
            Person p = new Person("张三", '男', 18);                //实例化一个类，并向对象赋值
            string path = @"C:\Users\Smile\Desktop\1.txt";          //建立一个路径
                                                                    //步骤一：创建流
            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Write, FileShare.Write))
            {
                BinaryFormatter bf = new BinaryFormatter();         //步骤二：创建一个二进制序列化器
                bf.Serialize(fs, p);                                //步骤三：对对象p进行序列化
            }
            Console.WriteLine("序列化成功");
            Console.ReadKey();
            #endregion

            #region 反序列化(读)：多个类型取值
            Person p ;                                              //实例化一个类
            string path = @"C:\Users\Smile\Desktop\1.txt";          //建立一个路径
                                                                    //步骤一：创建流
            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                BinaryFormatter bf = new BinaryFormatter();         //步骤二：创建一个二进制序列化器
                p=(Person)bf.Deserialize(fs);                       //步骤三：对对象p进行反序列化
            }
            Console.WriteLine("反序列化成功");
            Console.WriteLine(p.Name);                              //在控制台上写入对象的名称，类型为字符串
            Console.WriteLine(p.Age);                               //在控制台上写入对象的年龄，类型为整数型
            Console.WriteLine(p.Sex);                               //在控制台上写入对象的年龄，类型为字符型
            Console.ReadKey();
            #endregion
        }
    }

    [Serializable]                                                  //前提：序列化的时候要在类的前面做标记，告知序列化
    public class Person

⑤、异常处理

        static void Main(string[] args)
        {
            Console.WriteLine("请输入数字");
            
            try                                     //判断是否异常语句try catch语句
            {
                int number = Convert.ToInt32(Console.ReadLine());
            }
            catch (Exception ex)                    //Exception 是一个类，所以要实例化一个类，对象ex
            {
                Console.WriteLine(ex.Message);      //专业的错误提示信息
            }
            Console.ReadKey();
        }

三、拓展（很棒的文章）

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
14
评论
C#之基础3---⑤（Stream（流）、Directory、重写、重载、虚方法、抽象方法、多态、设计模式、接口、拆装箱、序列化）

一、概念类①、什么是Stream流,什么情况下用Stream流？Stream（流），类Stream为抽象类，需要引入命名空间: using System.IO，其中类Stream为抽象类，由此有三个派生类： MemoryStream：对内存进行读取与写入 BufferedStream：对缓冲器进行读取/写入 FileStream：对文件执行读取与写入 TextReader/Writ...
复制链接

扫一扫