.Net基础11

主要内容

File类

上一篇文章漏了几个方法，这里补上。

static void Main(string[] args)
{
    //读取
    byte[] buffer = File.ReadAllBytes(@"C:\Users\Administrator\Desktop\text.txt");
    //将字节数组中的每个元素都按照我们指定的编码格式解码成字符串
    string s = Encoding.GetEncoding(@"utf-8").GetString(buffer);
    Console.WriteLine(s);


    //写入
    //没有这个文件的话汇创建一个
    string str = "敲键盘";
    //需要字符串转换成字节数组
    byte[] buffer2 = Encoding.Default.GetBytes(str);
    File.WriteAllBytes(@"C:\Users\Administrator\Desktop\tt.txt", buffer2);

    Console.WriteLine("------------------------------------");

    //以行的形式读取
    string[] contents = File.ReadAllLines(@"C:\Users\Administrator\Desktop\tt.txt", Encoding.Default);
    foreach (var item in contents)
    {
        Console.WriteLine(item);
    }

    //读取所有文本
    string strr = File.ReadAllText(@"C:\Users\Administrator\Desktop\tt.txt", Encoding.Default);
    Console.WriteLine(strr);

    //以行的形式写入
    File.WriteAllLines(@"C:\Users\Administrator\Desktop\tt.txt", new string[] {"111", "222"});

    //写入字符串
    File.WriteAllText(@"C:\Users\Administrator\Desktop\tt.txt", "ewtqeqweqwewq");


    //追加
    File.AppendAllText(@"C:\Users\Administrator\Desktop\tt.txt", "追加的文字");


    Console.ReadKey();
}

绝对路径和相对路径

绝对路径：通过给定的这个路径直接能在我的电脑中找到这个文件。
相对路径：文件相对于应用程序的路径。
我们在开发中应该去尽量的使用相对路径。

List泛型集合

static void Main(string[] args)
{
    //创建泛型集合对象
    List<int> list = new List<int>();
    list.Add(20);
    list.Add(30);
    list.Add(40);

    list.AddRange(new int[] { 1, 2, 3});
    list.AddRange(list);

    //list泛型集合可以转换为数组
    int[] nums = list.ToArray();
    //将数组转集合
    List<int> listTwo = nums.ToList();

    for (int i = 0; i < list.Count; i++)
    {
        Console.WriteLine(list[i]);
    }

    Console.ReadKey();
}

装箱拆箱

装箱：就是将值类型转换为引用类型。
拆箱：将引用类型转换为值类型。
看两种类型是否发生了装箱或者拆箱，要看，这两种类型是否存在继承关系。只有存在继承才有可能发生。

static void Main(string[] args)
{
    int n = 10;
    object o = n;//装箱
    int m = (int)o;//拆箱

    Console.ReadKey();
}

字典集合

static void Main(string[] args)
{
    Dictionary<int, string> dict = new Dictionary<int, string>();
    dict.Add(1, "张三");
    dict.Add(2, "李四");

    dict[1] = "新来的";

    foreach (var item in dict.Keys)
    {
        Console.WriteLine("key: {0}------value: {1}", item, dict[item]);
    }

    //一对一对遍历
    foreach (KeyValuePair<int, string> kv in dict)
    {
        Console.WriteLine("key {0} ----- value {1}", kv.Key, kv.Value);
    }

    Console.ReadKey();
}

输出结果

FileStream 文件流 (操作字节的)

• FileStream的读写

static void Main(string[] args)
{
    //File 一次性读取 适合操作小文件
    //FileStream 操作字节的
    //StreamReader 和 StreamWriter 操作字符的


    //使用FileStream读取文件
    ////创建FileStream对象
    //FileStream fsRead = new FileStream(@"C:\Users\Administrator\Desktop\text.txt", FileMode.OpenOrCreate, FileAccess.Read);
    ////每次读取大小
    //byte[] buffer = new byte[1024 * 1024 * 5];
    ////返回本次实际读取到的有效字节数
    //int r = fsRead.Read(buffer, 0, buffer.Length);
    ////将字节数组中的每一个元素按照指定的编码格式解码成字符串
    //string s = Encoding.Default.GetString(buffer, 0, r);
    ////关闭流 
    //fsRead.Close();
    ////释放流所占用的资源
    //fsRead.Dispose();
    //Console.WriteLine(s);
    //Console.ReadKey();


    //使用FileStream写入文件
    //将创建文件流对象的过程写在using当中，会自动的帮助我们释放流所占用的资源。

    using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator\Desktop\text.txt", FileMode.OpenOrCreate, FileAccess.Write))
    {
        string s = "看我有没有把你覆盖";
        byte[] buffer = Encoding.Default.GetBytes(s);
        fsWrite.Write(buffer, 0, buffer.Length); 
    }

    Console.ReadKey();
}

• 使用文件流实现多媒体复制

static void Main(string[] args)
{
    //思路：先将要复制的多媒体文件读取出来，然后写入到指定的位置
    string source = @"C:\Users\Administrator\Desktop\4、变量的使用规则.avi";
    string taeget = @"C:\Users\Administrator\Desktop\1111.avi";

    CopyFile(source, taeget);
    Console.ReadKey();
}

public static void CopyFile(string source, string target)
{
    //创建一个读取的流
    using (FileStream fsRead = new FileStream(source, FileMode.OpenOrCreate, FileAccess.Read))
    {

        //创建一个写入的流
        using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write))
        {
            byte[] buffer = new byte[1024 * 1024 * 5];
            //因为文件可能会比较大 ，所以我们在读取的时候应该通过一个循环去读取
            while (true)
            {
                //返回本次实际读取的字节数
                int r = fsRead.Read(buffer, 0, buffer.Length);
                //如果返回一个0 也就一位置什么都没有读取到，读取完了
                if (r == 0)
                {
                    break;
                }
                fsWrite.Write(buffer, 0, r);
            }  
        }
    }
}

StreamReader和StreamWriter (操作字符的)

static void Main(string[] args)
{
    //使用StreamReader 来读取一个文本文件
    //using (StreamReader sr = new StreamReader(@"C:\Users\Administrator\Desktop\text.txt", Encoding.Default))
    //{
    //    while (!sr.EndOfStream)
    //    {
    //        Console.Write(sr.ReadLine());
    //    }
    //}
    //Console.ReadKey();

    //使用StreamReader 来写入一个文本文件
    using (StreamWriter sw = new StreamWriter(@"C:\Users\Administrator\Desktop\text.txt", true))
    {
        sw.Write("今天天气好晴朗");
    }
    Console.ReadKey();
}

多态

概念：让一个对象能够表现出多种状态（类型）
实现多态的3种手段 1、虚方法 2、抽象类 3、接口

• 虚方法
  步骤
  1、将父类的方法标记为虚方法 ，使用关键字 virtual，这个函数可以被子类重新写一遍。在子类方法中使用关键字 virtual

static void Main(string[] args)
{
    //概念：让一个对象能够表现出多种状态（类型）
    //实现多态的3中手段 1、虚方法 2、抽象类 3、接口
    
    Chinese cn1 = new Chinese("韩梅梅");
    Chinese cn2 = new Chinese("李雷");

    Japanese j1 = new Japanese("竹下");
    Japanese j2 = new Japanese("田中");

    Korean k1 = new Korean("xxx俊熙");
    Korean k2 = new Korean("dede美熙");

    Person[] pers = { cn1, cn2, j1, j2, k1, k2};

    for (int i = 0; i < pers.Length; i++)
    {
        //if (pers[i] is Chinese)
        //{
        //    ((Chinese)pers[i]).SayHello();
        //}
        //else if (pers[i] is Japanese)
        //{
        //    ((Japanese)pers[i]).SayHello();
        //}
        //else
        //{
        //    ((Korean)pers[i]).SayHello();
        //}

        pers[i].SayHello();
    }

    Console.ReadKey();
}

public class Person
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public Person(string name)
    {
        this.Name = name;
    }

    public virtual void SayHello()
    {
        Console.WriteLine("我是人类");
    }
}

public class Chinese : Person
{
    public Chinese(string name) : base(name)
    {
    }

    public override void SayHello()
    {
        Console.WriteLine("我是中国人，我叫{0}", this.Name);
    }

}

public class Japanese : Person
{
    public Japanese(string name) : base(name)
    {
    }

    public override void SayHello()
    {
        Console.WriteLine("日本人 {0}", this.Name);
    }
}

public class Korean : Person
{
    public Korean(string name) : base(name)
    {

    }

    public override void SayHello()
    {
        Console.WriteLine("韩国棒子 {0}", this.Name);
    }
}

• 抽象类

当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。
注意：使用关键字 abstract， 抽象方法不能有方法体，子类方法使用override 从写。

static void Main(string[] args)
{
    //狗狗会叫 猫咪会叫

    Animal a = new Dog();
    a.Bark();

    Animal b = new Cat();
    b.Bark();

    Console.ReadKey();
}

//使用关键字 abstract
public abstract class Animal
{
    //抽象方法不能有方法体
    public abstract void Bark();
}

public class Dog : Animal
{
    public override void Bark()
    {
        Console.WriteLine("狗狗旺旺叫");
    }

}

public class Cat : Animal
{
    public override void Bark()
    {
        Console.WriteLine("猫咪喵喵叫");
    }
}

1.抽象成员必须标记为abstract,并且不能有任何实现。
2.抽象成员必须在抽象类中。
3.抽象类不能被实例化

4.子类继承抽象类后，必须把父类中的所有抽象成员都重写。

（除非子类也是一个抽象类，则可以不重写）
5.抽象成员的访问修饰符不能是private
6.在抽象类中可以包含实例成员。
并且抽象类的实例成员可以不被子类实现

7.抽象类是有构造函数的。虽然不能被实例化。

8、如果父类的抽象方法中有参数，那么。继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。

如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候 也必须要传入返回值。

======
如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。

如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。

抽象类练习：使用多态求矩形的面积和周长以及圆形的面积和周长。

static void Main(string[] args)
{
    //使用多态求矩形的面积和周长以及圆形的面积和周长

    Shape shape = new Square(2, 3);//new Circle(3.0);
    Console.WriteLine(shape.GetArea());
    Console.WriteLine(shape.GetPerimeter());

    Console.ReadKey();
}

public abstract class Shape
{
    public abstract double GetArea();
    public abstract double GetPerimeter();
}

public class Circle : Shape
{
    private double _r;

    public double R
    {
        get { return _r; }
        set { _r = value; }
    }

    public Circle(double r)
    {
        this.R = r;
    }

    public override double GetArea()
    {
        return Math.PI * this.R * this.R;
    }

    public override double GetPerimeter()
    {
        return 2 * Math.PI * this.R;
    }
}

public class Square : Shape
{
    private double _length;
    private double _width;

    public double Length
    {
        get { return _length; }
        set { _length = value; }
    }

    public double Width
    {
        get { return _width; }
        set { _width = value; }
    }

    public Square(double length, double width)
    {
        this.Length = length;
        this.Width = width;
    }

    public override double GetArea()
    {
        return this.Length * this.Width;
    }

    public override double GetPerimeter()
    {
        return 2 * (Length + Width);
    }
}

---

往期回顾

• .Net基础01
• .Net基础02
• .Net基础03
• .Net基础04
• .Net基础05
• .Net基础06
• .Net基础07
• .Net基础08
• .Net基础09
• .Net基础10

图文无关.png