C#基础之面向对象编程（二）

已于 2023-04-06 10:55:04 修改
阅读量540 收藏 4
点赞数 1
分类专栏： C# 文章标签： c# 开发语言
于 2023-03-10 23:48:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39847278/article/details/129436890
版权

总目录

文章目录

前言

本文主要用于供自身复习使用，上篇文章首先回顾了C#中的数据类型，数据转换以及数据之间进行运算的运算符，然后回顾了基本的流程控制语句if else,switch for,while等，最后还回顾了数组，枚举，结构体，类，接口，抽象类等基本的数据结构，本文将从面向对象编程的角度进一步的回顾相关知识。

一、概述

1. 定义

把现实世界中的对象使用代码的形式表现出来

2. 面向对象的三大特性

  • 封装 - 体现了代码的可维护性
  • 继承 - 体现了代码的可扩展性
  • 多态 - 体现了代码的灵活性

题外话：面向对象的编程，那么什么是对象呢？一般都会说，一切事物都是对象，但是这种答案是对也不对！
找到一个相对具体的说法是这样的：编程的本质呢？其实大部分都在与数据打交道，不是在存储数据，就是围绕数据做延申的功能，那么可以这么理解对象，对象就像是个“盒子容器”，用来存放数据和功能， 也就是数据和功能的集合。

二、封装

1. 定义

  • 封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。
  • 在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。
  • 通俗说法：使用class，将变量和方法，包装到一个独立的程序单元中，一旦封装后，变量称之为属性，方法称为行为

2. 属性

变量封装到类中，分为两种形式：
字段：变量的声明，使用_标识
属性：使用get 和set 进行包装，一般首字母大写，符合驼峰命名规则

代码如下（示例）：

    class UserInfo
    {
        private string _id;
        public string Id
        {
            get { return _id; }
            set { _id = value; }
        }
    }

关于get 和set 的理解如下：

 		private int _id;
        public int Id
        {
            get//返回给外界的值，供外界调用读取的值 　
            {
                if (_id < 0)//如果内部逻辑得出的_id<0，则同一返回0
                {
                    _id = 0;
                }
                return _id; 
            }
            set//供给外界设置的窗口，如果设置为private,外界将无法为该属性赋值，为只读属性
            {
                if (value>999)//value 即是外界赋予的值，可以通过set来处理外界的值
                {
                    _id = 999;//如果外界赋予的值大于999，则统一修正为999
                }
                _id = value;
            }
        }

三、继承

1. 定义

  • 一个类通过申明沿用另一个类中，非私有的属性和行为。
  • 被继承的类称之为 基类或父类，继承类称之为 派生类或子类

继承的可扩展性体现在：继承的时候，子类不仅沿用父类中非私有的属性和行为，还可增加自己特有的内容，另外通过重写和重载，同样实现了内容的扩展

注意 : 继承的时候，一个类只能有一个父类

2. 继承的使用

继承我们通过冒号（:）表示，表现形式如下：

class Shape
   {
      public void setWidth(int w)
      {
         width = w;
      }
      public void setHeight(int h)
      {
         height = h;
      }
      protected int width;
      protected int height;
   }

   // 派生类
   class Rectangle: Shape
   {
   	  //通过 Rectangle: Shape 的形式表示：Rectangle继承自Shape 
   	  //由于Rectangle继承自Shape,就有了Shape中非私有的width和height变量以及setWidth和setHeight
      public int getArea()
      {
         return (width * height);
      }
   }
   
   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle Rect = new Rectangle();

         Rect.setWidth(5);
         Rect.setHeight(7);

         // 打印对象的面积
         Console.WriteLine("总面积： {0}",  Rect.getArea());
         Console.ReadKey();
      }
   }

3. base 和this

  • 一般当前类使用this，子类使用父类的使用base
  • 构造函数时不可继承的 ，只能去调用；因此子类使用父类的构造函数的时候，需要使用base

在这里插入图片描述

  • 子类继承了父类的非私有的属性和行为，因此子类使用父类的非私有属性和行为的时候使用this
  • 子类调用父类的方法，可使用base,也可使用this。主要是使用base的时候我们知道去父类找该方法，指向更明确
  • 大多情况下，都省略的this和base关键字

四、多态

1. 定义

  • 在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。
    多态就是同一个接口，使用不同的实例而执行不同操作，如图所示
    在这里插入图片描述

2. 重写和重载

重写：在子类中重新编写父类方法

重写具有相同的方法名、参数列表以及返回值

重写的方式有如下两种：

  • 使用new 重写（也称覆盖）
  • 使用vitual 和override 重写
    class Animal
    {
        public void Eat()
        {
            Console.WriteLine("吃");
        }

        //定义虚方法，需子类重新，另外abstract 自带virtual属性
        public virtual void Action()
        {
            Console.WriteLine("行动");
        }
    }

    class Monkey:Animal
    {
        //通过new 重写父类的方法
        public new void Eat()
        {
            Console.WriteLine("猴子吃香蕉");
        }

        //通过override重写
        public override void Action()
        {
            base.Action();//重写后，可以通过base调出父类的原方法执行，也可不调用，重新实现
            Console.WriteLine("猴子上树");
        }
    }

重载：就是在同一个类中有多个同名方法，但是方法的参数列表不同

重载可以实现一种方法的多种实现方式，有利于程序的扩展。

    class Animal
    {
        public void Eat()
        {
            Console.WriteLine("吃");
        }

        public void Eat(string food)
        {
            Console.WriteLine($"吃{food}");
        }

        public void Eat(int num,string food)
        {
            Console.WriteLine($"一天吃{num}次{food}");
        }

        public int Eat(string name ,int num,string food)
        {
            Console.WriteLine($"{name}一天吃{num}次{food}");
            //如猴子一天吃三次香蕉，（假如一次2根），返回一天总量
            return num * 2 ;
        }
    }

3. 多态性的实现

  • 多态性可以是静态的或动态的。
  • 在静态多态性中，函数的响应是在编译时发生的。
  • 在动态多态性中，函数的响应是在运行时发生的。
  • 多态是建立在封装和继承的基础上的

1、静态多态性

静态多态性通过函数（方法）重载和运算符重载实现。
函数重载上面已经介绍了，这里介绍以下运算符的重载。

C# 允许用户定义的类型通过使用 operator 关键字定义静态成员函数来重载运算符。
注意必须用public修饰且必须是类的静态的方法。

运算符的重载可为用户自定义的对象实现运算。

运算符重载的使用案例如下：

    class Rect
    {
        public double Width { get; set; }
        public double Length { get; set; }

        public static Rect operator+(Rect a,Rect b)
        {
            Rect rect = new Rect();
            rect.Width = a.Width + b.Width;
            rect.Length = a.Length + b.Length;
            return rect;
        }

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

    class Program
    {
        static void Main(string[] args)
        {
            Rect RectA = new Rect() { Width=2.5,Length=4};
            Rect RectB = new Rect() { Width=3.5,Length=6};
            Console.WriteLine($"RectA的面积{RectA.GetArea()}");
            Console.WriteLine($"RectB的面积{RectB.GetArea()}");

            //如果没有通过operator+ 进行重载，RecA是无法和RecB进行相加的操作的
            Rect RectC = RectA+RectB;
            Console.WriteLine($"RectC的面积{RectC.GetArea()}");

            Console.ReadLine();
        }
    }

下图罗列了可重载和不可重载的运算符
在这里插入图片描述
这里解释以下成对重载，也就是说，如果我们重载了==，那么就必须连同 != 一起重载

详细使用如下：

    class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student(15, "小栗子");
            var student1 = student + 3;
            var student2 = student + "新手小白";
            Console.WriteLine(student1.ToString());//年龄 = 18,名称 = 小栗子

            Console.WriteLine(student2.ToString());//年龄 = 15,名称 = 新手小白小栗子

            Student stu1 = new Student(12, "小张子");
            Student stu2 = new Student(18, "小王五");
            var stu3 = stu1 - stu2;
            Console.WriteLine(stu3.ToString()); //年龄 = 6,名称 = 小张子和小王五
            Console.ReadLine();
        }
    }

    public class Student
    {
        public int Age { get; set; }
        public string Name { get; set; }

        public Student()
        { }

        public Student(int age, string name)
        {
            this.Age = age;
            this.Name = name;
        }
        # 形如 public static Student operator +(int c1, int c2) 是会报错的
        # 因为这样，就与需要操作的Student类毫无关联！
        # 二元运算符的参数之一必须是包含类型(参数c1、c2中有一个类型为Student即可).
        
        //+重载 ，操作年龄
        public static Student operator +(Student stu, int c2)
        {
            return new Student(stu.Age + c2, stu.Name);
        }
        //+重载 ，增加姓名前缀
        public static Student operator +(Student stu, string prefix)
        {
            return new Student(stu.Age, prefix+stu.Name); 
        }

        //重载运算符"-"，计算两个学生的年龄差.
        public static Student operator -(Student a, Student b)
        {
            return new Student(Math.Abs(a.Age - b.Age), $"{a.Name}和{b.Name}");
        }

        //重写ToString方法，格式化输出
        public override string ToString()
        {
            return $"年龄={Age},名称={Name}";
        }
    }

2、动态多态性

动态多态性是通过 抽象类、接口 和 虚方法 实现的。

  • 抽象类 和 接口 综合案例如下：
    abstract class Animal
    {
       public abstract void Run();//abstract 自带virtual属性
    }

    interface IFly//接口默认public,通常接口命名以 I 开头
    {
        void Fly();//飞翔这项功能作为一个接口，并不是所有动物都可以的
    }

    class Monkey : Animal
    {
        public override void Run()
        {
            Console.WriteLine("猴子在奔跑！");
        }
    }

    class Pig : Animal
    {
        public override void Run()
        {
            Console.WriteLine("小猪在狂奔！");
        }
    }
    //同一个方法（“接口”）Run，在不同的实例中有不同的实现就是多态的一种体现


    # 这里需要注意：当一个子类同时继承抽象类，类，和接口的时候，抽象类，类必须排在接口前面

    class Brid : Animal, IFly
    {
        public void Fly()
        {
            Console.WriteLine("奋飞的小鸟！");
        }

        public override void Run()
        {
            Console.WriteLine("愤怒的小鸡在奔跑！");
        }
    }
  • 虚方法
    class Worker
    {
        public virtual void DoWork()
        {
            Console.WriteLine("做工作！");
        }
    }

    class WorkerA : Worker
    {
        public override void DoWork()
        {
            base.DoWork();
            Console.WriteLine("编写项目ppt");
        }
    }

4. 向上转型和向下转型

1、定义

  • 向上转型：将子类对象转为父类对象。此处父类对象可以是接口，抽象类。
  • 向下转型：把父类对象转为子类对象。
  • 向上转型和向下转型 就是针对同一个继承链中的两个类型的相互转换

2、语法格式

  • 向上转型格式：父类类型 上转型变量 = new 子类类型（）；
  • 向下转型格式：子类类型 下转型变量 = （子类类型）父类类型变量；

3、案例

    class Worker
    {
        public virtual void DoWork()
        {
            Console.WriteLine("做工作！");
        }
    }

    class WorkerA : Worker
    {
        public override void DoWork()
        {
            base.DoWork();
            Console.WriteLine("编写项目ppt");
        }

        public void Avocation()
        {
            Console.WriteLine("WorkA的业余爱好");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //向上转型
            Worker worker= new WorkerA();
            worker.DoWork();
            /*  输出：
                做工作！
                编写项目ppt
             */

            //worker.Avocation();
            //注意这里会报错：因为上转型变量是不可调用 子类中扩展的方法的，只能调用两者共有的方法


            //向下转型
            //这种情况是不合理的，因为相当于用父类替换子类，然而子类会有扩展，不可能完全替换
            //Worker wo = new Worker();
            //WorkerA wa = (WorkerA)wo;

            Worker wo = new WorkerA();
            WorkerA wa = (WorkerA)wo;
            wa.Avocation();//这样是可行的，因为自始至终实例都是WorkA
            wo.DoWork();

            /*
             WorkA的业余爱好
             做工作！
             编写项目ppt
             */
            Console.ReadLine();
        }
    }

结语

以上就是本文的内容，希望以上内容可以帮助到您，如文中有不对之处，还请批评指正。

参考资料：
C# 运算符重载
菜鸟教程-C# 运算符重载

鲤籽鲲
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C# 学习笔记 ③】C#面向对象编程（基础概念、静态成员、继承、多态 =＞ 虚方法、接口、抽象类及它们的区别）
一个努力学习的程序猿
09-05 491
C#面向对象编程的相关基础概念，静态成员，继承、多态 => 虚方法、接口、抽象类及它们的区别。
【C#基础】C# 面向对象编程
好学若饥，谦卑若愚。
02-24 2628
编程语言 C# 面向对象编程知识点介绍。
C# 面向对象编程(OOP)
zls365365的博客
05-10 1135
这节讲一下，什么是面向对象(Object Oriented Programming)。说面向对象之前，我们不得不提的是面向过程（Process Oriented Programming），C语言就是面向过程的语言，这两者的区别在哪呢？我们可以设想一个情景——厨房做菜：以面向过程的形式解释来说，第一步：准备材料，第二步：起火，第三步：炒菜，第四步：上菜；面向...
C#编程入门基础，开启你的编程之旅
热门推荐
m0_61490399的博客
07-01 14万+
C#使得C++程序员可以高效的开发程序，且因可调用由 C/C++ 编写的本机原生函数，而绝不损失C/C++原有的强大的功能。因为这种继承关系，C#与C/C++具有极大的相似性，熟悉类似语言的开发者可以很快的转向C#。 ................................................................................................
C# 面向对象
江江的博客
06-11 3046
/ 缴款 bool Withdraw(decimal amount);// 提，取（银行账户中的钱款） decimal Balance {get;} // 账户余额 } public class SaverAccount : IBankAccount {// 缴款 public bool Withdraw(decimal amount) // 提，取（银行账户中的钱款） {// 体现尝试失败 return false;
C#面向对象编程思维导图
Full_Speed_Turbo
02-07 2523
2018.2.7
C#教程8：面向对象编程【01】
gongdiwudu的专栏
03-20 3102
面向对象编程 (OOP) 是一种编程范式，它使用对象及其交互来设计应用程序和计算机程序。OOP中有一些基本的编程概念：Abstraction 抽象、Polymorphism 多态、Encapsulation 封装、Inheritance 继承
Unity开发之C#基础-面向对象的基本概念
想吃烤地瓜的博客
04-27 1574
前言 今天我们将讲解到的程序中的一种编程思想：面向对象编程 制作不易还请各位一键三连哦！ 文章目录前言什么是面向对象？面向对象的优点？面向对象的基本概念面向对象的基本特征类的概念 什么是面向对象？ 面向对象工程是一种新兴的程序设计方法，或者是一种新的程序设计规范，其基本思想 是使用对象、类、封装、继承、消息等概念来进行程序设计 面向对象的优点？ 从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造尽可能 运用人类的自然思维方式。 面向对象的基本概念 在生活中，我们身边的每一个事物都可以当作
C#面向对象高级编程语言
m0_72572822的博客
10-01 1524
C#
C#面向对象、面向过程（一）
何明洋的编程技术博客
03-14 2582
1、C#面向过程（强调人的思想） 1.1面向过程：面向的是完成这件事的过程，强调的是完成这件事的动作。 例如：把大象塞进冰箱里 （1）打开冰箱门 （2）把大象塞进去 （3）关闭冰箱门 1.2如果我们用面向过程的方式处理这件事，当执行人不同时。 我们需要为每个不同的人量身定做解决这件事。 例一：孙权 瘦小 矮 屌丝 ...
C#面向对象编程基础概念汇总
08-26
今天小编就为大家分享一篇关于C#面向对象编程基础概念汇总的文章，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C#中面向对象编程机制之多态学习笔记
09-03
主要介绍了C#中面向对象编程机制之多态学习笔记,本文总结了个人对多态的理解以及接口多态、继承多态等内容,并给出了代码示例,需要的朋友可以参考下
C#面向对象编程之猜拳游戏实现方法
02-18
主要介绍了C#面向对象编程之猜拳游戏实现方法,以一个完整的猜拳游戏为例讲述了C#面向对象程序设计的具体实现步骤,具有一定的学习与借鉴价值,需要的朋友可以参考下
c#面向对象编程的小案例 c#经典案例.pdf
05-07
c#面向对象编程的小案例 c#经典案例.pdf
JavaScript的综合案例
luosuss的博客
05-14 444
实现一个表单验证。
【c#】IEnumerator 和 yield
最新发布
qq_22849251的博客
05-17 211
迭代器是一个可以逐个访问集合中元素的方法或属性。在C#中，实现迭代器的常见方法是通过实现IEnumerable和IEnumerator接口。然而，这种方法可能会涉及大量的样板代码来维护状态和位置。
c#多态性的应用
m0_51648467的博客
05-14 259
继承和多态性是开发复杂软件的关键技术，特别适合于分层软 件系统。操作系统可以设计一个抽象基类，提供 Read()和 Write()两个抽象函数，各种硬件的驱动程序被编写为该抽象基类的 派生类，具体实现Read()和Write()操作。设计一个电脑游戏，游戏中有猪、牛、兔子、青蛙、鸭子等动物，这些动 物都继承于Vertebrata 类（脊椎动物类），Vertebrata类有一个抽象方法Display()，每个动 物都从Vertebrata 类那里继承并重写了Display()方法，用来把动物本身画在屏幕上。
C#上位机1ms级高精度定时任务
anlog的专栏
05-10 476
【免费】c#高精度毫秒定时器，实现windows高精度定时器功能资源-CSDN文库。高精度定时器的使用以及实现_c# precisiontimer-CSDN博客。C#上位机1ms级高精度定时任务讲解_哔哩哔哩_bilibili。2024年5月10日。
C#贪吃蛇
AMrss的博客
05-09 625
C#贪吃蛇。
C# 面向对象 传智
09-14
他们的C#培训课程涵盖了面向对象编程的基础知识、语法和实践技巧，帮助学员掌握C#语言的使用和面向对象编程的思想。 如果你对C#和面向对象编程有兴趣，可以考虑参加传智播客的相关培训课程，他们提供系统化的教学，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值