C# 中类与继承等概念

C#是一种现代的、面向对象的编程语言，其中类和继承是面向对象编程语言中非常重要的概念，类和继承是C#中面向对象编程的基本概念，可以用于创建复杂的应用程序和模块，而多态和接口可以使程序更加灵活和可扩展。 熟练掌握这些概念有助于提高C#编程效率和质量。

下面简要介绍：

• 类（Class）：

• 类是C#中面向对象编程的基本单位，它是一种用户自定义的数据类型，可以封装数据和方法。类定义了一个对象的属性和方法，并且可以创建其多个实例。一个类可以有自己的构造函数、方法、属性和字段等。

• 继承（Inheritance）：

• 继承是一种面向对象编程的概念，允许创建一个新类（子类），它从现有的一个或多个类（父类）继承属性和方法，从而可以重用现有代码。子类可以添加新的属性和方法，或覆盖父类的方法。

• 多态（Polymorphism）：

• 多态是一种面向对象编程的概念，它允许同一个方法名可以在不同的对象上执行不同的操作。多态使程序编写更加灵活，可以适应不同的使用场景。

• 接口（Interface）：

• 接口定义了一组方法或属性的规范，而不提供实现。接口只定义了方法或属性的名称，而不定义它们的实现方式。类可以实现（implement）一个或多个接口，从而提供了它们的具体实现。

构造函数/析构函数:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{

    class Person
    {
        public int Number;
        public string Name;
        private int tmp = 0;

        // 定义构造函数
        public Person(int x,string y)
        {
            this.Number = x;
            this.Name = y;
            Console.WriteLine("构造函数执行");
        }
        // 定义析构函数
        ~Person()
        {
            Console.WriteLine("析构函数执行");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person ptr = new Person(1001, "lyshark");
            Console.WriteLine("ID: {0} Name: {1}", ptr.Number, ptr.Name);

            Console.ReadKey();
        }
    }
}

对象中Get/Set方法: 该方法是用来限定用户属性的。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{

    class Person
    {
        private int _age;
        public int age
        {
            // 当用户输出该属性的值是执行Get方法
            get { return _age; }

            // 当用户对该属性赋值时执行Set方法
            set
            {
                // 判断如果年龄小于0或者大于100则直接返回0
                if (value < 0 || value > 100)
                {
                    value = 0;
                }
                // 否则将用户数据赋值给变量
                _age = value;
            }
        }
        // 定义构造函数
        public Person(int x)
        {
            this.age = x;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person ptr = new Person(10);
            Console.WriteLine("正常年龄: {0}", ptr.age);

            Person ptr_err = new Person(102);
            Console.WriteLine("异常年龄: {0}", ptr_err.age);

            Console.ReadKey();
        }
    }
}

静态方法与非静态方法:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Person
    {
        private static string _name;
        public static string Name
        {
            get { return Person._name; }
            set { Person._name = value; }
        }

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }
        public void M1()
        {
            Console.WriteLine("我是非静态的方法");
        }
        public static void M2()
        {
            Console.WriteLine("我是一个静态方法");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person ptr = new Person();

            // 调用非静态方法
            ptr.M1();
            // 调用静态方法
            Person.M2();

            Console.ReadKey();
        }
    }
}

继承的基本使用:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    // 定义基类
    public class Person
    {
        public string name;
        public int age;

        public Person(string _name, int _age)
        {
            this.name = _name;
            this.age = _age;
        }
        public void Display()
        {
            Console.WriteLine("姓名: {0} 年龄:{1} ", this.name, this.age);
        }
    }

    // 定义派生类
    public class Studnet: Person
    {
        public int stu;
        public Studnet(string _name,int _age,int _stu):base(_name,_age)
        {
            this.stu = _stu;
        }
        public void Display()
        {
            Console.WriteLine("Stu编号: {0} 学生姓名: {1} 年龄: {2}",this.stu,this.name,this.age);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 定义基类
            Person ptr = new Person("lyshark",22);
            ptr.Display();

            // 定义派生类
            Studnet stu = new Studnet("lyshark",22,1001);
            stu.Display();

            Console.ReadKey();
        }
    }
}

虚方法实现多态: 首先将父类函数标记为虚方法，然后子类就可以重写父类的虚方法，实现多态。

using System;
using System.Collections;

namespace ConsoleApplication1
{
    // 定义一个人类的基类
    public class Person
    {
        public string name;
        public Person(string name)
        {
            this.name = name;
        }
        public virtual void SayHello()
        {
            Console.WriteLine("基类方法");
        }
    }
    // 定义日本人并继承人类,重写SayHello方法
    public class Japanese : Person
    {
        public Japanese(string name) : base(name) { }
        // 重写父类的SayHello
        public override void SayHello()
        {
            base.SayHello();
            Console.WriteLine("日本人");
        }
    }
    // 定义中国并继承人类,重写SayHello方法
    public class Chinese : Person
    {
        public Chinese(string name) : base(name) { }
        // 重写父类的SayHello
        public override void SayHello()
        {
            Console.WriteLine("中国人");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 普通的调用方式
            Japanese jap = new Japanese("苍井空");
            jap.SayHello();

            Chinese chi = new Chinese("韩梅梅");
            chi.SayHello();

            // 直接通过循环调用
            Person[] per = { jap, chi };
            for (int x = 0; x < per.Length; x++)
                per[x].SayHello();

            Console.ReadKey();
        }
    }
}

抽象类实现多态: 当父类中的方法不知道如何实现的时候，可以考虑将父类定义为抽象类，将方法定义为抽象方法。

using System;
using System.Collections;

namespace ConsoleApplication1
{
    // 定义一个抽象类,等待让子类重写
    public abstract class Shape
    {
        public abstract double GetArea();
    }

    // 定义子类重写抽象类
    public class CirCle:Shape
    {
        public double x;
        public double y;

        public CirCle(double x,double y)
        {
            this.x = x;
            this.y = y;
        }
        public override double GetArea()
        {
            return this.x * this.y;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 抽象类不可实例化,只能实例化子类
            Shape sp = new CirCle(12.5,20.8);
            double ret = sp.GetArea();
            Console.WriteLine("结果是: {0}", ret);

            Console.ReadKey();
        }
    }
}

接口实现多态: 接口不允许有访问修饰符，方法自动设置为自动属性。

using System;
using System.Collections;

namespace ConsoleApplication1
{
    // 定义一个接口,等待让子类重写
    public interface Person
    {
        void Display();
    }
    // 定义派生类,继承于Person接口
    public class Student:Person
    {
        public void Display()
        {
            Console.WriteLine("定义学生");
        }
    }
    // 定义派生类
    public class Teacher:Person
    {
        public void Display()
        {
            Console.WriteLine("定义老师");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // 调用学生方法
            Person stu = new Student();
            stu.Display();

            // 调用老师方法
            Person tea = new Teacher();
            tea.Display();

            Console.ReadKey();
        }
    }
}