第一部分OOP原理

类:

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

对象也是类的实例。

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

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

方法:

面向对象编程(OOP)中的方法(或消息)是一个与对象类关联的过程。物体是由……组成的行为和数据。数据表示为对象和的属性作为方法的行为。方法也是对象呈现的接口对外面的世界。例如，窗口对象将具有方法如开与关。最重要的能力之一方法提供了其方法重写。相同的名称(例如，区域)可以可用于多种不同类型的类。这允许发送对象以调用行为并委托实现这些行为对接收对象的影响。例如，一个对象可以发送一个区域消息给另一个对象和相应的公式会被调用不管接收对象是矩形，圆形，三角形等。

属性和属性:

"字段"、"类变量"answers"属性";或多或少相同的-附加到对象的低级存储槽。每种语言的文档可能会始终使用不同的术语，但这是最实际的程序员可以互换地使用它们。(然而，这也意味着一些有些术语可能模棱两可，比如"类变量";-可以是解释为"给定类的实例的变量"，或"一个"类对象本身的变量"在类对象的语言中是可以直接操作的。)

"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方法，并从Main程序调用它。这样代码就不会重复了。

Vehicle.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);
    }
}

Car.cs

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);
    }
}

Airplane.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
    }
}

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

每个vehicle类，都需要继承一个公共类来实现'all' vehicles所需的功能，这个类( vehicle接受性)，然后可以在c#中使用来识别任何类型的vehicle类/类型。

不必有几个类，每个类单独负责一种类型的交通工具，你可以抽象出每个交通工具所需的公共功能，并实现一个暴露这些公共关系的类:

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);
  }
 }
}

}

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