2021-09-29

最新推荐文章于 2023-05-09 13:10:19 发布
最新推荐文章于 2023-05-09 13:10:19 发布
阅读量302 收藏 1
点赞数
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYLNB24/article/details/120550169
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

多态的实现

一、类的封装与继承

1.属性封装

C#提供了属性（property）这个更好的方法，把字段域和访问它们的方法相结合。对类的用户而言，属性值的读/写与字段域语法相同；对编译器来说，属性值的读/写是通过类中封装的特别方法get访问器和set访问器实现的。
属性的声明方法如下：
[属性集信息] [属性修饰符] 类型 成员名
{
访问器声明
}
其中：
 属性修饰符—与方法修饰符相同，包括 new、static、virtual、abstract、override 和 4种访问修饰符的合法组合，它们遵循相同的规则。
 类型—指定该声明所引入的属性的类型。
 成员名—指定该属性的名称。
 访问器声明——声明属性的访问器，可以是一个 get 访问器或一个 set 访问器，或者两个都有。
语法形式：
get // 读访问器
{
… // 访问器语句块
}
set // 写访问器
{
… // 访问器语句块
}
get 访问器的返回值类型与属性的类型相同，所以在语句块中的 return 语句必须有一个可隐式转换为属性类型的表达式。
set 访问器没有返回值，但它有一个隐式的值参数，其名称为 value，它的类型与属性的类型相同

using System;
namespace ConsoleApp3
{
    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();
        }
    }
}



属性是字段的自然扩展，当然属性也可作为特殊的方法使用，并不要求它和字段域一一对应，所以属性还可以用于各种控制和计算。
using System;
namespace ConsoleApp3
{
    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();
        }
    }
}

2.类的继承

代码如下（示例）：

using System;
namespace ConsoleApp3
{ // 定义基类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());
        }
    }
}




using System;
namespace ConsoleApp3
{ // 定义基类Shape
    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.派生类的构造函数

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

using System;
namespace ConsoleApp3
{
    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();
        }
    }
}



下面程序描述了派生类构造函数的格式，以及在初始化对象时构造函数的调用次序。
using System;
namespace ConsoleApp3
{
    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();
        }
    }
}

二、多态的实现

1.方法重载

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

using System;
namespace ConsoleApp3
{
    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();
        }
    }
}

2.运算符重载

运算符重载包括一元运算符重载、二元运算符重载以及用户定义的数据类型转换，下面简单介绍前两种情况。
如果有一个复数Complex类对一元运算符“++”重载，可以写成：
public static Complex operator ++(Complex a)
{
//TODO…
}
对二元运算符“+”可以写成：
public static Complex operator +(Complex a, Complex b)
{
//TODO…
}
一元运算符有一个参数，二元运算符有两个参数。重载运算符必须以 public static 修饰符开始。
可以重载的运算符包括：
 一元运算符——+  ! ~ ++   true false；
 二元运算符——+  * / % & | ^ << >> == != > < >= <=。

using System;
namespace ConsoleApp3
{
    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();
        }
    }
}

三、虚拟方与方法覆盖

1．继承中的方法隐藏及其局限

【例】 试用隐藏基类成员方法的方式，在运行时执行指定派生类方法的功能。
本例定义了一个基类 Shape，含有字段域 width 和 height，分别表示形状的宽和高，并定义了一个 area 方法，用来求形状的面积。它的派生类Triangle（三角形）和Trapezia（梯形）都用关键字new修饰了 area 方法，表明这是有意隐藏该方法的。若不加new修饰，为了警示，编译器会发出警告信息。

using System;
namespace ConsoleApp3
{
    class Shape
    {
        protected double width;
        protected double height;
        public Shape()
        { width = height = 0; }
        public Shape(double x)
        { width = height = x; }
        public Shape(double w, double h)
        {
            width = w;
            height = h;
        }
        public double area()
        { return width * height; }
    }
    class Triangle : Shape      		// 三角形
    {
        public Triangle(double x, double y) : base(x, y) { }
        new public double area()    	// 加new隐藏基类的area方法
        {
            return width * height / 2;
        }
    }
    class Trapezia : Shape   		// 梯形
    {
        double width2;
        public Trapezia(double w1, double w2, double h) : base(w1, h)
        {
            width2 = w2;
        }
        new public double area()		// 加new隐藏基类的area方法
        {
            return (width + width2) * height / 2;
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            Shape A = new Shape(2, 4);
            Triangle B = new Triangle(1, 2);
            Trapezia C = new Trapezia(2, 3, 4);
            Console.WriteLine("A.area= {0} ", A.area());   // 调Shape的area方法
            Console.WriteLine("B.area= {0} ", B.area());   // 调Triangle的area方法
            Console.WriteLine("C.area= {0} ", C.area());   // 调Trapezia的area方法
            A = B;
            Console.WriteLine("A.area= {0} ", A.area());   // 试图调Triangle的area方法失败
            A = C;
            Console.WriteLine("A.area= {0} ", A.area());   // 试图调Trapezia的area方法失败
            Console.Read();
        }
    }
}

上段代码本来是想分别调用 Triangle 的 area 方法计算三角形面积，调用 Trapezia 的 area 方法计算梯形面积，但程序执行的仍然是基类的 area 方法，只计算了抽象的“形状面积”：
A.area＝width * height＝1×2＝2≠width * height / 2
A.area＝width * height＝2×4＝8≠(width + width2) * height / 2

2．虚方法覆盖技术

（1）虚方法的重载
在类的方法前加上关键字 virtual，就声明了一个虚方法。通过对虚方法的重载，实现在程序运行过程中确定调用的方法。
【例】 虚方法的重载。
在 A 类定义中提供了非虚的方法 F 和虚方法 G，派生类 B 对方法 F 进行隐藏，而对虚方法 G 则使用 override 关键字实现了覆盖。这样一来，语句“A a = b”中的a就仍是一个b对象.

using System;
namespace ConsoleApp3
{
    class A
    {
        public void F() { Console.WriteLine("A.F"); }
        public virtual void G() { Console.WriteLine("A.G"); }
    }
    class B : A
    {
        new public void F() { Console.WriteLine("B.F"); }
        public override void G() { Console.WriteLine("B.G"); }
    }
    class Test
    {
        static void Main(string[] args)
        {
            B b = new B();
            A a = b;
            a.F();
            b.F();
            a.G();
            b.G();
            Console.Read();
        }
    }
}

（2）派生类方法覆盖基类方法
下面通过虚方法重载的机制，利用覆盖技术实现调用派生类方法计算三角形和梯形面积。
【例】Shape类中的方法area用virtual修饰，而在派生类Triangle和Trapezia中用关键字override修饰area方法，这样就可以在程序运行时决定调用哪个类的area方法。

using System;
namespace ConsoleApp3
{
    class Shape
    {
        protected double width;
        protected double height;
        public Shape()
        { width = height = 0; }
        public Shape(double x)
        { width = height = x; }
        public Shape(double w, double h)
        {
            width = w;
            height = h;
        }
        public virtual double area()   //virtual
        { return width * height; }
    }
    class Triangle : Shape      		// 三角形
    {
        public Triangle(double x, double y) : base(x, y) { }
         public override double area()    	//override
        {
            return width * height / 2;
        }
    }
    class Trapezia : Shape   		// 梯形
    {
        double width2;
        public Trapezia(double w1, double w2, double h) : base(w1, h)
        {
            width2 = w2;
        }
         public override double area()		//override
        {
            return (width + width2) * height / 2;
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            Shape A = new Shape(2, 4);
            Triangle B = new Triangle(1, 2);
            Trapezia C = new Trapezia(2, 3, 4);
            Console.WriteLine("A.area= {0} ", A.area());   // 调Shape的area方法
            Console.WriteLine("B.area= {0} ", B.area());   // 调Triangle的area方法
            Console.WriteLine("C.area= {0} ", C.area());   // 调Trapezia的area方法
            A = B;
            Console.WriteLine("A.area= {0} ", A.area());   // 试图调Triangle的area方法成功
            A = C;
            Console.WriteLine("A.area= {0} ", A.area());   // 试图调Trapezia的area方法成功
            Console.Read();
        }
    }
}

四、抽象类与抽象方法

抽象类是一种特殊的基类，并不与具体的事物相联系。抽象类的定义使用关键字abstract。将“图形”定义为抽象类，并由它派生出“圆形”、“四边形”这样一些可以产生具体实例的普通类。需要注意的是，抽象类不能被实例化，它只能作为其他类的基类。
将Shape类定义为抽象类：
public abstract class Shape
{
//TODO…
}
在抽象类中也可以使用关键字 abstract 定义抽象方法，要求所有的派生非抽象类都要重载实现该方法。引入抽象方法的原因在于，抽象类本身是一种抽象的概念，有的方法并不要求具体的实现，而是让派生类去重载实现。Shape 类中 GetArea 方法本身没什么具体的意义，而只有到了派生类Circle类和Rectangular类才可以计算具体的面积。
抽象方法的语法：
public abstract double GetArea();
则派生类重载实现为：
public override double GetArea()
{
//TODO…
}
【例】 抽象类和抽象方法的实现。

using System;
namespace ConsoleApp3
{
    // 定义抽象基类Shape
    public abstract class Shape
    {
        protected string Color;
        public Shape() { }
        public Shape(string Color)
        {
            this.Color = Color;
        }
        public string GetColor()
        {
            return Color;
        }
        public abstract double GetArea();           // 定义抽象方法
    }
    // 定义Circle类，从Shape类中派生
    public class Circle : Shape
    {
        private double Radius;
        public Circle(string Color, double Radius)
        {
            this.Color = Color;
            this.Radius = Radius;
        }
        // 实现抽象方法
        public override double GetArea()
        {
            return System.Math.PI * Radius * Radius;
        }
    }
    // 定义Rectangular类，从Shape类中派生
    public class Rectangular : Shape
    {
        protected double Length, Width;
        public Rectangular(string Color, double Length, double Width)
        {
            this.Color = Color;
            this.Length = Length;
            this.Width = Width;
        }
        // 实现抽象方法
        public override double GetArea()
        {
            return Length * Width;
        }
        public double PerimeterIs()         // 周长
        {
            return (2 * (Length + Width));
        }
    }
    // 派生类Square，从Rectangular类中派生
    public class Square : Rectangular
    {
        public Square(string Color, double Side) : base(Color, Side, Side) { }
    }
    class TestAbstract
    {
        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.GetArea(), 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.GetArea(), Squ.PerimeterIs());
            Console.Read();
        }
    }
}

抽象类只能作为基类，由其他类继承，不能被实例化。相对应地还有一种不能被其他类继承的类，叫密封类，使用sealed关键字定义。如将Rectangular类定义为密封类：
public sealed class Rectangular:Shape
{
// TODO…
}
这样Rectangular类中的派生类Square将不再保留，否则，程序编译时会报错。

LYLNB24
关注
编写一个抽象类Shape
Keven_fall的博客
04-03 618
二者都有计算对象面积的函数。，在此基础上派生出类。、计算对象周长的函数。
1．声明一个图形基类Shape，该类拥有用于存储Shape面积的属性S，以及用于计算面积的虚方法GetArea，由Shape类派生出Rectangle和Circle类，并在子类中重写GetArea方法
m0_68926878的博客
04-18 2846
1．声明一个图形基类Shape，该类拥有用于存储Shape面积的属性S，以及用于计算面积的虚方法GetArea，由Shape类派生出Rectangle和Circle类，并在子类中重写GetArea方法分别用于计算矩形和圆形的面积，在主函数中完成派生类的实例化及其测试。 2．基类Shape类是一个表示形状的抽象类，该类拥有用于存储Shape面积的属性Area，以及用于求面积的抽象方法GetArea。请从Shape类派生三角形类()，并给出具体的求面积函数GetArea，在主函数中完成类的实例化及其测试。
3.抽象类（shape）
W2001r的博客
05-27 5834
3 抽象类 定义一个抽象类shape，包括公有的计算面积area方法，计算体积volume方法，输出基本信息方法printinfo（三个方法均为抽象方法）。从shape派生point类，增加私有数据成员x,y坐标，以及构造方法。从point派生circle类，增加私有数据成员半径r，以及构造方法。从circle派生cylinder类，增加私有数据成员高度h，以及构造方法。在main方法中，定义shape类的对象，引用派生类的对象，输出三类对象的基本信息，面积，体积。 public class Test {
定义抽象类Shape，Rectangle和Square继承并实现
Shiny_desiger的博客
09-29 705
【代码】定义抽象类Shape，Rectangle和Square继承并实现。
Java创建Shape类
qq_51514930的博客
10-28 6907
建立的Shape包 package Shape; public abstract class Shape { //基类Shape的定义 public String name;//变量name public static String fatherName = "shape" ;//静态变量fatherName = “Shape” final static double PI =3.14; public static String getFatherName() { ret..
文字识别 2021-09-29 02.04.txt
03-30
文字识别 2021-09-29 02.04.txt
LBS in industry applications[2021-09-29]（15页）.pdf
05-20
《高精度LBS在工业应用中的重要性及发展》 位置感知技术，特别是高精度的Location-Based Services（LBS），已经在各个行业中展现出巨大的潜力。LBS不仅为用户提供精确的位置信息，还在工业应用中扮演着至关重要的...
NOI Linux2.0使用系列视频集-2021-09-29(G)--39页.pdf
09-29
NOI Linux 2.0 使用系列视频集 NOI Linux 2.0 是一个基于 Linux 操作系统的考试环境，旨在为编程比赛和算法竞赛提供一个稳定、可靠的平台。本资源摘要信息涵盖了 NOI Linux 2.0 的使用、安装、配置、编程环境、考试...
基于UWB技术的机器人高精度位置校准[2021-09-29]（12页）.pdf
05-21
标题提及的“基于UWB技术的机器人高精度位置校准”是关于机器人定位技术的一种，主要探讨了如何利用超宽带(Ultra-Wideband, UWB)技术实现机器人的精确定位。UWB技术在机器人领域的应用主要是通过SLAM（Simultaneous ...
C#画各种Shape
12-25
一个关于C# GDI+ 画各种形状的范例
C# 生成ShapeFile .shp文件
03-14
C# 生成ShapeFile 输出 .shp文件的代码，底层原生代码，无需第三方类库支持！
C#练习题--第一篇
MrLiuの甜蜜小屋
03-30 697
class Program{ static void Main(string[] args){ Tiger t = new Tiger(); Console.Read(); } } class Animal{ public Animal(){ Console.Write ("基类"); } .
C++ primer plus学习笔记 --- 第13章、类继承
qq_19432525的博客
05-09 452
一个简单的基类通常包括一些数据成员和成员函数，而这些成员函数可以用于被派生类继承和/或重写。在上述源代码中，我们定义了一个Shape类，作为几何图形的基类。Shape类有两个虚函数area()和，用于返回图形的面积和周长。这些虚函数将被派生类继承和重写。在这个例子中，我们并没有定义任何数据成员。注意，我们在虚函数的声明中使用了virtual关键字来标识这些函数。这表示这些函数是虚函数，并且需要在派生类中进行重写，以提供特定于派生类的实现。如果不使用virtual。
C# -＞ (Cshape)笔记
rod0320的博客
12-10 4173
文章目录编译/执行 C# 程序C# 基本语法字符串（String）类型指针类型（Pointer types）C# 类型转换接受来自用户的值c#输出语句常量:const readonly位运算符:&、 | 和 ^参数传递:值传递 引用传递(ref) 按输出传递参数C# 可空类型（Nullable）?使用 foreach 循环:(int j in n)C# 结构体（Struct）C# 枚举（Enum）C# 中的析构函数C# 继承:用的是:不是extendC# 多重继承:C# 不支持多重继承。可以使用接口
ovalshape C# 真正纯WinForm打造指示灯
热门推荐
newidea07的博客
03-28 1万+
20190328 雨，又下雨~ 这几天无聊，刚好看到别人c++软件有指示灯的控件，想着自己也弄一个练练手，做出来效果还不错，应该可以帮到有需要的人。 效果图如下： 核心代码如下： 这一段是实现带放射效果的圆形图案，纯色的实在难看(手动扶额)。 private void Ovalshape_Paint(object sender, PaintEventArgs e) ...
c#定义一个接口IShape，其中包括方法Area()用来计算面积，
Roninzhz的博客
11-26 8726
定义一个接口IShape，其中包括方法Area()用来计算面积，方法Girth()用来计算周长。三角形类Triangle、矩形类Rectangle实现该接口，各形状所需属性自己定义，由构造方法设置初值，请编写完整程序分别求其面积和周长。 //接口 interface IShape { void Area(); void Girth(); } //三角形 class ITriangle : IShape { //
Shape类
qq_51514930的博客
11-04 2995
（1）Shape类：抽象方法setColor（String color）方法，用来给图形设置颜色。 抽象方法showShapeInfo()方法，用来显示图形的详细信息。 （2）Shape2D类：计算面积的方法area()，计算周长的方法perimeter（）。 （3）Shape3D类：计算表面积方法surfaceArea()，计算体积方法volume（）。 （4）分别创建Rectangle、Circle、Box、Sphere类。 （5）在测试类TestShape中 创建Rectangle、Cir
java生成租金计划 需求：根据下面的条件生成每个月的月租金计划列表 递增周期：1年 租金递增率：6% 租赁开始时间 2021-03-01 租赁结束时间 2022-03-01 免租开始时间：2021-03-01 免租结束时间：2021-03-31 开始月租金：600 递增周期的时间是从租赁开始时间计算。
最新发布
05-26
2021-09-01 30 796.39 2021-10-01 31 840.94 2021-11-01 30 887.02 2021-12-01 31 934.72 2022-01-01 31 984.12 2022-02-01 28 1035.30 ``` 可以看到，程序正确地根据递增周期和递增率生成了每个月的租金计划...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值