C#—代码理解知识点(二)

原创

mark223 2022-12-05 16:03:00 博主文章分类：——【C#】 ©著作权

©著作权归作者所有：来自51CTO博客作者mark223的原创作品，请联系作者获取转载授权，否则将追究法律责任

上回介绍了关于第一章所设计的那些知识点，这次介绍一下第二章所涉及到的代码，以及由代码折射出的知识点！

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//第二章，声明属性的修饰符，以及调用另一个类的属性和方法
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建类中的一个对象
            BankCustomer c;
            //实例化
            c = new BankCustomer();
            //调用并赋值
            c.FirstName = "kang";
            c.LastName = "ma";
            c.Balance = 0.0M;
            c.Deposit(1000.00M);
        }
    }
    public class BankCustomer
    {
        //定义属性
        public string FirstName;
        public string LastName;
        public decimal Balance;
        //定义方法
        public void Deposit(decimal amount)
        {
            this.Balance += amount;
        }
    }
}</span></span>

这个例子主要讲了如何在一个类中调用另一个类的属性和方法，其中另一个类属性和方法的声明必须是public（公有），如果定义为private（私有）是无法调用的。

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//问题 第二章 面向对象第二小节 Authentic运用
namespace Authentic1
{
    public class TESTMain
    {
        public static void Main()
        {
            Authentic simon = new Authentic();
            bool Done;
            Done = simon.ChangePassword("马 康", "makang");
            if (Done == true)
                Console.WriteLine("password ok");
            else
                Console.WriteLine("错误");
        }
    }
    class Authentic
    {
        //定义私有 密码
        public string Password = "马康";
        //定义boll类型的密码属性
        public bool IsPasswordCorrect(string userPassWord)
        {
            return (Password == userPassWord) ? true : false;
        }
        public bool ChangePassword(string oldPassword, string newPassword)
        {
            if (oldPassword == Password)
            {
                Password = newPassword;
                return true;
            }
            else
                return false;
        }

    }
}</span></span>

一开始我只写了一个Authentic类，并且一直在这个类中加Main方法，怎么也运行不出来，这次再看这些遗留的问题的时候发现原来需要在另一个类中调用Authentic类的方法以及判断，这也就能很好的说明，我第二次看的时候比第一次看有收获了！

从以上例子中关于Authentic的运用很明显了，就是用来做判断用的，记得设计模式中会将这些判断都分成每一类中单独的判断，也就是降低代码之间的耦合度了！

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//第二章面向对象，static静态构造函数 可以用this或者base调用基类的构造函数
namespace Bus
{
    public class Bus
    {
        //Static constructor：
        static Bus()
        {
            System.Console.WriteLine("这是一个静态构造函数Bus方法");
        }

        public static void Drive()
        {
            System.Console.WriteLine("这是一个Drive方法.");
        }
    }
    class TestBus
    {
        static void Main()
        {
            Bus.Drive();
        }
    }
}
//最后结果将自动调用Bus类中的Bus方法（自动调用）！</span></span>

这个例子主要介绍了一下静态构造函数的使用，看着视频中介绍它的定义，总结一下就是：

1.方法名和类名相同（以上的Bus类名和Bus方法名）。

2.调用改类中的方法的时候，它就会被优先调用。

3.不显示调用方法，无法访问返回值（构造函数不返回值）。

4.构造函数可以用this和base调用和重写。

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//问题第二章，面向对象，方法重写
namespace Basederived
{
    class Base
    {
        public virtual void base1()
        {
            Console.WriteLine("此方法显示定义方法");
        }
    }
    class Derived : Base
    {
        //重写base类中的base1方法
        public override void base1()
        {
            base.base1();
            Console.WriteLine("此方法重写base方法");
        }
        public static void Main()
        {
            Base a = new Derived();
            a.base1();

        }
    }
}</span></span>

通过这个例子对于方法的重写有些理解了，需要注意的是：

1.方法重写必须匹配基类中方法的返回值类型和参数，否则就会产生一个编译错误。

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//第二章，面向对象，abstract关键字
namespace abstract1
{
    abstract class ShapesClass
    {
        abstract public int Area();
    }
    class Square : ShapesClass
    {
        int x, y;
        //Not providing an Area method results
        //in a compile-time error.
        public override int Area()
        {
            return x * y;
        }
    }
}</span></span>

以上例子介绍了abstract关键字，若以此关键字修饰的类，证明此类只能是其他类的基类！将范围缩小，减少耦合度！

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//第二章面向对象，向上转型
namespace consoleApplication1
{
    class program
    {
        static void Main(string[] arge)
        {
            Derive.Test2();
        }
    }
    public class Bass
    {
        public void Test()
        {
            Console.WriteLine("我是基类");
        }
    }
    public class Derive : Bass
    {
        public static void Test2()
        {
            Bass b = new Derive();
            b.Test();
        }
    }
}</span></span>

这个向上转型例子，将派生类当作基类来使用。

<span style="font-family:KaiTi_GB2312;font-size:18px;"><span style="font-family:KaiTi_GB2312;font-size:24px;">//第二章 面向对象 播放器  多态
namespace bofang
{
    class program
    {
        static void Main(string[] arge)
        {
            //DVD dvd = new DVD();
            //Console.WriteLine(dvd.PlayVideo());
            //VCD vcd = new VCD();
            //Console.WriteLine(vcd.PlayVideo());

            //调用playvideo（）方法
            program tt = new program();
            tt.PlayVideo();
        }
        public void PlayVideo()
        {
            VideoShow vw;
            vw = new DVD();
            Console.WriteLine(vw.PlayVideo());
            vw = new VCD();
            Console.WriteLine(vw.PlayVideo());
        }
    }
    //定义一个播放类
    public abstract class VideoShow
    {
        public abstract string PlayVideo();
    }
    //继承播放类
    public class VCD : VideoShow
    {
        public override string PlayVideo()
        {
            return "正在播放VCD";
        }
    }
    //继承播放类
    public class DVD : VideoShow
    {
        public override string PlayVideo()
        {
            return "正在播放DVD";
        }
    }
}</span></span>