C# 中类与继承等概念

已于 2023-07-02 15:57:43 修改
阅读量5.2k 收藏
点赞数
分类专栏： 博客园搬家 文章标签： c# .net Visual C# visualstudio 微软技术 类与继承
于 2020-06-18 12:47:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyshark_csdn/article/details/124939209
版权

在C#中，类是面向对象编程的基本概念之一。类是一种模板或蓝图，用于定义对象的属性和行为。它是创建对象的基础，包含数据成员（字段）和函数成员（方法）。通过定义类，可以创建多个具有相似属性和行为的对象。

类是面向对象编程中的基本概念之一，它是一种模板或蓝图，用于定义对象的属性和行为。类提供了一种组织和封装数据以及相关操作的方式，它将数据成员（字段）和函数成员（方法）封装在一起，形成一个独立的实体。

通过类，可以创建多个具有相似属性和行为的对象。对象是类的实例，它可以使用类中定义的数据和函数来执行特定的任务。类定义了对象的结构和行为，而对象则代表了类的具体实例。

继承是面向对象编程中的另一个重要概念，它允许一个类继承另一个类的属性和行为。被继承的类称为基类或父类，继承这个类的类称为派生类或子类。派生类可以继承基类的成员，并可以添加新的数据成员和函数成员，或者修改已继承的成员。

继承提供了代码重用和扩展的能力。通过继承，派生类可以使用基类已有的功能，避免了重复编写相似的代码。派生类可以通过添加新的成员来扩展基类的功能，也可以重写基类的成员来修改其行为。

继承支持多层次的层级关系，也就是派生类可以成为另一个派生类的基类，形成类的继承链。这种层级关系可以形成更复杂的类结构，并支持更高级别的抽象和组织。

除了基本的类和继承概念，面向对象编程还涉及其他概念，如抽象类、接口、多态等。这些概念进一步扩展了类和继承的能力，使代码更具灵活性、可扩展性和可维护性。它们提供了一种更高级别的代码组织和设计方法，使得面向对象编程更具优势和效率。

构造函数与析构函数

这段代码定义了一个名为Person的类和一个Program类。Person类具有公共的整数Number和字符串Name属性，以及一个私有的整数tmp字段。

在Person类中，定义了一个构造函数和一个析构函数。构造函数用于初始化Person类的实例，并将传入的参数赋值给相应的属性。析构函数在对象被销毁时执行，用于释放对象占用的资源。

在Program类的Main方法中，创建了一个Person类的实例ptr，并传入参数1001和"lyshark"给构造函数进行初始化。然后，使用ptr对象访问其属性Number和Name，并将它们输出到控制台。

最后，通过Console.ReadKey()等待用户按下任意键退出程序。

总体来说，这段代码演示了如何定义类和构造函数，以及如何创建类的实例并访问其属性。同时，也展示了析构函数的使用，用于在对象销毁时执行清理操作。

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方法

这段代码定义了一个名为Person的类和一个Program类。Person类具有一个私有的整数_age字段和一个公共的age属性。

在age属性中，定义了get和set方法。get方法用于返回_age字段的值，而set方法用于接收用户赋值给属性的值，并进行一些逻辑判断。如果赋值的值小于0或大于100，则将属性的值设为0；否则，将赋值的值赋给_age字段。

在Person类的构造函数中，通过传入的参数将年龄赋值给age属性。

在Program类的Main方法中，创建了一个Person类的实例ptr，并将年龄初始化为10。然后，通过访问ptr对象的age属性，输出其正常年龄。

接着，创建了另一个Person类的实例ptr_err，将年龄初始化为102，超出了合理的范围。再次通过访问ptr_err对象的age属性，输出其异常年龄。根据属性的设置逻辑，异常年龄将被设置为0。

最后，通过Console.ReadKey()等待用户按下任意键退出程序。

总体来说，这段代码演示了如何定义属性，并在属性的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();
        }
    }
}

静态方法与非静态方法

这段代码定义了一个名为Person的类和一个Program类。Person类具有两个字段：一个私有的静态字符串_name和一个私有的字符_gender。同时，Person类还定义了两个属性：一个公共的静态字符串属性Name和一个公共的字符属性Gender。

Name属性使用Person._name作为字段，用于获取和设置静态的名称。Gender属性使用_gender字段，用于获取和设置实例的性别。

Person类还定义了两个方法：一个非静态的方法M1()和一个静态的方法M2()。M1()方法输出"我是非静态的方法"，而M2()方法输出"我是一个静态方法"。

在Program类的Main方法中，创建了一个Person类的实例ptr。然后，通过调用ptr对象的非静态方法M1()，输出"我是非静态的方法"。接着，通过调用Person类的静态方法M2()，输出"我是一个静态方法"。

最后，通过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();
        }
    }
}

继承的基本使用

这段代码定义了一个基类Person和一个派生类Student。基类Person具有两个公共字段name和age，以及一个构造函数Person(string _name, int _age)和一个方法Display()用于显示姓名和年龄。

派生类Student继承了基类Person，并添加了一个额外的字段stu表示学生编号。派生类Student还定义了一个与基类同名的方法Display()，用于显示学生编号、姓名和年龄。

在Main方法中，首先创建了一个基类Person的实例ptr，并调用Display()方法显示姓名和年龄。然后创建了一个派生类Student的实例stu，并调用Display()方法显示学生编号、姓名和年龄。

总结来说，这段代码演示了类的继承关系。派生类可以继承基类的字段、构造函数和方法，并且可以在派生类中添加额外的字段和方法。通过继承，派生类可以重用基类的代码，并且可以扩展和修改基类的功能。

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();
        }
    }
}

虚方法实现多态

这段代码演示了在继承关系中使用虚方法和重写方法的概念。

首先定义了一个基类Person，它具有一个字段name和一个构造函数Person(string name)。基类还定义了一个虚方法SayHello()，用于输出基类方法的信息。

然后定义了两个派生类Japanese和Chinese，它们都继承自基类Person。派生类分别重写了基类的SayHello()方法，以输出特定国家的信息。Japanese重写后会先调用基类的SayHello()方法，然后输出"日本人"；Chinese直接输出"中国人"。

在Main方法中，首先创建了一个Japanese类的实例jap和一个Chinese类的实例chi，并分别调用它们的SayHello()方法。接着创建了一个Person类型的数组per，其中包含了jap和chi两个对象。通过循环遍历数组，可以直接调用基类的SayHello()方法或派生类重写的SayHello()方法，实现对不同对象的多态调用。

总结来说，虚方法和重写方法是面向对象中实现多态性的关键概念。通过使用virtual和override关键字，可以在派生类中重写基类的方法，并且可以在运行时根据对象的实际类型调用适当的方法。这种灵活性使得代码可以更加可扩展和可维护，同时提高了代码的可读性和复用性。

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();
        }
    }
}

抽象类实现多态

抽象类和抽象方法是用于定义一组相关类的通用行为的机制。抽象类不能被实例化，只能作为其他类的基类，并且可以包含具体的方法和抽象方法。派生类必须重写抽象类中的所有抽象方法，提供具体的实现。抽象类和抽象方法的使用可以实现代码的模板化和代码重用，同时也可以确保派生类具有特定的行为。当父类中的方法不知道如何实现的时候，可以考虑将父类定义为抽象类，将方法定义为抽象方法。

首先定义了一个抽象类Shape，其中包含一个抽象方法GetArea()。抽象类用abstract关键字修饰，其中的抽象方法没有具体的实现，只有方法的签名，即返回类型和参数列表。抽象方法必须在派生类中进行重写实现。

然后定义了一个派生类CirCle，它继承自抽象类Shape。派生类重写了基类的抽象方法GetArea()，并提供具体的实现。在这个例子中，CirCle类表示一个圆形，它有两个属性x和y，在重写的GetArea()方法中计算并返回圆形的面积。

在Main方法中，由于抽象类不能被实例化，所以创建了一个抽象类Shape的引用sp，并用派生类CirCle的实例进行初始化。通过抽象类的引用，调用了重写后的GetArea()方法，计算出了圆形的面积并将结果输出。

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();
        }
    }
}

接口实现多态

接口是一种规范，用于定义一组相关类的公共行为。它只包含方法的声明，没有具体的实现。派生类实现接口时必须提供接口中声明的方法的具体实现。通过接口可以实现多态性，使得不同的类可以被视为具有相同的行为。接口的使用可以增加代码的灵活性和可扩展性。接口不允许有访问修饰符，方法自动设置为自动属性。

这段代码展示了接口的概念以及接口的实现。

首先定义了一个接口Person，其中声明了一个方法Display()。接口是一种合同或契约，定义了一组行为或功能的规范，但没有具体的实现。接口中的方法只有方法签名，没有方法体。

然后定义了两个派生类Student和Teacher，它们都实现了接口Person。这意味着这两个派生类必须提供对接口中声明的方法Display()的具体实现。

在Main方法中，创建了一个接口类型的引用stu和tea，分别用派生类Student和Teacher的实例进行初始化。通过接口的引用，调用了实现了接口的方法Display()，分别输出了"定义学生"和"定义老师"。

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();
        }
    }
}
微软技术分享
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中类的继承
QWD8596的博客
10-18 5695
C#中类的继承 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术：C# 作者：吴锦华 撰写时间：2021/10/18 一、继承的概念 继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容 易。同时也有利于重用代码和节省开发时间。当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的 类，继承了已有的类的成员即可。
C#中的面向对象概念
03-03
原著：Tushar Kant Agrawal 12/24/2003原文：http://www.c-sharpcorner.com/Code/2003/Dec/OOPS In CSharp 1.0.asp翻译：lover_P在这篇文章中我们将要讨论一些面向对象在C#中的具体实践的关键概念。...
C# 类的继承
qq_42607586的博客
02-23 1834
1.我们可能会在一些类中，写一些重复的成员，我们可以将这些重复的成员，单独的封装到一个类中，作为这些类的父亲；5.代码块:父类:Person;子类:student;3.子类继承了父亲，那么子类从父亲哪里继承过来了什么？（1）继承的单根性，一个子类只能有一个父类；4.问题：子类有没有继承父类的构造函数？
【C#基础详解】（十四）面向对象 继承
Y1RV1NG的博客
06-04 416
学习面向对象基础知识、面向过程和面向对象的区别、面向对象继承、里氏转换
C#的类和继承
weixin_66598341的博客
03-26 1000
本章简单介绍了类之间的继承，包括如何屏蔽和访问基类成员，虚方法和覆写方法之间的关系，类中构造函数的执行以及构造函数之间的相互调用的语法。
详解C#面相对象编程中的继承特性
12-31
继承用于创建可重用、扩展和修改在其他类中定义的行为的新类。其成员被继承的类称为“基类”，继承这些成员的类称为“派生类”。派生类只能有一个直接基类。但是，继承是可传递的。如果 ClassB 派生出 ClassC，...
C# 继承
01-03
继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。 当创建一个类时，程序员不需要完全重新编写新的...
C#子类对基类方法的继承、重写与隐藏详解
12-17
提起子类、基类和方法继承这些概念，肯定大家都非常熟悉。毕竟，作为一门支持OOP的语言，掌握子类、基类是学习C#的基础。不过，这些概念虽然简单，但是也有一些初学者可能会遇到的坑，我们一起看看吧。 子类继承基类...
C#中的Task：异步编程的瑞士军刀
qq_35320456的博客
04-19 1562
C#中的Task：异步编程的瑞士军刀
C#语法知识之循环语句
AMrss的博客
04-20 472
5、循环语句。
学生选课及成绩查询管理系统的设计与开发C#(winform + sqlserver)
小张微说的博客
04-22 1922
源码来自网络 技术栈： C#的窗体程序开发 本系统未采用C#实现MDI——多文档窗口，因为考虑到C#的该技术与java类似，而暑期java实训时，曾用过类似的方法做过停车场管理系统，所以想为这次的系统注入一点新鲜的血液，所以本系统设计的主题采用了了C#的C#TreeView 实现。 Sql server数据库 关注公众号【DotNet微说】，发送：学生选课及成绩查询管理系统，便可获取源码。 个人微信：iotzzh 公众号：DotNet微说 个人网站：www.iotzzh.com 登录界面 管理员主页
C# Lazy
大黄鸭在发光的专栏
04-20 229
在 C# 中，Lazy<T>类型用于支持延迟初始化。延迟初始化是一种优化策略，它允许推迟创建对象或执行某些昂贵计算的过程，直到实际需要其值的时刻。这有助于提高应用程序的启动速度和运行效率，特别是在处理资源密集型对象时。以下是关于Lazy<T>
在 VSCode 中运行 C#
明明明的博客
04-23 521
在 VSCode 中运行 C#
windows驱动开发-I/O请求(一)
最新发布
m0_72813396的博客
04-23 765
IRP结构定义介绍
C# 中的 null 类型详解与在使用null类型时，有哪些常见陷阱需要避免？
qq_35320456的博客
04-23 793
在 C# 中，null 是一个特殊的值，表示引用类型的空值。对于值类型（例如 int、float、double 等），null 不是一个有效的赋值，因为值类型不能为 null。只有引用类型（例如类、接口、数组等）才能被赋值为 null。null 是一个只读的静态成员，它在程序中的所有部分都是相同的。null.Value 是一个编译时常量，它的值为 null。
C# 6.0+JavaScript云LIS系统源码 云LIS实验室信息管理新型解决方案
zmm201453的博客
04-22 660
云LIS是为区域医疗提供临床实验室信息服务的计算机应用程序，可协助区域内所有临床实验室相互协调并完成日常检验工作，对区域内的检验数据进行集中管理和共享，通过对质量控制的管理，最终实现区域内检验结果互认。其目标是以医疗服务机构为主体，以医疗资源和检验信息共享为目标，集成共性技术及医疗服务关键技术，建立区域协同检验，最大化利用有限的医疗卫生资源。
C# 异步编程
3000bookworm
04-23 378
Task。
‘language‘不能作为表名或字段名
bcbobo21cn的专栏
04-20 213
language是一些数据库的保留关键字，不能用作字段名或表名；
C#中的继承，封装和多态
07-13
在C#中，继承（inheritance），封装（encapsulation）和多态（polymorphism）是面向对象编程的基本概念。 继承是指一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。子类可以通过继承来重用父类的代码，并且可以添加新的属性和方法。继承使用冒号（:）来表示，子类可以继承单个父类，但C#不支持多继承。 例如，如果有一个Animal类作为父类，可以创建一个Dog类作为子类来继承Animal类的属性和方法。这样，Dog类可以访问Animal类中定义的公共成员。 封装是将数据和方法封装在一个类中，并对外部代码隐藏实现的细节。封装通过访问修饰符（如public、private、protected等）来控制对类成员的访问权限。公共成员可以被外部代码访问，而私有成员只能在类内部访问。 例如，可以创建一个Car类，并将其内部的引擎细节封装起来。外部代码只能通过公共方法来操作Car对象，而无法直接访问引擎的细节。 多态是指一个对象可以被当作多种类型来使用。多态性允许使用基类类型的引用来引用派生类的对象。这样可以提高代码的灵活性和可扩展性。 例如，有一个Shape类作为基类，定义了一个名为Draw的方法。可以创建Circle类和Rectangle类作为Shape类的子类，并分别重写Draw方法。然后，可以使用Shape类型的引用来引用Circle或Rectangle对象，并调用Draw方法，根据具体对象的类型来执行不同的绘制操作。 这就是C#中的继承，封装和多态的基本概念。它们是面向对象编程中重要的概念，用于构建灵活、可扩展和易于维护的代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值