C#学习（八）多态

最新推荐文章于 2021-10-09 13:52:22 发布
最新推荐文章于 2021-10-09 13:52:22 发布
阅读量196 收藏 2
点赞数 1
分类专栏： c#
原文链接：https://www.runoob.com/csharp/csharp-operator-overloading.html
版权

来源：菜鸟教程

C# 多态性

多态是同一个行为具有多个不同表现形式或形态的能力。

多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。

多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。

在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。

多态就是同一个接口，使用不同的实例而执行不同操作。

静态多态性

在编译时，函数和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：

  • 函数重载
  • 运算符重载

 

函数重载

您可以在同一个范围内对相同的函数名有多个定义。函数的定义必须彼此不同，可以是参数列表中的参数类型不同，也可以是参数个数不同。不能重载只有返回类型不同的函数声明。

重载：

函数名相同，参数不同（类型、个数）

C# 运算符重载

您可以重定义或重载 C# 中内置的运算符。因此，程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。

例如，请看下面的函数：

public static Box operator+ (Box b, Box c)
{
   Box box = new Box();
   box.length = b.length + c.length;
   box.breadth = b.breadth + c.breadth;
   box.height = b.height + c.height;
   return box;
}

上面的函数为用户自定义的类 Box 实现了加法运算符（+）。它把两个 Box 对象的属性相加，并返回相加后的 Box 对象。

using System;

namespace OperatorOvlApplication
{
   class Box
   {
      private double length;      // 长度
      private double breadth;     // 宽度
      private double height;      // 高度

      public double getVolume()
      {
         return length * breadth * height;
      }
      public void setLength( double len )
      {
         length = len;
      }

      public void setBreadth( double bre )
      {
         breadth = bre;
      }

      public void setHeight( double hei )
      {
         height = hei;
      }
      // 重载 + 运算符来把两个 Box 对象相加
      public static Box operator+ (Box b, Box c)
      {
         Box box = new Box();
         box.length = b.length + c.length;
         box.breadth = b.breadth + c.breadth;
         box.height = b.height + c.height;
         return box;
      }

   }

   class Tester
   {
      static void Main(string[] args)
      {
         Box Box1 = new Box();         // 声明 Box1，类型为 Box
         Box Box2 = new Box();         // 声明 Box2，类型为 Box
         Box Box3 = new Box();         // 声明 Box3，类型为 Box
         double volume = 0.0;          // 体积

         // Box1 详述
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);

         // Box2 详述
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);

         // Box1 的体积
         volume = Box1.getVolume();
         Console.WriteLine("Box1 的体积： {0}", volume);

         // Box2 的体积
         volume = Box2.getVolume();
         Console.WriteLine("Box2 的体积： {0}", volume);

         // 把两个对象相加
         Box3 = Box1 + Box2;

         // Box3 的体积
         volume = Box3.getVolume();
         Console.WriteLine("Box3 的体积： {0}", volume);
         Console.ReadKey();
      }
   }
}

可重载和不可重载运算符

下表描述了 C# 中运算符重载的能力：

运算符描述
+, -, !, ~, ++, --这些一元运算符只有一个操作数，且可以被重载。
+, -, *, /, %这些二元运算符带有两个操作数，且可以被重载。
==, !=, <, >, <=, >=这些比较运算符可以被重载。
&&, ||这些条件逻辑运算符不能被直接重载。
+=, -=, *=, /=, %=这些赋值运算符不能被重载。
=, ., ?:, ->, new, is, sizeof, typeof这些运算符不能被重载。
using System;

namespace OperatorOvlApplication
{
    class Box
    {
       private double length;      // 长度
       private double breadth;     // 宽度
       private double height;      // 高度
     
       public double getVolume()
       {
         return length * breadth * height;
       }
      public void setLength( double len )
      {
          length = len;
      }

      public void setBreadth( double bre )
      {
          breadth = bre;
      }

      public void setHeight( double hei )
      {
          height = hei;
      }
      // 重载 + 运算符来把两个 Box 对象相加
      public static Box operator+ (Box b, Box c)
      {
          Box box = new Box();
          box.length = b.length + c.length;
          box.breadth = b.breadth + c.breadth;
          box.height = b.height + c.height;
          return box;
      }
     
      public static bool operator == (Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length == rhs.length && lhs.height == rhs.height
             && lhs.breadth == rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public static bool operator !=(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length != rhs.length || lhs.height != rhs.height
              || lhs.breadth != rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public static bool operator <(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length < rhs.length && lhs.height
              < rhs.height && lhs.breadth < rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator >(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length > rhs.length && lhs.height
              > rhs.height && lhs.breadth > rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator <=(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length <= rhs.length && lhs.height
              <= rhs.height && lhs.breadth <= rhs.breadth)
          {
              status = true;
          }
          return status;
      }

      public static bool operator >=(Box lhs, Box rhs)
      {
          bool status = false;
          if (lhs.length >= rhs.length && lhs.height
             >= rhs.height && lhs.breadth >= rhs.breadth)
          {
              status = true;
          }
          return status;
      }
      public override string ToString()
      {
          return String.Format("({0}, {1}, {2})", length, breadth, height);
      }
   
   }
   
   class Tester
   {
      static void Main(string[] args)
      {
        Box Box1 = new Box();          // 声明 Box1，类型为 Box
        Box Box2 = new Box();          // 声明 Box2，类型为 Box
        Box Box3 = new Box();          // 声明 Box3，类型为 Box
        Box Box4 = new Box();
        double volume = 0.0;   // 体积

        // Box1 详述
        Box1.setLength(6.0);
        Box1.setBreadth(7.0);
        Box1.setHeight(5.0);

        // Box2 详述
        Box2.setLength(12.0);
        Box2.setBreadth(13.0);
        Box2.setHeight(10.0);

       // 使用重载的 ToString() 显示两个盒子
        Console.WriteLine("Box1： {0}", Box1.ToString());
        Console.WriteLine("Box2： {0}", Box2.ToString());
       
        // Box1 的体积
        volume = Box1.getVolume();
        Console.WriteLine("Box1 的体积： {0}", volume);

        // Box2 的体积
        volume = Box2.getVolume();
        Console.WriteLine("Box2 的体积： {0}", volume);

        // 把两个对象相加
        Box3 = Box1 + Box2;
        Console.WriteLine("Box3： {0}", Box3.ToString());
        // Box3 的体积
        volume = Box3.getVolume();
        Console.WriteLine("Box3 的体积： {0}", volume);

        //comparing the boxes
        if (Box1 > Box2)
          Console.WriteLine("Box1 大于 Box2");
        else
          Console.WriteLine("Box1 不大于 Box2");
        if (Box1 < Box2)
          Console.WriteLine("Box1 小于 Box2");
        else
          Console.WriteLine("Box1 不小于 Box2");
        if (Box1 >= Box2)
          Console.WriteLine("Box1 大于等于 Box2");
        else
          Console.WriteLine("Box1 不大于等于 Box2");
        if (Box1 <= Box2)
          Console.WriteLine("Box1 小于等于 Box2");
        else
          Console.WriteLine("Box1 不小于等于 Box2");
        if (Box1 != Box2)
          Console.WriteLine("Box1 不等于 Box2");
        else
          Console.WriteLine("Box1 等于 Box2");
        Box4 = Box3;
        if (Box3 == Box4)
          Console.WriteLine("Box3 等于 Box4");
        else
          Console.WriteLine("Box3 不等于 Box4");

        Console.ReadKey();
      }
    }
}

 

operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一：

public static result-type operator unary-operator ( op-type operand )
public static result-type operator binary-operator ( op-type operand, op-type2 operand2 )
public static implicit operator conv-type-out ( conv-type-in operand )
public static explicit operator conv-type-out ( conv-type-in operand )

参数：

  •  result-type 运算符的结果类型。
  •  unary-operator 下列运算符之一：+ - ! ~ ++ — true false
  •  op-type 第一个（或唯一一个）参数的类型。
  •  operand 第一个（或唯一一个）参数的名称。
  •  binary-operator 其中一个：+ - * / % & | ^ << >> == != > < >= <=
  •  op-type2 第二个参数的类型。
  •  operand2 第二个参数的名称。
  •  conv-type-out 类型转换运算符的目标类型。
  •  conv-type-in 类型转换运算符的输入类型。

注意：

前两种形式声明了用户定义的重载内置运算符的运算符。并非所有内置运算符都可以被重载（请参见可重载的运算符）。op-type 和 op-type2 中至少有一个必须是封闭类型（即运算符所属的类型，或理解为自定义的类型）。例如，这将防止重定义整数加法运算符。

后两种形式声明了转换运算符。conv-type-in 和 conv-type-out 中正好有一个必须是封闭类型（即，转换运算符只能从它的封闭类型转换为其他某个类型，或从其他某个类型转换为它的封闭类型）。

运算符只能采用值参数，不能采用 ref 或 out 参数。

C# 要求成对重载比较运算符。如果重载了==，则也必须重载!=，否则产生编译错误。同时，比较运算符必须返回bool类型的值，这是与其他算术运算符的根本区别。

C# 不允许重载=运算符，但如果重载例如+运算符，编译器会自动使用+运算符的重载来执行+=运算符的操作。

运算符重载的其实就是函数重载。首先通过指定的运算表达式调用对应的运算符函数，然后再将运算对象转化为运算符函数的实参，接着根据实参的类型来确定需要调用的函数的重载，这个过程是由编译器完成。

任何运算符声明的前面都可以有一个可选的属性（C# 编程指南）列表。

动态多态性

C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。

请注意，下面是有关抽象类的一些规则：

  • 您不能创建一个抽象类的实例。
  • 您不能在一个抽象类外部声明一个抽象方法。
  • 通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。

抽象类：

不能被实例化

含有抽象方法的类一定是抽象类

抽象类不能用sealed修饰

using System;
namespace PolymorphismApplication
{
   abstract class Shape
   {
       abstract public int area();
   }
   class Rectangle:  Shape
   {
      private int length;
      private int width;
      public Rectangle( int a=0, int b=0)
      {
         length = a;
         width = b;
      }
      public override int area ()
      {
         Console.WriteLine("Rectangle 类的面积：");
         return (width * length);
      }
   }

   class RectangleTester
   {
      static void Main(string[] args)
      {
         Rectangle r = new Rectangle(10, 7);
         double a = r.area();
         Console.WriteLine("面积： {0}",a);
         Console.ReadKey();
      }
   }
}

当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。

虚方法是使用关键字 virtual 声明的。

虚方法可以在不同的继承类中有不同的实现。

对虚方法的调用是在运行时发生的。

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

以下实例创建了 Shape 基类，并创建派生类 Circle、 Rectangle、Triangle， Shape 类提供一个名为 Draw 的虚拟方法，在每个派生类中重写该方法以绘制该类的指定形状。

using System;
using System.Collections.Generic;

public class Shape
{
    public int X { get; private set; }
    public int Y { get; private set; }
    public int Height { get; set; }
    public int Width { get; set; }
   
    // 虚方法
    public virtual void Draw()
    {
        Console.WriteLine("执行基类的画图任务");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个圆形");
        base.Draw();
    }
}
class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个长方形");
        base.Draw();
    }
}
class Triangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("画一个三角形");
        base.Draw();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // 创建一个 List<Shape> 对象，并向该对象添加 Circle、Triangle 和 Rectangle
        var shapes = new List<Shape>
        {
            new Rectangle(),
            new Triangle(),
            new Circle()
        };

        // 使用 foreach 循环对该列表的派生类进行循环访问，并对其中的每个 Shape 对象调用 Draw 方法
        foreach (var shape in shapes)
        {
            shape.Draw();
        }

        Console.WriteLine("按下任意键退出。");
        Console.ReadKey();
    }

}
using System;
namespace PolymorphismApplication
{
   class Shape
   {
      protected int width, height;
      public Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      public virtual int area()
      {
         Console.WriteLine("父类的面积：");
         return 0;
      }
   }
   class Rectangle: Shape
   {
      public Rectangle( int a=0, int b=0): base(a, b)
      {

      }
      public override int area ()
      {
         Console.WriteLine("Rectangle 类的面积：");
         return (width * height);
      }
   }
   class Triangle: Shape
   {
      public Triangle(int a = 0, int b = 0): base(a, b)
      {
     
      }
      public override int area()
      {
         Console.WriteLine("Triangle 类的面积：");
         return (width * height / 2);
      }
   }
   class Caller
   {
      public void CallArea(Shape sh)
      {
         int a;
         a = sh.area();
         Console.WriteLine("面积： {0}", a);
      }
   }  
   class Tester
   {
     
      static void Main(string[] args)
      {
         Caller c = new Caller();
         Rectangle r = new Rectangle(10, 7);
         Triangle t = new Triangle(10, 5);
         c.CallArea(r);
         c.CallArea(t);
         Console.ReadKey();
      }
   }
}

C# 多态性

多态：一个接口多个功能。

静态多态性：编译时发生函数响应（调用）；

动态多态性：运行时发生函数响应。

静态绑定（早期绑定）：编译时函数和对象的连接机制。 两种技术实现静态多态性：函数重载/运算符重载。

函数重载：在同一范围内对相同函数名有多个定义，可以是参数类型或参数个数的不同，但不许只有返回值类型不同。

运算符重载：

关键字 abstract 声明抽象类：用于接口部分类的实现（派生类继承抽象类时，实现完成）。抽象类包含抽象方法，抽象方法可被派生类实现。

抽象类规则：

  •  1.不能创建抽象类的实例
  • 2.不能在抽象类外定义抽象方法
  • 3.不能把抽象类声明为sealed（类前带关键字sealed代表该类是密封类，不能被继承）

关键字virtual声明虚方法:用于方法在继承类中的实现（在不同的继承类中有不同的实现）。

抽象类和虚方法共同实现动态多态性。

注：继承类中的重写虚函数需要声明关键字 override

virtual 和 abstract

virtual和abstract都是用来修饰父类的，通过覆盖父类的定义，让子类重新定义。

  •  1.virtual修饰的方法必须有实现（哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现。
  • （即abstract修饰的方法没有方法体，而virtual修饰的方法有方法体）
  •  2.virtual可以被子类重写，而abstract必须被子类重写。
  • （继承抽象类，必须重写抽象类中的抽象方法）
  •  3.如果类成员被abstract修饰，则该类前必须添加abstract，因为只有抽象类才可以有抽象方法。
  •  4.无法创建abstract类的实例，只能被继承无法实例化。
  • （抽象类不能被实例化）

抽象方法是需要子类去实现的。虚方法是已经实现了的，可以被子类覆盖，也可以不覆盖，取决于需求。

抽象方法和虚方法都可以供派生类重写

虚方法：即为基类中定义的允许在派生类中重写的方法，使用virtual关键字定义。

注意：虚方法也可以被直接调用。

抽象方法：在基类中定义的并且必须在派生类中重写的方法，使用 abstract 关键字定义。

注意：抽象方法只能在抽象类中定义

重载和重写

重载(overload)是提供了一种机制, 相同函数名通过不同的返回值类型以及参数来表来区分的机制。重写(override)是用于重写基类的虚方法,这样在派生类中提供一个新的方法。

重载发生在一个类中，重写发生在父子类中，子类方法重写，覆盖掉父类的同名方法。

重载(overload): 在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载，它们有三个特点(俗称两必须一可以):

  •  方法名必须相同
  •  参数列表必须不相同
  •  返回值类型可以不相同

重写(override):子类中为满足自己的需要来重复定义某个方法的不同实现，需要用 override 关键字，被重写的方法必须是虚方法，用的是 virtual 关键字。它的特点是(三个相同):

  • 相同的方法名
  • 相同的参数列表
  • 相同的返回值

如：父类中的定义：

public virtual void EatFood()
{
    Console.WriteLine("Animal吃东西");
}

子类中的定义：

public override void EatFood()
{
    Console.WriteLine("Cat吃东西");
    //base.EatFood();
}

隐藏方法：在派生类中定义的和基类中的某个方法同名的方法，使用 new 关键字定义。如在基类 Animal 中有一方法 Sleep():

public void Sleep()
{
    Console.WriteLine("Animal Sleep");
}

则在派生类 Cat 中定义隐藏方法的代码为：

new public void Sleep()
{
    Console.WriteLine("Cat Sleep");
}

或者为：

public new void Sleep()
{
    Console.WriteLine("Cat Sleep");
}

注意：

  • （1）隐藏方法不但可以隐藏基类中的虚方法，而且也可以隐藏基类中的非虚方法。
  • （2）隐藏方法中父类的实例调用父类的方法，子类的实例调用子类的方法。
  • （3）和上一条对比：重写方法中子类的变量调用子类重写的方法，父类的变量要看这个父类引用的是子类的实例还是本身的实例，如果引用的是父类的实例那么调用基类的方法，如果引用的是派生类的实例则调用派生类的方法。
class dad
    {
        protected string name;
        public dad(string n)
        {
            name = n;
        }
        public void say()
        {
            Console.WriteLine("I am {0}.", name);
        }
        public virtual void growup()
        {
            Console.WriteLine("{0} has grown old.", name);
        }
    }
    class son : dad
    {
        public son(string n) : base(n)
        {
            //name = n;
        }
        public new void say()
        {
            Console.WriteLine("I am {0} and a son.", name);
        }
        public override void growup()
        {
            //base.growup();
            Console.WriteLine("{0} is growing up.", name);
        }
    }
    class entrance
    {
        public static void Main()
        {
            dad grandpa = new dad("grandpa");
            grandpa.say();
            grandpa.growup();
            dad father = new son("father");
            father.say();
            father.growup();
            son tom = new son("Tom");
            tom.say();
            tom.growup();
            Console.ReadKey();
        }
    }

I am grandpa.
grandpa has grown old.
I am father.
father is growing up.
I am Tom and a son.
Tom is growing up.

  • 用父类生成的父类对象，grandpa，访问隐藏方法是父类的方法，访问重写方法是父类的方法
  •  用子类生成的父类对象，father，访问隐藏方法是父类的方法，访问重写方法是子类的方法
  •  用子类生成的子类对象，son，访问隐藏方法是子类的方法，访问重写方法是子类的方法
 调用的隐藏方法， 用父类的声明来调用的，调用的就是父类的Move方法。
调用的是隐藏方法， 用子类的声明来调用的，调用的就是子类的Move。

虚方法的调用：调用上，使用子类构造的对象调用虚方法，就会调用子类的方法，使用父类构造的对象，就会调用父类的方法。

隐藏方法的调用：调用上， 使用子类类型的声明调用隐藏方法，就会调用到子类的方法。若想调用被隐藏的方法，需要用父类类型的声明来调用。

class Enemy
{
    public void Move() {
        Console.WriteLine("调用了 enemy的move方法");
    }
    public virtual void Attack() {
        Console.WriteLine("enemy attac");
    }
    }


    class Boss : Enemy
    {
    public override void Attack() {
        Console.WriteLine("Boss Attac");
    }

    public new void Move() {
        Console.WriteLine("Boss move");
    }
}

static void Main(string[] args)
{
    //---- 隐藏方法的调用----begin
    Boss oneEnemy = new Boss();
    oneEnemy.Move(); // 调用的是隐藏方法， 用子类的声明来调用的，调用的就是子类的Move。

    Enemy twoEnemy = new Boss();
    twoEnemy.Move(); // 调用的隐藏方法， 用父类的声明来调用的，调用的就是父类的Move方法。
    //-----------------------end

    //-----虚方法的调用----- begin
    //用什么类型 来构造，在调用方法的时候就会调用什么类型的方法。

    Enemy threeEnemy = new Enemy();
    threeEnemy.Attac(); // 调用虚方法，用父类来实例化的，所以调用的是父类的Attac方法。

    Enemy fourEnemy = new Boss();
    fourEnemy.Attac();  // 调用虚方法，用子类来实例化的，所以调用的就是子类(Boss)的Attac方法。

    //-----虚方法的调用------end

    Console.ReadKey();
}

 

 

泽西岛
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中的属性(get、set、value)浅谈
xiaoweids的博客
06-12 4456
这种参数类型的自动转换时基于.NETFramework提供的类型转换器而实现的，CLR将C#源代码编译成中间语言IL，在这种类汇编的高级机器语言中可以发现value参数的传递机制。
C#多态
Oneil_Sally的专栏
08-22 1308
首先理解一下什么叫多态。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。多态性通过派生类覆写基类中的虚函数型方法或者抽象方法来实现。多态性分为两种，一种是编译时的多态性，一种是运行时的多态性。编译时的多态性：编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。运行时的多态性：运行时的多态
c#中的多态学习总结
liming0931的专栏
11-17 241
c#的多台方法，大体上和c++的类似，但是有点区别的，我这里刚刚初学，因此把重点记录下。 多态是同一个行为具有多个不同表现形式或形态的能力。 多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。 多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。 在C#中，每个类型都是多态的，因为包括用户定义类型...
反射,System.Type类
01-26 2089
两个现实中的例子：1、B超：大家体检的时候大概都做过B超吧，B超可以透过肚皮探测到你内脏的生理情况。这是如何做到的呢？B超是B型超声波，它可以透过肚皮通过向你体内发射B型超声波，当超声波遇到内脏壁的时候就会产生一定的“回音”反射，然后把“回音”进行处理就可以显示出内脏的情况了（我不是医生也不是声学专家，不知说得是否准确^_^）。2、地球内部结构：地球的内部结构大体可以分为三层：地壳、地幔和地核
C#属性简写的原理分析之get set private
生命在于折腾的博客
12-13 1528
陌生的奇怪的属性用法，特地记录一下，如下： public bool Skidding { get; private set; } public float BrakeInput { get; private set; } public float CurrentSteerAngle{ get { return m_SteerAngle; }} p...
C#属性简写用法 {get;set}
narutojzm1的博客
03-02 1万+
话说我用C# 都工作两年了，竟然看到了一个陌生的奇怪的属性用法，特地记录一下，如下： public bool Skidding { get; private set; } public float BrakeInput { get; private set; } public float CurrentSteerAngle{ get { return m_Stee
c#基础学习之多态
12-25
最近在看一本书《你必须知道的.Net》,书涵盖的内容比较多，对于c#，.Net平台以往所学的零散东西有了慢慢的总结和新的认识。把一些基础的东西记录于此。先说说多态吧：1.基类继承式多态如书中所说，基类继承式多态的...
C#封装继承多态
11-05
这是关于C#封装继承多态的一个简单的例子，对于深入学习C#中封装继承多态将很有帮助！
C#中的多态深入理解
01-01
我一直认为学习OO的最好方法就是结合实践，封装、继承在实际工作中的应用随处可见，但多态呢？也许未必，可能不经意间用到也不会把它跟“多态”这个词对应起来。在此抛砖引玉，大家讨论，个人能力有限，不足之处还请...
C#中面向对象编程机制之多态学习笔记
09-03
多态性主要体现在接口多态和继承多态两个方面。 1. **接口多态性**： 接口多态是指不同的类实现同一个接口，并根据各自的需求提供不同的实现。在这种情况下，接口扮演着统一行为的角色，使得不同类型的对象可以通过...
夜光带你走进C#语言 基础版本（49）
夜光的博客
08-04 234
夜光序言： 理想的书籍是智慧的铜匙。 一切节省，归根到底都归结为时间的节省。 今天所做之事勿候明天，自己所做之事勿候他人。 坚强的信心，能使平凡的人做出惊人的事业。 正文： C# 多态性 多态：一个接口多个功能。 静态多态性：编译时发生函数响应（调用）； 动态多态性：运行时发生函数...
C#中的get、set方法
qq_42370421的博客
10-09 1万+
1、首先自己定义的类的属性。类型为privata、且变量名以下划线开始 public class student { private int _id; private string _name; } 2、接着选中上面的代码块，先ctrl+R,再ctrl+E,就会出现下图的界面，点击Apply，就会自动生成set、get方法 3、自动生成的set、get方法 public class student { private int _i
c#值get、 set用法（包含自动转换的说明）
流浪若相惜的专栏
02-15 7089
在程序中经常碰到get、set，不甚明白，在网上查询时也说的迷迷糊糊，所以整理下，以学的明白透彻点。     有两个类person：     public class person     {       public string name;     }     public class person     {       public stri
C#中{ get; set; }写法是什么意思
热门推荐
大头之家
06-01 5万+
代表，属性xxx 可以 是获取或设置。如果是 仅是 set 则只能设置，反之亦然。老版本的.net framework 对于属性，不能省略，必须这样做：int adminID = 0;public AdminID{ get{return adminID;} set{adminID=value;}}而现在的版本可以省略，仅仅需要:public AdminID{get;set;} 其代表的意义是一样的...
C# 基础（八）C# get set 以及value 表示什么意思？举例说明
xpj8888的博客
11-16 2万+
一、基础知识（你只有程序拷贝过去，自己单步执行，才能发现Value是怎样来的） 1、只读 //https://www.cnblogs.com/lixiaolu/p/8214037.html http://www.cnblogs.com/zl181015/p/9243881.html 2、只写 //https://www.cnblogs.com/lixiaolu/p/8214037.htm...
C#函数中{get;set;}
KindSuper_liu的专栏
01-17 8863
在面向对象编程（OOP）中，是不允许外界直接对类的成员变量直接访问的，既然不能访问，那定义这些成员变量还有什么意义呢？所以C#中就要用set和get方法来访问私有成员变量，它们相当于外界访问对象的一个通道，一个“接口”。先来看一段代码： class Employee { private string name; private byte age; ...
C#中get和set、get｛｝和set｛｝函数的用法
zhaoshi1987的专栏
10-25 2656
A :        C# 中，get是读取属性时进行的操作，set是设置属性时进行的操作。        定义一个属性如果只有get，这个属性就是只读的。同样，只有set，属性就是只写的，当然只写的属性是没有任务意义的。 get和set：允许对属性进行读写访问。               get        only：只允许读属性的值。               set
C# 进阶笔记之美
游戏开发、游戏引擎开发、逆向破解爱好者
09-06 399
C#（发音为 C sharp，正确写法应为 C♯），是一种简单、现代、通用、面向对象的编程语言，支持跨平台。支持结构化、面向对象、泛型等多种编程范型。深受 Visual Basic、Java、C/C++ 的影响。在很多方面与 Java 相似，但在面向对象特性上拥有许多优势。 前言 本文不包含 C# 语法中比较基础的部分，仅包含较为高级的语法。 可空类型 C# 提供了一个特殊的数据类型——n...
C#中多态性的理解
Silk2018的专栏
04-27 5846
在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。 多态性可以是静态的或动态的。 在静态多态性中，函数的响应是在编译时发生的。 函数重载 运算符重载 在动态多态性中，函数的响应是在运行时发生的。 参考资料：http://www.runoob.com/csharp/csharp-polymorphism.html
c#后端开发学习路线
最新发布
02-22
C#是一种通用的面向对象编程言，广泛应用于后端开发领域。如果你想学习C#后端开发，以下是一个学习路线的建议： 1. 学习基础知识：首先，你需要学习C#的基础知识，包括语法、数据类型、控制流等。可以通过阅读相关的教程或者参加在线课程来学习。 2. 掌握面向对象编程：C#是一种面向对象的语言，掌握面向对象编程的概念和技巧对于后端开发至关重要。你需要学习类、对象、继承、多态等概念，并且能够运用它们来设计和实现复杂的系统。 3. 学习.NET框架：C#是.NET框架的一部分，了解和掌握.NET框架的各种功能和组件对于C#后端开发至关重要。你可以学习ASP.NET MVC或者ASP.NET Core等框架，它们提供了丰富的工具和库来简化后端开发。 4. 数据库和数据访问：后端开发经常需要与数据库进行交互，你需要学习数据库的基本概念和SQL语言，并且了解如何使用C#来连接和操作数据库。常见的数据库包括SQL Server、MySQL、Oracle等。 5. Web开发：学习C#后端开发的一个重要方向是Web开发。你可以学习ASP.NET MVC或者ASP.NET Core框架来构建Web应用程序，掌握HTML、CSS、JavaScript等前端技术也是必要的。 6. 安全和性能优化：在实际的后端开发中，安全和性能优化是非常重要的考虑因素。你需要学习如何编写安全的代码，防止常见的安全漏洞，并且了解如何优化代码以提高系统的性能和响应速度。 7. 实践项目：最后，通过实践项目来巩固所学知识。可以尝试开发一些小型的Web应用程序或者API，这样可以更好地理解和应用所学的知识。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值