代码之家 › 专栏 › 技术社区 › SlavisaB

车辆对象阵列-C#

derived-class inheritance arrays c#

-2

SlavisaB · 技术社区 · 9 年前

我在写代码时遇到了问题。我不太确定在哪里以及如何编写构造函数和访问器。

我必须做的活动是:

编写3个派生类,允许用户输入三种类型车辆及其属性的详细信息。

汽车(品牌、型号、年份、车身类型)

飞机(品牌、型号、年份、无发动机、发动机类型)

船(品牌、型号、年份、长度、船体类型)

第四类是基类Vehicle,包含共享属性和方法

将所有属性设置为私有(在派生类中)或受保护(在基类中),并为每个属性编写访问器方法。

为每个派生类编写2个构造函数。一个没有参数,另一个接受派生类中的属性值作为参数。

编写名为Fleet的控制台应用程序。cs,创建并显示每种车辆类型的2个

到目前为止,我的代码如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication5
{
    class Vehicle
    {
        static void Main(string[] args)
        {
        }

        class Car
        {
            protected string make
            {
                get
                {
                    return make;
                }
                set
                {
                    make = value;
                }
            }

            protected string model
            {
                get
                {
                    return model;
                }
                set
                {
                    model = value;
                }
            }

            protected int year
            {
                get
                {
                    return year;
                }
                set
                {
                    year = value;
                }
            }

            protected string bodyType
            {
                get
                {
                    return bodyType;
                }
                set
                {
                    bodyType = value;
                }
            }

            public bool isInitialized;
            public Car()
            {
                isInitialized = true;
            }
        }
    }

    class Airplane
    {
        protected string make
        {
            get
            {
                return make;
            }
            set
            {
                make = value;
            }
        }

        protected string model
        {
            get
            {
                return model;
            }
            set
            {
                model = value;
            }
        }

        protected int year
        {
            get
            {
                return year;
            }
            set
            {
                year = value;
            }
        }

        protected int numEngines
        {
            get
            {
                return numEngines;
            }
            set
            {
                numEngines = value;
            }
        }

        protected int engineType
        {
            get
            {
                return engineType;
            }
            set
            {
                engineType = value;
            }
        }
    }

    class Boat
    {
        protected string make
        {
            get
            {
                return make;
            }
            set
            {
                make = value;
            }
        }

        protected string model
        {
            get
            {
                return model;
            }
            set
            {
                model = value;
            }
        }

        protected string year
        {
            get
            {
                return year;
            }
            set
            {
                year = value;
            }
        }

        protected string length
        {
            get
            {
                return length;
            }
            set
            {
                length = value;
            }
        }

        protected string hullType
        {
            get
            {
                return hullType;
            }
            set
            {
                hullType = value;
            }
        }
    }
}

2 回复 | 直到 9 年前

Community Ian Goodfellow 4 年前

第一部分OOP原则

Classes :

类是一种构造,它使您能够创建自己的自定义通过将其他类型、方法和事件。一堂课就像一张蓝图。它定义了数据和行为类型。如果类未声明为静态,则客户端代码可以使用它通过创建分配给变量的对象或实例来实现。该变量保留在内存中,直到对它的所有引用都用完范围此时,CLR将其标记为符合垃圾处理条件收集如果类声明为静态,则只有一个副本存在于内存中,客户端代码只能通过类访问它而不是实例变量。有关详细信息,请参见静态类和静态类成员(C#编程指南)。不像结构,类支持继承,这是面向对象编程。有关详细信息,请参见继承(C# 编程指南)。

对象也是类的实例。

Inheritance :

继承以及封装和多态性是面向对象的三个主要特征(或支柱) 编程。继承使您能够创建新的类, 扩展和修改在其他类中定义的行为。这个成员被继承的类称为基类继承这些成员的类称为派生类。A. 派生类只能有一个直接基类。然而继承是可传递的。如果ClassC派生自ClassB,并且 ClassB派生自ClassA,ClassC继承 B类和A类。

派生类:
基于先前存在的类(即基类)创建的类。派生类继承派生类的基类的所有成员变量和方法。也称为派生类型。

Method :

面向对象编程(OOP)中的方法(或消息)是与对象类关联的过程。一个物体由行为和数据。数据表示为对象的属性行为作为方法。方法也是对象呈现的接口向外界开放。例如,窗口对象将具有方法例如打开和关闭。最重要的功能之一是方法提供的是方法重写。相同的名称(例如,区域)可以可用于多种不同类型的类。这允许发送对象以调用行为和委托实现将这些行为发送给接收对象。例如,对象可以向另一个对象发送区域消息和适当的公式将调用接收对象是否是矩形、圆形或矩形, 三角形等。

Attributes and properties :

“字段”、“类变量”和“属性”或多或少是相同-连接到对象的低级存储槽。每种语言的文档可能始终使用不同的术语,但最实际的程序员可以互换使用它们。(然而,这也意味着其中的一个术语可能是不明确的,比如“类变量” 解释为“给定类实例的变量”,或“ 类对象本身的变量” 是你可以直接操纵的东西。)

在我使用的大多数语言中,“属性”完全是另一回事- 它们是将自定义行为附加到读/写字段的一种方式。 (或更换。)

因此,如果你想对它们进行分类,它们就是OOP(面向对象编程)原则。

第二部分:

编写名为Fleet的控制台应用程序。创建和显示的cs 每种车型2辆。

这样做的一种方法是将车辆创建为硬编码。另一种方法是使用 Console.Readline() . Main 方法可能看起来像这样。

static void Main(string[] args)
{
    Vehicle v1 = new Vehicle { Make = "test1", Model = "model1", Year = 1996 };
    Vehicle v2 = new Vehicle { Make = "test2", Model = "model2", Year = 1997 };
    Console.WriteLine(v1);
    Console.WriteLine(v2);
    ...
}

然后你将覆盖 ToString() 方法。这样地:

public override string ToString()
{
    return string.Format("Vehicle is {0} and of model {1} and is made in {2}.", make, model, year);
}

在这里,您也可以使用 base.ToString() 以获取派生类中上层(基础)类的数据。

编辑1:用户输入:

所以,如果你想要用户输入,你可以制作这样的程序:

static void Main(string[] args)
{
    //input
    Vehicle v1 = new Vehicle();
    Console.Write("Enter the make of 1st vehicle: ");
    v1.Make = Console.ReadLine();
    Console.Write("Enter the model of 1st vehicle: ");
    v1.Model = Console.ReadLine();
    Console.WriteLine("Enter the year of manufacturing for 1st vehicle:");
    v1.Year = int.Parse(Console.ReadLine());
    //output
    Console.WriteLine("The data for 1st vehicle: ");
    Console.WriteLine(v1);
    ...
}

更好的办法是创造 Input 方法,并从 主要的 程序所以代码不会重复。

已完成的程序

车辆.cs

using System;

class Vehicle
{
    string make, model;
    int year;

    public string Make { get { return make; } set { make = value; } }
    public string Model { get { return model; } set { model = value; } }
    public int Year { get { return year; } set { year = value; } }

    public Vehicle()
    {
        make = model = "Unknown";
        year = 0;
    }

    public Vehicle(string make, string model, int year)
    {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    public virtual void GetFromInput()
    {
        Console.Write("Enter the make of vehicle: ");
        Make = Console.ReadLine();
        Console.Write("Enter the model of vehicle: ");
        Model = Console.ReadLine();
        Console.WriteLine("Enter the year of manufacturing for vehicle: ");
        Year = int.Parse(Console.ReadLine());
    }

    public override string ToString()
    {
        return string.Format("Vehicle is {0} and of model {1} and is made in {2}.", make, model, year);
    }
}

车载电脑

using System;

class Car : Vehicle
{
    string bodyType;
    public string BodyType { get { return bodyType; } set { bodyType = value; } }

    public Car() : base()
    {
        bodyType = "Unknown";
    }

    public Car(string make, string model, int year, string bodyType) : base(make, model, year)
    {
        this.bodyType = bodyType;
    }

    public override void GetFromInput()
    {
        base.GetFromInput();
        Console.Write("Enter body type for the car: ");
        BodyType = Console.ReadLine();
    }

    public override string ToString()
    {
        return base.ToString() + string.Format("This vehicle is a car with body type of {0}.", BodyType);
    }
}

飞机.cs

using System;

class Airplane : Vehicle
{
    int noEngines;
    string engineType;
    public int NumberOfEngines{ get { return noEngines; } set { noEngines = value; } }
    public string EngineType { get { return engineType; } set { engineType = value; } }

    public Airplane() : base()
    {
        noEngines = 0;
        engineType = "Unknown";
    }

    public Airplane(string make, string model, int year, int noEngines, string engineType) : base(make, model, year)
    {
        this.noEngines = noEngines;
        this.engineType = engineType;
    }

    public override void GetFromInput()
    {
        base.GetFromInput();
        Console.Write("Enter the number of engines on an airplane: ");
        NumberOfEngines = int.Parse(Console.ReadLine());
        Console.Write("Enter the engine type for the airplane: ");
        EngineType = Console.ReadLine();
    }

    public override string ToString()
    {
        return base.ToString() + string.Format("This vehicle is an airplane with {0} engines and engine type of {1}.", NumberOfEngines, EngineType);
    }
}

Boat.cs公司

using System;

class Boat : Vehicle
{
    int length;
    string hullType;
    public int Length { get { return length; } set { length = value; } }
    public string HullType { get { return hullType; } set { hullType = value; } }

    public Boat() : base()
    {
        length = 0;
        hullType = "Unknown";
    }

    public Boat(string make, string model, int year, int length, string hullType) : base(make, model, year)
    {
        this.length = length;
        this.hullType = hullType;
    }

    public override void GetFromInput()
    {
        base.GetFromInput();
        Console.Write("Enter the length of the boat: ");
        Length = int.Parse(Console.ReadLine());
        Console.Write("Enter the hull type for the boat: ");
        HullType = Console.ReadLine();
    }

    public override string ToString()
    {
        return base.ToString() + string.Format("This vehicle is a boat with length of {0} and hull type of {1}.", Length, HullType);
    }
}

Fleet.cs公司

using System;

class Fleet
{
    static void Main(string[] args)
    {
        Vehicle v1 = new Vehicle();
        v1.GetFromInput();
        Console.WriteLine(v1);
        //... for the other vehicles
    }
}

zackery.fix 9 年前

这可以通过使用类继承来实现。

您的每个人 交通工具 类,需要继承实现“all”所需功能的公共类车辆 ,这个类( 交通工具 可接受地),然后可以在C#中用于识别 任何类型的车辆 类别/类型。

您可以抽象出每个车辆所需的公共功能,并实现一个公开这些公共关系的类,而不是有几个类,每个类单独负责一种类型的车辆:

using System;

public namespace CodeSpace {
 public class Vehicle { 
  public Vehicle(Type type, string make, string model) {
   Model = model;
   Make = make;
   Type = type;
  }
  public Type VehicleType { get; private set; }
  public string Make { get; set; } 
  public string Model { get; set; } 
 }

 public class Airplane : Vehicle {
  public class Airplane(string make, string model) : base(typeof(Airplane), make, model) {
  }
 }

 public class Boat : Vehicle {
  public class Boat(string make, string model) : base(typeof(Boat), make, model) {
  }
 }

 public class Car : Vehicle {
  public class Car(string make, string model) : base(typeof(Car), make, model) {
  }
 }

 class Program {
 public static void Main(params string[] args ) {       
 var vehicles = new List<Vehicle>() {
    new Boat("Canoe", "X2") as Vehicle,
    new Boat("Raft", "A") as Vehicle,
    new Car("Ford", "T") as Vehicle,
    new Airplane("BMW", "Idk") as Vehicle,
 };

  foreach(var v in vehicles) { 
   Console.WriteLine(v.VehicleType.FullName);
  }
 }
}

}

现在,可以使用一个类来识别所有车辆,该类通过公共接口公开所有车辆。