C#（面向对象）

最新推荐文章于 2024-04-20 10:34:50 发布
最新推荐文章于 2024-04-20 10:34:50 发布
阅读量3.4k 收藏 49
点赞数 4
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ye_liang_chen/article/details/120514812
版权

C#（面向对象）

一、面向对象

1.概念

​ 类可以派生形成子类（派生类），派生子类的类称为父类。对应一个系统最基本的类称为基类，一个基类可以有多个派生类，从基类派生出的类（子类）还可以进行派生。

​ 对象是类的具体化，是具有属性和方法的实体（实例）。对象通过唯一的标识名以区别于其他对象，对象有固定的对外接口，它是对象与外界通信的通道。

2.对象、类与实例化

​ 对象是类的具体化，是具有属性和方法的实体（实例）。对象通过唯一的标识名以区别于其他对象，对象有固定的对外接口，它是对象与外界通信的通道。

image-20210927160153864

二、面向对象程序设计三原则

1.封装

​ 所谓“封装”，就是用一个框架把数据和代码组合在一起，形成一个对象。遵循面向对象数据抽象的要求，一般数据都被封装起来，外部不能直接访问对象的数据，只能说明对象提供的公共方法（也称接口，是对象之间联系的渠道）。在 C#中，类是支持对象封装的工具，对象则是封装的基本单元。

​ 封装的对象之间进行通信的一种机制叫作消息传递。消息是向对象发出的服务请求，是对象之间交互的途径。消息包含要求接收对象去执行某些活动的信息，以及完成要求所需的其他信息（参数）。发送消息的对象不需要知道接收消息的对象如何对请求予以响应，接收者接收到消息，它就承担了执行指定动作的责任，作为消息的答复，接收者将执行某个方法来满足所接收的请求。

2.继承

​ 继承是面向对象编程技术的一块基石，通过它可以创建分等级层次的类。例如，创建一个汽车的通用类，它定义了汽车的一般属性（如车轮、方向盘、发动机、车门）和操作方法（如前进、倒退、刹车、转弯等）。这个已有的类可以通过继承的方法派生出新的子类，如卡车、轿车、客车等，它们都是汽车类中更具体的类，每个具体的类还可增加自己的一些特有的属性，如图3.2所示，更一般的表示如图3.3所示。

image-20210927161522792

image-20210927161644282

​ 如果一个类有两个或两个以上的直接基类，这样的继承结构就称为多重继承或多继承。现实中这种模型屡见不鲜，如一些类似于沙发床的组合功能的产品，它既有沙发的功能，又有床的功能，沙发床应允许同时继承沙发和床的特征，如图3.4所示，更一般的表示如图3.5所示。

image-20210927161728067

image-20210927161731636

​ 目前很多编程语言已不再支持多继承，C#也对多继承的使用进行了限制，规定通过接口来实现多继承。接口可以从多个基接口继承，可以包含方法、属性、事件和索引器。一个典型的接口就是一个方法声明的列表，接口本身不提供它所定义的成员的实现，故不能被实例化，而是由实现接口的类以适当的方式定义接口中声明的方法，如图3.6所示。

image-20210927161744989

3.多态

​ 多态就其字面意思是：多种形式或多种形态。在面向对象编程中，多态是指同一个消息或操作在作用于不同的对象时，可以有不同的反应，产生不同的执行结果。例如，问甲同学：“现在几点钟？”甲回答说：“3 点 15 分。”又问乙同学：“现在几点钟？”乙回答说：“大概3点多钟。”再问丙同学：“现在几点钟？”丙回答说：“不知道。”这就是同一个消息发送给不同的对象，不同的对象可以作出不同的反应的例子。

​ 多态分两种：静态多态和动态多态。当在同一个类中直接调用一个对象的方法的时候，系统在编译时，根据传递的参数个数、类型及返回值类型等信息决定实现何种操作，这就是所谓的静态多态（静态绑定）。而当在一个有着继承关系的类层次结构中间接调用一个对象的方法的时候，调用要经过基类的操作，只有到系统运行时，才能根据实际情况决定实现何种操作，这就是动态多态（动态绑定）。C#同时支持这两种多态，在实现方式上可以有三种方式：接口多态、继承多态、通过抽象类实现的多态。

三、类的封装与继承

1.属性封装

​ C#提供了属性（property）这个更好的方法，把字段域和访问它们的方法相结合。对类的用户而言，属性值的读/写与字段域语法相同；对编译器来说，属性值的读/写是通过类中封装的特别方法get访问器和set访问器实现的。

属性的声明方法如下：

 [属性集信息]   [属性修饰符]  类型 成员名 
{
	访问器声明
}

其中：

v 属性修饰符—与方法修饰符相同，包括 new、static、virtual、abstract、override 和 4种访问修饰符的合法组合，它们遵循相同的规则。

v 类型—指定该声明所引入的属性的类型。

v 成员名—指定该属性的名称。

v 访问器声明——声明属性的访问器，可以是一个 get 访问器或一个 set 访问器，或者两个都有。

语法形式：

get   			// 读访问器
{
	…		// 访问器语句块
}
set   			// 写访问器
{
	…		// 访问器语句块
}

​ get 访问器的返回值类型与属性的类型相同，所以在语句块中的 return 语句必须有一个可隐式转换为属性类型的表达式。

​ set 访问器没有返回值，但它有一个隐式的值参数，其名称为 value，它的类型与属性的类型相同。

​ 同时包含 get 和 set 访问器的属性是读/写属性，只包含 get 访问器的属性是只读属性，只包含 set 访问器的属性是只写属性。

【例3.1】 对TextBox类的text、fontname、fontsize、multiline域提供[属性方式的读](【例3.1】 对TextBox类的text.txt)[/](【例3.1】 对TextBox类的text.txt)[写访问。](【例3.1】 对TextBox类的text.txt)

using System;
namespace Ex3_1
{
    class TextBox
    {
        private string text;
        private string fontname;
        private int fontsize;
        private bool multiline;
        public TextBox()
        {
            text = "text1";
            fontname = "宋体";
            fontsize = 12;
            multiline = false;
        }
        public string Text
        {
            // Text属性，可读可写
            get
            { return text; }
            set
            { text = value; }
        }
        public string FontName
        {
            // FontName属性，只读属性
            get
            { return fontname; }
        }
        public int FontSize
        {    
            // FontSize属性，可读可写
            get
            { return fontsize; }
            set
            { fontsize = value; }
        }
        public bool MultiLine
        {
            // MultiLine属性，只写
            set
            { multiline = value; }
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            TextBox Text1 = new TextBox();
            // 调用Text属性的get访问器
            Console.WriteLine("Text1.Text= {0} ", Text1.Text);
            // 调用Text属性的set访问器
            Text1.Text = "这是文本框";
            Console.WriteLine("Text1.Text= {0} ", Text1.Text);
            // 调用FontName属性的get访问器
            Console.WriteLine("Text1.Fontname= {0} ", Text1.FontName);
            // 调用FontSize属性的set访问器
            Text1.FontSize = 36;
            // 调用FontSize属性的get访问器
            Console.WriteLine("Text1.FontSize= {0} ", Text1.FontSize);
            // 调用MultiLine属性的set访问器
            Text1.MultiLine = true;
            Console.Read();
        }
    }
}

程序运行结果如图3.7所示。

image-20210927162200392

​ 在这个示例中，类TextBox定义了4个属性，在类体外使用这些属性是用 Text1.*的形式，这与字段域的访问非常类似。编译器根据它们出现的位置调用不同的访问器。如果在表达式中引用该属性则调用 get 访问器，若给属性赋值则调用set访问器，赋值号右边的表达式值传给value。

属性是字段的自然扩展，当然属性也可作为特殊的方法使用，并不要求它和字段域一一对应，所以属性还可以用于各种控制和计算。

【例3.2】 定义 Label类，设置 Width 和 Heigh属性，分别存放两点之间在水平坐标轴和垂直[坐标轴上的投影长度](【例3.2】 定义 Label类.txt)[。](【例3.2】 定义 Label类.txt)

using System;
namespace Ex3_2
{
    class Point
    {
        int x, y;
        public int X
        {
            get
            {	return x;	}
        }
        public int Y
        {
            get
            {	return y;	}
        }
        public Point ( )
        { 	x=y=0;	}
        public Point (int x, int y)
        {
            this.x=x;
            this.y=y;
        }
    }
    class Label
    {
        Point p1=new Point ( );
        Point p2=new Point (5, 10);
        public int Width			// 计算两点之间在水平坐标轴上的投影长度
        {
            get
            {
                return p2.X-p1.X;
            }
        }
        public int Height			// 计算两点之间在垂直坐标轴上的投影长度
        {
            get
            {
                return p2.Y-p1.Y;
            }
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            Label Label1 = new Label();
            Console.WriteLine("Label1.Width= {0} ", Label1.Width);
            Console.WriteLine("Label1.Height= {0} ", Label1.Height);
            Console.Read();
        }
    }
}

image-20210927162243742

2.类的继承

1.引例

图3.9是采用类的层次图表示继承的例子。

下面用程序实现图3.9所示的类的层次结构。

image-20210927162444456

【例3.3】 类的继承

using System;
namespace Ex3_3
{
    // 定义基类Shape
    public class Shape
    {
        protected string Color;
        public Shape(){ ;}
        public Shape(string Color)
        {
            this.Color = Color;
        }
        public string GetColor()
        {
            return Color;
        }
    }
    // 定义Circle类，从Shape类中派生
    public class Circle : Shape
    {
        private double Radius;
        public Circle(string Color, double Radius)
        {
            this.Color = Color;
            this.Radius = Radius;
        }
        public double GetArea()
        {
            return System.Math.PI * Radius * Radius;
        }
    }
    // 派生类Rectangular，从Shape类中派生
    public class Rectangular : Shape
    {
        protected double Length, Width;
        public Rectangular()
        {
            Length = Width = 0;
        }
        public Rectangular(string Color, double Length, double Width)
        {
            this.Color = Color;
            this.Length = Length;
            this.Width = Width;
        }
        public double AreaIs()
        {
            return Length * Width;
        }
        public double PerimeterIs()         // 周长
        {
            return (2 * (Length + Width));
        }
    }
    // 派生类Square，从 Rectangular类中派生
    public class Square : Rectangular
    {
        public Square(string Color, double Side)
        {
            this.Color = Color;
            this.Length = this.Width = Side;
        }
    }
    class TestInheritance
    {
        static void Main(string[] args)
        {
            Circle Cir = new Circle("orange", 3.0);
            Console.WriteLine("Circle color is {0},Circle area is {1}", Cir.GetColor(), Cir.GetArea());
            Rectangular Rect = new Rectangular("red", 13.0, 2.0);
            Console.WriteLine("Rectangualr color is {0},Rectangualr area is {1}, 
				Rectangular perimeter is {2}",Rect.GetColor(), Rect.AreaIs(), Rect.PerimeterIs());
            Square Squ = new Square("green", 5.0);
            Console.WriteLine("Square color is {0},Square Area is {1},
				Square perimeter is {2}", Squ.GetColor(),Squ.AreaIs(), Squ.PerimeterIs());
        }
    }
}

程序运行结果如图3.10所示。

image-20210927162643475

【例3.3】程序中的Square类也可改写成：

public class Square: Rectangular
{
	public Square(string Color,double Side):base(Color,Side,Side){ }
}

​ 关键字base的作用是调用Rectangular类的构造函数，并将Square类的变量初始化。

如果将Square类改写成：

public class Square: Rectangular
{
	public Square(string Color,double Side){ }
}

这种情况调用的就是父类的无参构造函数，而非有参构造函数，它等同于：

public class Square: Rectangular
{
	public Square(string Color,double Side):base(){ }
}

【例3.4】 [base](【例3.4】 base调用基类的方法.txt)[调用基类的方法。](【例3.4】 base调用基类的方法.txt)

​ 在上例中，Employee类的 GetInfoEmployee 方法使用了 base 关键字，调用基类 Person 的GetInfoPerson方法。

using System;

namespace Ex3_4
{
    public class Person
    {
        protected string Phone = "444-555-666";
        protected string Name = "李明";
        public void GetInfoPerson()
        {
            Console.WriteLine("Phone: {0}", Phone);
            Console.WriteLine("Name: {0}", Name);
        }
    }
    class Employee : Person
    {
        public string ID = "ABC567EFG";
        public void GetInfoEmployee()
        {
            // 调用基类Person的GetInfo方法 
            base.GetInfoPerson();
            Console.WriteLine("Employee ID: {0}", ID);
        }
    }
    class TestClass
    {
        static void Main(string[] args)
        {
            Employee Employees = new Employee();
            Employees.GetInfoEmployee();
        }
    }
}

程序运行结果如图3.11所示。

image-20210927170146793

3．System.Object类

​ C#中所有类都派生于 System.Object 类。在定义类时如果没有指定派生于哪一个类，系统就默认其派生于Object类。

于是，【例3.3】中Shape的定义就等同于：

public class Shape :System.Object
{
	//TODO…
}

System.Object类常见的公有方法是：

（1）Equals——若两个对象具有相同值，方法返回true。

（2）GetHashCode——方法返回对象值的散列码。

（3）ToString——通过在派生类中重写该方法，返回一个表示对象状态的字符串。

（4）GetType——根据内置对象类型指针获得当前对象的实际类型。

四、派生类的构造函数

​ 当创建派生类的对象时，会展开一个链式的构造函数调用，在这个过程中，派生类构造函数在执行它自己的函数体之前，首先显式或隐式地调用基类构造函数。类似地，如果这个基类也是从另一个类派生而来的，那么这个基类的构造函数在执行之前也会先调用它的基类构造函数，以此类推，直到Object类的构造函数被调用为止。

【例3.5】 [继承中函数的构造顺序。](【例3.5】 继承中函数的构造顺序.txt)

using System;
…
namespace Ex3_5
{
    public class Grandsire
    {
        public Grandsire()
        {
            Console.WriteLine("调用Grandsire的构造函数");
        }
    }
    public class Father : Grandsire
    {
        public Father()
        {
            Console.WriteLine("调用Father的构造函数"); 
        }
    }
    public class Son : Father
    {
        public Son()
        {
            Console.WriteLine("调用Son的构造函数"); 
        }
    }
    class BaseLifeSample
    {
        static void Main(string[] args)
        {
            Son s1 = new Son();
            Console.Read();
        }
    }
}

​ 上段代码中，C#的执行顺序是这样的：根据层次链找到最顶层的基类 Grandsire，先调用基类的构造函数，再依次调用各级派生类的构造函数，运行结果如图3.12所示。

image-20210927170333087

​ 下面程序描述了派生类构造函数的格式，以及在初始化对象时构造函数的调用次序。

【例3.6】 [派生类构造函数及其调用。](【例3.6】 派生类构造函数及其调用.txt)

using System;
namespace Ex3_6
{
    class Point
    {
        private int x, y;
        public Point()
        {
            x = 0; y = 0;
            Console.WriteLine("Point() constructor : {0} ", this);
        }
        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
            Console.WriteLine("Point(x,y) constructor : {0} ", this);
        }
    }
    class Circle : Point
    {
        private double radius;
        public Circle()     		// 默认约定调用基类的无参构造函数Point()
        {
            Console.WriteLine("Circle () constructor : {0} ", this);
        }
        public Circle(double radius): base()
        {
            this.radius = radius;
            Console.WriteLine("Circle (radius) constructor : {0} ", this);
        }
        public Circle(int x, int y, double radius): base(x, y)
        {
            this.radius = radius;
            Console.WriteLine("Circle (x, y, radius) constructor : {0} ", this);
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            Point a = new Point();
            Circle b = new Circle(3.5);
            Circle c = new Circle(1, 1, 4.8);
            Console.Read();
        }
    }
}

程序运行结果如图3.13所示。

image-20210927170445318

五、多态的实现

1.方法重载

一个方法的名字、形参个数、修饰符及类型共同构成了这个方法的签名，应用中经常需要为同名的方法提供不同的实现，如果一个类中有两个或两个以上的方法同名，但它们的形参个数或类型有所不同，这是允许的，这属于不同的方法签名。若仅仅是返回类型不同的同名方法，编译器是不能识别的。下面通过一个例子来介绍方法的重载。

【例3.7】 [不同版本的方法求最大值](【例3.7】 不同版本的方法求最大值.txt)[。](【例3.7】 不同版本的方法求最大值.txt)

using System;
namespace Ex3_7
{
    class Myclass              // 该类中有4个不同版本的max方法
    {
        public int max(int x, int y)
        {
            return x >= y ? x : y;
        }
        public double max(double x, double y)
        {
            return x >= y ? x : y;
        }
        public int max(int x, int y, int z)
        {
            return max(max(x, y), z);
        }
        public double max(double x, double y, double z)
        {
            return max(max(x, y), z);
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            Myclass m = new Myclass();
            int a, b, c;
            double e, f, g;
            a = 10; b = 20; c = 30;
            e = 1.5; f = 3.5; g = 5.5;
            // 调用方法时，编译器会根据实参的类型和个数调用不同的方法
            Console.WriteLine("max({0},{1})= {2} ", a, b, m.max(a, b));
            Console.WriteLine("max({0},{1},{2})= {3} ", a, b, c, m.max(a, b, c));
            Console.WriteLine("max({0},{1})= {2} ", e, f, m.max(e, f));
            Console.WriteLine("max({0},{1},{2})= {3} ", e, f, g, m.max(e, f, g));
            Console.Read();
        }
    }
}

程序运行结果如图3.14所示。

image-20210927171039155

2.运算符重载

​ 运算符重载包括一元运算符重载、二元运算符重载以及用户定义的数据类型转换，下面简单介绍前两种情况。

如果有一个复数Complex类对一元运算符“++”重载，可以写成：

public static Complex operator ++(Complex a)
{
	//TODO…
}

对二元运算符“+”可以写成：

public static Complex operator +(Complex a, Complex b)
{
	//TODO…
}

​ 一元运算符有一个参数，二元运算符有两个参数。重载运算符必须以 public static 修饰符开始。

可以重载的运算符包括：

v 一元运算符——+ - ! ~ ++ - - true false；

v 二元运算符——+ - * / % & | ^ << >> == != > < >= <=。

下面的运算符要求必须同时重载，不能只单独重载中间的一个：

v 一元运算符——true和false；

v 二元运算符——==和!=，>和<，>=和<=。

【例3.8】 运算符重载的实现。

using System;
namespace Ex3_8
{
    class Complex
    {
        double  r, v;  					//r+ v i
        public Complex(double r, double v)
        {
            this.r=r;
            this.v=v;
        }
        // 二元运算符“+”重载
        public static Complex operator +(Complex a, Complex b)
        {
            return new Complex(a.r+b.r, a.v+b.v);
        }
        // 一元运算符“-”重载
        public static Complex operator -(Complex a)
        {
            return new Complex(-a.r,-a.v);
        }
        // 一元运算符“++”重载
        public static Complex operator ++(Complex a)
        {
            double r=a.r+1;
            double v=a.v+1;
            return new Complex(r, v);
        }
        public void Print()
        {
            Console.Write(r+" + "+v+"i\n");
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
			Complex a=new Complex(3,4);
			Complex b=new Complex(5,6);
			Complex c=-a;
			c.Print();
			Complex d=a+b;
			d.Print();
			a.Print();
			Complex e=a++;          // 先赋值后++
			a.Print();
			e.Print();
			Complex f=++a;          // 先++后赋值
			a.Print();
			f.Print();
        }
    }
}

程序运行结果如图3.15所示。

image-20210927171251367

小叶在呢
关注
  • 4
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 面向对象的基本原则
01-21
C#面向对象的基本原则 一、面向接口编成而不是实现 [Code to an interface rather than to an implementation.] 二、优先使用组合而非继承 [Favor Composition Over Inheritance.] 三、SRP: The single ...
C#面向对象编程期末参考题
12-22
【标题】"C#面向对象编程期末参考题"揭示了本次讨论的核心——C#编程语言中的面向对象编程（Object-Oriented Programming, OOP）概念，这是软件开发中的一种重要方法论。C#是一种现代、类型安全且面向对象的语言，...
C#面向对象思想——最基础讲解（图文混合讲解）
蘇小白的博客
08-28 4724
一、面向对象是什么？ 二、面向对象有哪些内容？ 我们带着这两个问题来阅读这篇文章 OOP面向对象思想一、面向对象是什么？二、面向对象有哪些内容？1、封裝2、继承3、多态三级目录 一、面向对象是什么？ 先给大家看一张很有意思的图片，不知道是哪位大神所创，小蘇在此佩服佩服。 这张图片很清晰的讲解了面向对象编程中每一种方法的特点。当然了，这张图片就是给大家开开胃，细节咱们后面讲。 面向对象就是一种编码的思想，简称(oop思想)，这种编程思想可以让你在编码的过程中，对于类的使用变得更加的方便快捷，在不同的场.
【C#】面向对象、数据类型
山赶着山，山山漫漫结成关
07-25 297
看得见、摸得到、具体的、特指的对象是计算机程序中的一个实体，它可以是数据、函数、类、模块或其他类型的实体。它具有属性和方法，可以通过调用其方法来访问和修改其属性。在面向对象编程中，对象通常是由类创建的实例。每个对象都有自己的状态和行为，可以与其他对象进行交互。对象是面向对象编程中最基本的组成部分之一，它使得程序的设计更加模块化和灵活。
C# 面向对象编程(三)——接口/枚举类型/泛型
最新发布
记录知识点的博客
04-20 374
C# 面向对象编程(三)——接口/枚举类型/泛型
C#之面向对象
Cathy
02-18 676
一、对象：一切事物皆对象，对象是一个自包含的实体，用一组可识别的特细并和行为来标识。 二、类：就是具有相同属性和功能的抽象的集合。 实例化对象，就是创建一个正式的对象。 三、构造方法（函数）：对类进行初始化，构造方法和类同名，无返回值，也不需要void 注意：所有的类都有构造方法，系统默认一个空的构造方法 四、方法重载 方法重载提供了创建同名的多个方法的能力，但这些方法需要使用不同的参
C# 对象和类型
江江的博客
06-11 1123
在 C# 中，对象（Object）和类型（Type）是面向对象编程中的重要概念。对象是一个实际存在的实体，它具有特定的属性和行为。在 C# 中，所有的数据都是通过对象来表示和操作的。对象可以是事物的具体实例，也可以是抽象的概念或概念模型的实例。类型是对象的蓝图或模板，用于定义对象的结构和行为。每个对象都属于一个特定的类型，它决定了对象可以具有的属性和可以执行的操作。在 C# 中，类型可以是内置类型（如整数、浮点数等，在 C# 基础篇中有简单的介绍），也可以是自定义的类、结构体、接口或枚举。
C#教程8：面向对象编程【01】
gongdiwudu的专栏
03-20 3499
面向对象编程 (OOP) 是一种编程范式，它使用对象及其交互来设计应用程序和计算机程序。OOP中有一些基本的编程概念：Abstraction 抽象、Polymorphism 多态、Encapsulation 封装、Inheritance 继承
C#基础知识点总结（二）- 对象和类型
weixin_43152495的博客
10-17 434
C#对象和类 类和结构 类：字段属性方法构造函数只读成员只读字段 匿名类型 结构 按值和按引用传递参数: ref和out 可空类型 枚举 部分类 扩展方法 object类
c#面向对象编程的小案例 c#经典案例.pdf
05-07
"C#面向对象编程小案例：模拟彩票选号器" 本资源详细介绍了C#面向对象编程的小案例，模拟彩票选号器的实现。该案例主要使用C#语言，通过面向对象编程的思想，实现了一个彩票选号器的模拟。 知识点1：System.Random...
C#面向对象程序设计简单的计算器.zip
10-27
在本项目中，"C#面向对象程序设计简单的计算器.zip"是一个包含了一个基本的C#计算器应用程序的压缩包。这个程序展示了面向对象编程的基本概念，使用C#语言实现加法、减法、乘法和除法操作。让我们深入探讨一下其中...
C#面向对象编程 源码
04-15
本书以面向对象编程技术和.NET框架类库为主轴，透彻地介绍了C#的语法、编程思想和高级.NET框架编程技术。全书分为三部分，共22章，全面详细地解说了C#的技术要点，包括C#语言基础、C#的面向对象特征、异常处理、委托与事件、集合、泛型、字符串与正则表达式、特性、反射、程序集与版本控制、.NET框架的内存管理、多线程、Windows窗体、GDI+、与非托管代码互操作等，对每一个知识点都提供了典型实例。本书基于C#和.NET框架的最新版本而编写，介绍了C#的最新特色，包括泛型、匿名方法、迭代器、静态类、分部类型和可空类型等。本书既阐述了C#的基础知识，又介绍了C#的高级应用技术，包括多线程、异步调用、图形图像处理、游戏编程、与COM等非托管代码的互操作，以及插件编程等。 本书适合所有希望了解和掌握C#和.NET的开发人员阅读，是大专院校计算机相关专业和各类培训班的理想教学参考书。
C#面向对象讲解
10-13
实践是学习的最佳方式，尝试编写自己的类、对象、继承关系、多态实现以及接口，将有助于深化对C#面向对象的理解。同时，注释代码以解释各个部分的作用，也能帮助初学者更快地掌握面向对象编程的思想。
浅谈对c# 面向对象的理解
09-04
面向对象编程（Object-Oriented Programming，简称OOP）是C#编程语言的核心特性之一，它提供了一种高效且易于维护的代码组织方式。本文将深入探讨C#中的面向对象特性，包括对象、封装、继承和多态。 1. 对象的理解 ...
C#面向对象
10-05
【C#面向对象】 C#（读作"C sharp"）是一种由微软开发并标准化的通用、类型安全的、面向对象的编程语言。它主要用于构建Windows应用程序、Web应用程序以及移动应用程序等。C#的设计目标是提高代码的可靠性和可维护...
C# 面向对象-面向对象概述
Yu_yoyo的博客
10-27 3091
一、面向对象概述 什么是面向对象？面向对象其实就是在处理事物时，对事物的特征、行为进行概括、归纳、总结 抽象成一个类，然后在使用时由类再生成对象， 在编程时使用，这个过程就可以面向对象编程 面向过程编程：重点是在于解决问题的步骤、方法。 面向对象编程优势、特点：重用性、可扩展性好一些、可维护性强一些 面向过程编程 优势、特点正好相反 二、类和对象 类和对象在任何类型的项目中都可以使用 什么是类？ 类是具有共同特征和行为的一类事物的总称。 什么是对象？ 对象是某一个具体的事物。 三、对象的实例化及访问.
C#中类的对象、封装、继承和多态
wenchm的博客
07-06 1079
当重写父类方法时，修改方法的修饰权限只能从小的范围到大的范围改变，例如，父类中的doit()方法的修饰权限为protected，继承后子类中的方法doit()的修饰权限只能修改为public，不能修改为private。继承的基本思想是基于某个父类的扩展，制定出一个新的子类，子类可以继承父类原有的属性和方法，也可以增加原来父类所不具备的属性和方法，或者直接重写父类中的某些方法。C#是一门面向对象的程序设计语言，对象是由类抽象出来的，所有的问题都是通过对象来处理的，对象可以操作类的属性和方法解决相应的问题。
C#---面向对象编程（OOP）
renwen1579的博客
10-22 422
【千锋合集】史上最全Unity3D全套教程|匠心之作_哔哩哔哩_bilibili
C#面向对象教程：入门与实践
"面向对象编程是C#课程的核心内容，本资源提供了一份100%完整正版的C#面向对象课程资料，特别适合初学者入门。课程首先介绍了什么是面向对象，它是一种软件开发思想，通过模拟现实世界中的实体及其相互关系来组织...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值