static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Done - Create an abstract class called Vehicle
* Done - The vehicle class shall have three string properties Year, Make, and Model
* Done - Set the defaults to something generic in the Vehicle class
* Done - Vehicle shall have an abstract method called DriveAbstract with no implementation
* Done - Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Done = Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Done - Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Done - Provide the implementations for the abstract methods
* Done - Only in the Motorcycle class will you override the virtual drive method
*/
// Done - Create a list of Vehicle called vehicles
var vehicles = new List<Vehicle>();
/*
* Done - Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
var focus = new Car() { hasTrunk = true, Make = "Ford", Model = "Focus", Year = 2019 };
var motorcycle = new Motorcycle() { HasSideCart = true, Make = "Harley Davidson", Model = "Roadster", Year = 2017};
Vehicle sedan = new Car() { hasTrunk = true, Make = "Porsche", Model = "Panamera", Year = 2020 };
Vehicle coupe = new Car() { hasTrunk = true, Make = "Honda", Model = "Accord", Year = 2015 };
/*
* Done - Add the 4 vehicles to the list
* Done- Using a foreach loop iterate over each of the properties
*/
vehicles.Add(focus);
vehicles.Add(motorcycle);
vehicles.Add(sedan);
vehicles.Add(coupe);
foreach(var veh in vehicles)
{
Console.WriteLine{$"Make {veh.Make} Model {veh.Model} Year {veh.Year}");
veh.DriveAbstract();
}
// Done - Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
var vehicles = new List <Vehicle>();
var myCar = new Car();
var myMotorcycle = new Motorcycle();
Vehicle newCar = new Car();
Vehicle newMoto = new Motorcycle();
myCar.HasFourWheels = true;
myCar.HasTrunk = true;
myMotorcycle.HasSideCar = false;
myMotorcycle.IsACruiser = true;
newCar.Make = "Ford";
newCar.Model = "Mustang";
newCar.Year = 2012;
newMoto.DriveAbstract();
vehicles.Add(myCar);
vehicles.Add(myMotorcycle);
vehicles.Add(newCar);
vehicles.Add(newMoto);
foreach (var vehicle in vehicles)
{
Console.WriteLine(vehicle.Make);
Console.WriteLine(vehicle.Model);
Console.WriteLine(vehicle.Year);
vehicle.DriveAbstract();
vehicle.DriveVirtual();
Console.WriteLine(" ");
Console.WriteLine(" ");
Console.WriteLine("********************");
}
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle,
* and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes -Done
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
Car car = new Car(2017, "Marcedenz", "Bnz", true);
Motorcycle motorcycle = new Motorcycle(2021, "Bike", "Bk", false);
Vehicle car1 = new Car(2001, "Toyota", "Camry", true);
Vehicle motorcycle1 = new Motorcycle(2018, "Mtbs", "Mt", true);
var vehicles = new List <Vehicle>();
vehicles.Add(car);
vehicles.Add(car1);
vehicles.Add(motorcycle);
vehicles.Add(motorcycle1);
foreach (Vehicle item in vehicles)
{
item.DriveAbstract();
item.DriveVirtual();
}
Console.WriteLine($"The number of cars are: {vehicles.Count()}");
//Console.WriteLine(car.Year = 2018);
//Console.WriteLine(car.Make = "Toyota");
//Console.WriteLine(car.Model = "Camry");
//Console.WriteLine(motorcycle.Year = 2010);
//Console.WriteLine(motorcycle.Make = "BMW");
//Console.WriteLine(motorcycle.Model = "BMW CSV");
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
// Console.ReadLine();
}
static void Main(string[] args)
{
#region Vehicles
/*
* DONE---Create an abstract class called Vehicle
* DONE---The vehicle class shall have three string properties Year, Make, and Model
* DONE--- Set the defaults to something generic in the Vehicle class
* DONE---Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE---Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/* DONE---
* DONE---Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE---Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONE---Provide the implementations for the abstract methods
* DONE---Only in the Motorcycle class will you override the virtual drive method
*/
/*
* DONE--- Create a list of Vehicle called vehicles
* DONE--- Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* DONE--- new it up as one of each derived class
* DONE---Set the properties with object initializer syntax
* DONE--- Add the 4 vehicles to the list
* DONE--- Using a foreach loop iterate over each of the properties
* DONE-- - Call each of the drive methods for one car and one motorcycle
*/
var vehicles = new List <Vehicle>();
Car focus = new Car()
{
HasTrunk = true, Make = "Jeep", Model = "Wrangler", Year = 2021
};
Motorcycle senke = new Motorcycle()
{
HasSideCart = false, Make = "Senke", Model = "Boda", Year = 2020,
};
Vehicle camry = new Car()
{
HasTrunk = false, Make = "Toyota", Model = "Camry", Year = 2009,
};
Vehicle dodge = new Car()
{
Make = "Dodge", Model = "Sedan", Year = 2006,
};
vehicles.Add(dodge);
vehicles.Add(camry);
vehicles.Add(senke);
vehicles.Add(focus);
foreach (var veh in vehicles)
{
Console.WriteLine($"Make: { veh.Make}, Model: { veh.Model}, Year: { veh.Year}. ");
veh.DriveAbstract();
Console.WriteLine("----------------------------------------");
}
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* DONE - Create an abstract class called Vehicle
* DONE - The vehicle class shall have three string properties Year, Make, and Model
* DONE - Set the defaults to something generic in the Vehicle class
* DONE - Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE - Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* DONE - Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE - Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONE - Provide the implementations for the abstract methods
* DONE -Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vechiles = new List <Vechile>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
var focus = new Car()
{
HasTrunk = true, Make = "Ford", Model = "Focus", Year = 2013
};
var motorcycle = new Motorcycle()
{
HasSideCart = true, Make = "HD", Model = "Chopper", Year = 1978
};
Vechile sedan = new Car()
{
Make = "Dodge", Model = "Blah", Year = 2019
};
Vechile sport = new Car()
{
HasTrunk = false, Make = "Ferari", Model = "Something", Year = 200
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vechiles.Add(focus);
vechiles.Add(motorcycle);
vechiles.Add(sedan);
vechiles.Add(sport);
foreach (var veh in vechiles)
{
Console.WriteLine($"Make {veh.Make} Model {veh.Model} Year {veh.Year}");
veh.DriveVirtual();
Console.WriteLine("-----------------------");
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car myCar = new Car()
{
HasTrunk = true,
Make = "Honda",
Model = "Fit",
Year = 2010
};
Motorcycle myMoto = new Motorcycle()
{
HasSideCart = false,
Make = "HD",
Model = "Chopper",
Year = 1978
};
Vehicle sedan = new Car()
{
Make = "Dodge",
Model = "Plymoth",
Year = 1992
};
Vehicle sport = new Car()
{
HasTrunk = false,
Make = "Chevrolet",
Model = "Corvette",
Year = 1978
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(myCar);
vehicles.Add(myMoto);
vehicles.Add(sedan);
vehicles.Add(sport);
foreach (var item in vehicles)
{
Console.WriteLine($"Make: {item.Make} Model: {item.Model} Year: {item.Year}");
item.DriveVirtual();
Console.WriteLine("---------------------------------------------");
}
// Call each of the drive methods for one car and one motorcycle
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Done - Create an abstract class called Vehicle
* Done - The vehicle class shall have three string properties Year, Make, and Model
* Done - Set the defaults to something generic in the Vehicle class
* Done - Vehicle shall have an abstract method called DriveAbstract with no implementation
* Done - Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Done - Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Done - Add a distinct property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Done - Provide the implementations for the abstract methods
* Done - Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
var car = new Car()
{
HasTrunk = true, Make = "BMW", Model = "650i", Year = 2012
};
var motorcycle = new Motorcycle()
{
HasSideCart = false, Make = "Honda", Model = "1000",
};
Vehicle accord = new Car()
{
Make = "Honda", Model = "Accord", Year = 2020
};
Vehicle benz = new Car()
{
Make = "Mercedez", Model = "S550", Year = 2018
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(car);
vehicles.Add(motorcycle);
vehicles.Add(accord);
vehicles.Add(benz);
foreach (var veh in vehicles)
{
Console.WriteLine($"Make: {veh.Make} Model: {veh.Model} Year: {veh.Year}");
veh.DriveAbstract();
Console.WriteLine("------------------------------");
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* DONE Create an abstract class called Vehicle
* DONE The vehicle class shall have three string properties Year, Make, and Model
* DONE Set the defaults to something generic in the Vehicle class
* DONE Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* DONE Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONE Provide the implementations for the abstract methods
* DONE Only in the Motorcycle class will you override the virtual drive method
*/
// DONECreate a list of Vehicle called vehicles
/*
* DONE Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* DONE Set the properties with object initializer syntax
*/
/*
* DONE Add the 4 vehicles to the list
* DONE Using a foreach loop iterate over each of the properties
*/
// DONE Call each of the drive methods for one car and one motorcycle
var vehicles = new List <Vehicle>();
var Xterra = new Car()
{
HasHatchBack = true, Make = "Nissan", Model = "Xterra", Year = 2011
};
Car Accord = new Car()
{
HasHatchBack = false, Make = "Honda", Model = "Accord", Year = 2000
};
var Motorcycle = new Motorcycle()
{
Make = "Kawasaki", Model = "Ninja", Year = 2006
};
Car ForRunner = new Car()
{
HasHatchBack = true, Make = "Toyota", Model = "ForRunner", Year = 2016
};
Vehicle SantaFe = new Car()
{
HasHatchBack = true, Make = "Hyundai", Model = "Santa Fe", Year = 2015
};
vehicles.Add(Xterra);
vehicles.Add(Accord);
vehicles.Add(ForRunner);
vehicles.Add(SantaFe);
vehicles.Add(Motorcycle);
foreach (var motor in vehicles)
{
Console.WriteLine($"Make: {motor.Make} Model: {motor.Model} Year: {motor.Year}");
motor.DriveVirtual();
Console.WriteLine("---------------------------------------------------------");
}
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
#region Vehicles
/*
* DONE* Create an abstract class called Vehicle
* DONE* The vehicle class shall have three string properties Year, Make, and Model
* DONE* Set the defaults to something generic in the Vehicle class
* DONE* Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* DONE* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONE* Provide the implementations for the abstract methods
* DONE* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* DONE* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* DONE* - new it up as one of each derived class
* DONE* Set the properties with object initializer syntax
*/
Car terrian = new Car()
{
HasTrunk = true, Make = "GMC", Model = "Terrain", Year = 2019
};
Motorcycle motorcycle = new Motorcycle()
{
HasSideCart = true, Make = "Harley", Model = "cool", Year = 2020
};
Vehicle sedan = new Car()
{
HasTrunk = false, Make = "Honda", Model = "Civic", Year = 2014
};
Vehicle sport = new Car()
{
HasTrunk = true, Make = "Chevy", Model = "Corevette", Year = 2008
};
vehicles.Add(terrian);
vehicles.Add(motorcycle);
vehicles.Add(sedan);
vehicles.Add(sport);
foreach (var veh in vehicles)
{
Console.WriteLine($"Make {veh.Make} Model {veh.Model} Year {veh.Year}");
veh.DriveAbstract();
}
/*
* DONE* Add the 4 vehicles to the list
* DONE* Using a foreach loop iterate over each of the properties
*
*
*/
// *DONE* Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* DONE - Create an abstract class called Vehicle
* DONE - The vehicle class shall have three string properties Year, Make, and Model
* DONE - Set the defaults to something generic in the Vehicle class
* DONE - Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE - Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* DONE - Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE - Add a distinct property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONE - Provide the implementations for the abstract methods
* DONE - Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list holding type Vehicle called vehicles
// do that here
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle,
* and then 2 instances of type Vehicle (use explicit typing) but use constructors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
//create a Car object and set values in its properties
var sedan = new Car()
{
HasTrunk = true, make = "Olds", model = "Cutlass", year = 1972
};
//create a MotorCycle object and set values in its properties
var motorcycle = new Motorcycle()
{
HasSideCart = true, make = "Honda", model = "550"
};
// twice - create an object of type vehicle with explicit typing: Vehicle whatever = new Car();
Vehicle sedan2 = new Car()
{
make = "Acura", model = "TL", year = 2002
};
Vehicle sedan3 = new Car()
{
make = "Toyota", model = "Corolla", year = 2003
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car item1 = new Car("2021", "Audi", "A4 2.0T", "Black", 4, true);
vehicles.Add(item1);
Motorcycle item2 = new Motorcycle("2021", "Susuki", "Katana", "Gold", false, "Sprot");
vehicles.Add(item2);
Vehicle item3 = new Car()
{
Year = "2019",
Make = "BMW",
Model = "6 Series 640i",
Color = "Glacier Silver",
numOfDoors = 2,
isSport = true
};
vehicles.Add(item3);
Vehicle item4 = new Car()
{
Year = "2020",
Make = "Dodge",
Model = "Challenger",
Color = "Pearl White",
numOfDoors = 2,
isSport = true
};
vehicles.Add(item4);
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
foreach (var product in vehicles)
{
Console.WriteLine($"Year: {product.Year} \n" +
$"Make: {product.Make} \n" +
$"Model: {product.Model} \n" +
$"Color: {product.Color}");
Console.WriteLine();
}
// Call each of the drive methods for one car and one motorcycle
item1.DriveAbstract();
item2.DriveVirtual();
item3.DriveVirtual();
item4.DriveAbstract();
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing)
* but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car mazda = new Car()
{
Make = "Mazda", Model = "Protege", Year = 2016
};
Motorcycle motor = new Motorcycle()
{
Make = "Suzuki", Model = "Posh", Year = 2030
};
Vehicle nissan = new Car();
Vehicle honda = new Motorcycle()
{
Year = 2020, Model = "Accord", Make = "Honda"
};
var vehicles = new List <Vehicle>();
// List<Vehicle> vehicles1 = new List<Vehicle>(); explicit typing.
vehicles.Add(mazda);
vehicles.Add(nissan);
vehicles.Add(honda);
vehicles.Add(motor);
foreach (var item in vehicles)
{
Console.WriteLine($"I have {vehicles.Count} vehicles in my list.Which are {item.Make} {item.Model}");
}
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
foreach (var vehicle in vehicles)
{
Console.WriteLine($" {vehicle.Make } {vehicle.Model} & {vehicle.Year}");
Console.WriteLine($" ");
}
// Call each of the drive methods for one car and one motorcycle
mazda.DriveAbstract();
mazda.DriveVirtual();
motor.DriveAbstract();
motor.DriveVirtual();
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
var vehicles = new List <Vehicle>();
var juansCar = new Car()
{
Year = 2021, Make = "Ford", Model = "Explorer"
};
var juansMotorcycle = new Motorcycle()
{
Year = 2019, Make = "Harley", Model = "Kt500"
};
Vehicle juanOneVehicle = new Car()
{
Year = 2017, Make = "Toyota", Model = "Camry"
};
Vehicle juanTwoVehicle = new Motorcycle()
{
Year = 2015, Make = "Honda", Model = "Ninja300"
};
vehicles.Add(juansCar);
vehicles.Add(juansMotorcycle);
vehicles.Add(juanOneVehicle);
vehicles.Add(juanTwoVehicle);
foreach (var vehicle in vehicles)
{
Console.WriteLine($"My {vehicle.Model} it's mark is {vehicle.Make} and it is of {vehicle.Year}");
}
juansCar.DriveAbstract();
juansCar.DriveVirtual();
juansMotorcycle.DriveAbstract();
juansMotorcycle.DriveVirtual();
juanOneVehicle.DriveAbstract();
juanOneVehicle.DriveVirtual();
juanTwoVehicle.DriveAbstract();
juanTwoVehicle.DriveVirtual();
/*
* Todo follow all comments!!
*/
#region Vehicles
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* DONE - Create an abstract class called Vehicle
* DONE - The vehicle class shall have three string properties Year, Make, and Model
* DONE - Set the defaults to something generic in the Vehicle class
* DONE - Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE - Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* DONE - Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE - Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONE - Provide the implementations for the abstract methods
* DONE -Only in the Motorcycle class will you override the virtual drive method
*/
// DONE - Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* DONE - Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* DONE - Set the properties with object initializer syntax
*/
Car fiesta = new Car()
{
HasTrunk = true, Make = "Ford", Model = "Fiesta", Year = "2010"
};
Motorcycle yamaha = new Motorcycle()
{
HasSideCar = false, Make = "Yamaha", Model = "Ninja", Year = "2015"
};
Vehicle GrandCherokee = new Car()
{
HasTrunk = false, Model = "Grand Cherokee", Year = "2018", Make = "Jeep"
};
Vehicle harley = new Motorcycle()
{
HasSideCar = true, Make = "Harley", Year = "2017", Model = "HardTail"
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(fiesta);
vehicles.Add(yamaha);
vehicles.Add(GrandCherokee);
vehicles.Add(harley);
foreach (var vehicle1 in vehicles)
{
Console.WriteLine($"Make {vehicle1.Make} Model {vehicle1.Model} Year {vehicle1.Year}");
Console.WriteLine(" ");
vehicle1.DriveAbstract();
Console.WriteLine("-------------------------------- ");
}
// DONE - Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle -- DONE
* The vehicle class shall have three string properties Year, Make, and Model -- Done
* Set the defaults to something generic in the Vehicle class -- DONE
* Vehicle shall have an abstract method called DriveAbstract with no implementation -- DONE
* Vehicle shall have a virtual method called DriveVirtual with a base implementation. -- DONE
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle -- DONE
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle -- DONE
* Provide the implementations for the abstract methods -- DONE
* Only in the Motorcycle class will you override the virtual drive method -- DONE
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car fusion = new Car()
{
Make = "Ford",
Model = "Fusion",
Year = 2019,
HasTrunk = true
};
Motorcycle harley = new Motorcycle()
{
Make = "Harley Davidson",
Model = "Street 750",
Year = 2020,
HasSideCart = false
};
Vehicle sedan = new Car()
{
Make = "Infinity",
Model = "Q70L",
Year = 2019,
HasTrunk = true
};
Vehicle muscle = new Car()
{
Make = "Dodge",
Model = "Viper",
Year = 2018,
HasTrunk = false
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(muscle);
vehicles.Add(sedan);
vehicles.Add(harley);
vehicles.Add(fusion);
foreach (var veh in vehicles)
{
Console.WriteLine($"Year: {veh.Year}");
Console.WriteLine($"Make: {veh.Make}");
Console.WriteLine($"Model: {veh.Model}");
veh.DriveAbstract();
veh.DriveVirtual();
Console.WriteLine();
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car van = new Car()
{
Make = "Ford", HasTrunk = true, CarType = "Van", Year = 2010,
};
Motorcycle bicycle = new Motorcycle()
{
NumOfWheels = 2
};
Vehicle truck = new Car();
Vehicle anActualSheep = new Motorcycle()
{
NumOfWheels = 0, GasMileage = 99999999
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(van);
vehicles.Add(truck);
vehicles.Add(bicycle);
vehicles.Add(anActualSheep);
foreach (var item in vehicles)
{
Console.WriteLine($"Make: {item.Make} Model: {item.Model} Year: {item.Year}");
item.DriveAbstract();
}
// Call each of the drive methods for one car and one motorcycle
anActualSheep.DriveVirtual();
van.DriveAbstract();
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicles>();
var ford = new Car();
ford.DriveAbstract();
ford.DriveVirtual();
ford.Make = "Ford";
ford.Model = "Mustang";
ford.Year = "2020";
var harley = new Motorcycle();
ford.DriveAbstract();
ford.DriveVirtual();
harley.Make = "Harley";
harley.Model = "Davidson";
vehicles.Add(harley);
vehicles.Add(ford);
var chevy = new Car()
{
Model = "Corvette",
Make = "Chevy",
HasTrunk = false
};
vehicles.Add(chevy);
foreach (var item in vehicles)
{
Console.WriteLine($"{item.Make} { item.Model} { item.Year}");
}
/*
* Create 4 instances, 1 Car, 1 Motorcycle, and then 2 Vehicles - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
/*
* Create 4 instances, 1 Car, 1 Motorcycle, and then 2 Vehicles - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* DONE Create an abstract class called Vehicle
* DONE The vehicle class shall have three string properties Year, Make, and Model
* DONE Set the defaults to something generic in the Vehicle class
* DONE Vehicle shall have an abstract method called DriveAbstract with no implementation
* DONE Vehicle shall have a virtual method called DriveVirtual with a base implementation.
* DONE
*/
/*
* DONE Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* DONE Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* DONEProvide the implementations for the abstract methods
* DONE Only in the Motorcycle class will you override the virtual drive method
*
*/
// Create a list of Vehicle called vehicles
// Done
var vehicles = new List <Vehicle>();
/*
* DONE Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* DONE - new it up as one of each derived class
* DONE Set the properties with object initializer syntax
*
*/
Car newCar = new Car()
{
HasTrunk = true,
Model = "3285i",
Make = "Bmw",
Year = 1993
};
Motorcycle motorcycle = new Motorcycle()
{
HasSideCart = true,
Make = "Harley",
Model = "Pink",
Year = 1999
};
Vehicle sedan = new Car()
{
Year = 2020,
Model = "Polaris",
Make = "GroundCrew 3s",
HasTrunk = true
};
Vehicle sport = new Car()
{
Year = 2003,
Make = "Convertible",
Model = "Ford Fusion",
HasTrunk = false
};
/*
* DONE Add the 4 vehicles to the list
* DONE Using a foreach loop iterate over each of the properties
*/
vehicles.Add(newCar);
vehicles.Add(motorcycle);
vehicles.Add(sedan);
vehicles.Add(sport);
foreach (var veh in vehicles)
{
Console.WriteLine($"Make {veh.Make} Model {veh.Model} Year {veh.Year}");
veh.DriveAbstract();
veh.DriveVirtual();
Console.WriteLine("----------------------------------------------");
}
// DONE Call each of the drive methods for one car and one motorcycle
motorcycle.DriveAbstract();
sport.DriveVirtual();
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Done: Create an abstract class called Vehicle
* Done: The vehicle class shall have three string properties Year, Make, and Model
* Done: Set the defaults to something generic in the Vehicle class
* Done: Vehicle shall have an abstract method called DriveAbstract with no implementation
* Done: Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Done: Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Done: Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Done: Provide the implementations for the abstract methods
* Done: Only in the Motorcycle class will you override the virtual drive method
*/
// Done: Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Done: Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Done: Set the properties with object initializer syntax
*/
Car focus = new Car()
{
HasTrunk = true, Make = "Ford", Model = "Focus", Year = 2010
};
Motorcycle motorcycle = new Motorcycle()
{
HasSidecart = true, Make = "Honda", Model = "XR 75", Year = 2000
};
Vehicle sedan = new Car()
{
HasTrunk = true, Make = "Volvo", Model = "S60", Year = 2007
};
Vehicle compact = new Car()
{
HasTrunk = false, Make = "Geo", Model = "Metro", Year = 1993
};
/*
* Done: Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(focus);
vehicles.Add(motorcycle);
vehicles.Add(sedan);
vehicles.Add(compact);
foreach (var veh in vehicles)
{
Console.WriteLine($"Make: {veh.Make}, Model: {veh.Model}, Year: {veh.Year}");
veh.DriveVirtual();
Console.WriteLine("---------------------------");
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
List <Vehicle> list = new List <Vehicle>();
Car sedan = new Car()
{
Make = "Toyota", Model = "Sierra", Year = 1999
};
Vehicle tricycle = new Motorcycle()
{
Make = "tricycle", Model = "Honda", HasSideCar = false
};
Vehicle sixWheel = new Car()
{
Make = "Chevy", Model = "truck"
};
Vehicle harley = new Motorcycle()
{
Make = "Harley", Model = "Thunder", Year = 2009
};
list.Add(sedan);
list.Add(tricycle);
list.Add(sixWheel);
list.Add(harley);
foreach (var item in list)
{
Console.WriteLine(item.ToString());
}
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
//car
var car1 = new Car()
{
HasTrunk = true, Make = "Ford", Model = "Focus", Year = 2013
};
//motorcycle
var motor1 = new Motorcycle()
{
HasSideCart = true, Make = "he", Model = "Chopper", Year = 1888
};
// 2 instances of type vehicle
Vehicle sedan = new Car()
{
Make = "Dodge", Model = "Blah", Year = 2000
};
Vehicle sport = new Car()
{
Make = "damn", Model = "Tesla", Year = 2015
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(sedan);
vehicles.Add(motor1);
vehicles.Add(car1);
vehicles.Add(motor1);
foreach (var vehicle in vehicles)
{
Console.WriteLine(vehicle.Make);
Console.WriteLine(vehicle.Model);
Console.WriteLine(vehicle.Year);
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
var vehicles = new List <Vehicle>();
Car c = new Car();
c.Name = "Car 1";
c.Year = "1990";
c.Make = "Honda";
c.Model = "Civic";
c.HasTrunk = true;
Motorcycle m = new Motorcycle();
m.Name = "Motorcycle 1";
m.Year = "2009";
m.Make = "Kawasaki";
m.Model = "Ninja";
m.HasSideCar = true;
Vehicle v1 = new Car();
v1.Name = "Vehicle 1";
v1.Year = "2016";
v1.Make = "Nissan";
v1.Model = "Rogue";
Vehicle v2 = new Motorcycle();
v2.Name = "Vehicle 2";
v2.Year = "1966";
v2.Make = "BMW";
v2.Model = "Bike";
vehicles.Add(c);
vehicles.Add(m);
vehicles.Add(v1);
vehicles.Add(v2);
foreach (var item in vehicles)
{
Console.WriteLine($"Here are the stats on {item.Name}:");
Console.WriteLine(item.Year);
Console.WriteLine(item.Make);
Console.WriteLine(item.Model);
Console.WriteLine("");
}
c.DriveAbstract();
Console.WriteLine("");
c.DriveVirtual();
Console.WriteLine("");
m.DriveAbstract();
Console.WriteLine("");
m.DriveVirtual();
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
// Call each of the drive methods for one car and one motorcycle
List <Vehicle> vehicle = new List <Vehicle>();
Car gavinCar = new Car();
gavinCar.hasTrunk = true;
gavinCar.make = "Buic";
gavinCar.model = "Laceern";
gavinCar.year = 2008;
Motorcycle gavinsMot = new Motorcycle();
gavinsMot.hasSideCart = false;
gavinsMot.make = "Harly";
gavinsMot.model = "Davison";
gavinsMot.year = 2000;
Car danniesCar = new Car();
danniesCar.hasTrunk = true;
danniesCar.year = 2012;
danniesCar.make = "Ford";
danniesCar.model = "Fushion";
Car bresCar = new Car();
bresCar.hasTrunk = true;
bresCar.year = 1999;
bresCar.make = "Chevy";
bresCar.model = "Cruiz";
gavinsMot.DriveVirtual();
gavinCar.DriveAbstract();
danniesCar.DriveAbstract();
bresCar.DriveAbstract();
vehicle.Add(gavinCar);
vehicle.Add(gavinsMot);
vehicle.Add(danniesCar);
vehicle.Add(bresCar);
Console.WriteLine("--------------------------------------------");
foreach (var item in vehicle)
{
Console.WriteLine($"Make: {item.make} , Model: {item.model} , Year: {item.year} ");
item.DriveAbstract();
item.DriveVirtual();
Console.WriteLine("//////////////////////////////////////");
}
{
}
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Done - Create an abstract class called Vehicle
* Done - The vehicle class shall have three string properties Year, Make, and Model
* Done - Set the defaults to something generic in the Vehicle class
* Done - Vehicle shall have an abstract method called DriveAbstract with no implementation
* Done - Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Done - Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Done - Add a distinct property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Done - Provide the implementations for the abstract methods
* Done - Only in the Motorcycle class will you override the virtual drive method
*/
// Done - Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Done - Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* Done - new it up as one of each derived class
* Done - Set the properties with object initializer syntax
*/
Car focus = new Car()
{
HasSeatBelts = true, Make = "Ford", Model = "Focus", Year = "2013"
};
Motorcycle motorcycle = new Motorcycle()
{
HasSideCar = false, Make = "Ace", Model = "XP-4", Year = "1923"
};
Vehicle sedan = new Car()
{
Make = "Dodge", Model = "Thingie", Year = "2019"
};
Vehicle sport = new Car()
{
HasSeatBelts = false, Make = "Ferrari", Model = "Fancy", Year = "2021"
};
/*
* Done - Add the 4 vehicles to the list
* Done - Using a foreach loop iterate over each of the properties
*/
vehicles.Add(sedan);
vehicles.Add(sport);
vehicles.Add(focus);
vehicles.Add(motorcycle);
foreach (var veh in vehicles)
{
Console.WriteLine($"{veh.Year} {veh.Make} {veh.Model}.");
//veh.DriveAbstract();
//veh.DriveVirtual();
//Console.WriteLine("__________________________________");
}
// Done - Call each of the drive methods for one car and one motorcycle
motorcycle.DriveVirtual();
sedan.DriveAbstract();
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car Golf = new Car()
{
HasTrunk = true, Year = 2016, Make = "Volkswagen", Model = "Golf"
};
Motorcycle Spider = new Motorcycle()
{
HasSideCart = false, Year = 2019, Make = "Kawasaki", Model = "Ninja"
};
vehicle Equinox = new Car()
{
Make = "GM", Model = "Equinox XL", Year = 2014
};
vehicle Altima = new Car()
{
HasTrunk = true, Make = "Nissan", Model = "Altima Sport", Year = 2015
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(Golf);
vehicles.Add(Spider);
vehicles.Add(Equinox);
vehicles.Add(Altima);
foreach (var item in vehicles)
{
Console.WriteLine($" Make {item.Make}, Model {item.Model} and Year {item.Year}");
item.DriveVirtual();
Console.WriteLine("---------------------------------------------");
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
static void Main(string[] args)
{
/*
* Todo follow all comments!!
*/
#region Vehicles
/*
* Create an abstract class called Vehicle
*
*
* The vehicle class shall have three string properties Year, Make, and Model
* Set the defaults to something generic in the Vehicle class
* Vehicle shall have an abstract method called DriveAbstract with no implementation
* Vehicle shall have a virtual method called DriveVirtual with a base implementation.
*/
/*
* Now create 2 non-abstract classes: Car and Motorcycle, that inherit from Vehicle
* Add a distict property in the 2 derived classes such as HasTrunk for Car and HasSideCart for Motorcycle
* Provide the implementations for the abstract methods
* Only in the Motorcycle class will you override the virtual drive method
*/
// Create a list of Vehicle called vehicles
var vehicles = new List <Vehicle>();
/*
* Create 4 instances: 1 Car, 1 Motorcycle, and then 2 instances of type Vehicle (use explicit typing) but use constuctors from derived classes
* - new it up as one of each derived class
* Set the properties with object initializer syntax
*/
Car focus = new Car()
{
HasTrunk = "Yes", Make = "Ford", Model = "Focus", Year = 2016,
};
Car civic = new Car()
{
HasTrunk = "No", Make = "Honda", Model = "Civic", Year = 2017,
};
Motorcycle harely = new Motorcycle()
{
HassideCart = "Yes", Make = "Davidson", Model = "Harley", Year = 2001,
};
Vehicle sedan = new Car()
{
HasTrunk = "Yes", Make = "Ford", Model = "Mustang", Year = 2001,
};
Vehicle sport = new Car()
{
HasTrunk = "No", Make = "Lexus", Model = "X90", Year = 2018,
};
/*
* Add the 4 vehicles to the list
* Using a foreach loop iterate over each of the properties
*/
vehicles.Add(focus);
vehicles.Add(civic);
vehicles.Add(harely);
vehicles.Add(sedan);
vehicles.Add(sport);
foreach (var item in vehicles)
{
Console.WriteLine($"-------------------------");
Console.WriteLine($"Make: {item.Make}, Model: {item.Make}, Year: {item.Year}");
item.DriveAbstract();
item.DriveVirtual();
}
// Call each of the drive methods for one car and one motorcycle
#endregion
Console.ReadLine();
}
