в 15:31, 26 мая 2010

2010-05-26T15:31:18Z

Admin: 1 версия

2010-05-26T11:38:52Z

1 версия

Новая страница

==Abstract Classes and Methods==

<source lang="csharp">

using System;
abstract public class MotorVehicle {
public string make;
public string model;
public MotorVehicle(string make, string model) {
this.make = make;
this.model = model;
}
abstract public void Accelerate();
}
public class Product : MotorVehicle {
public Product(string make, string model) :
base(make, model) {
// do nothing
}
public override void Accelerate() {
Console.WriteLine("In Product Accelerate() method");
Console.WriteLine(model + " accelerating");
}
}

class MainClass {
public static void Main() {
Product myProduct = new Product("Toyota", "MR2");
myProduct.Accelerate();
}
}
</source>

==Bank Account class is abstract since there is no single implementation for Withdrawal==

<source lang="csharp">
using System;
public class MainClass {
public static void Main(string[] strings) {
SavingsAccount sa = new SavingsAccount();
sa.Withdrawal(100);
CheckingAccount ca = new CheckingAccount();
ca.Withdrawal(100);
}
}
abstract public class BankAccount {
abstract public void Withdrawal(double dWithdrawal);
}
public class SavingsAccount : BankAccount {
override public void Withdrawal(double dWithdrawal) {
Console.WriteLine("Call to SavingsAccount.Withdrawal()");
}
}
public class CheckingAccount : BankAccount {
override public void Withdrawal(double dWithdrawal) {
Console.WriteLine("Call to CheckingAccount.Withdrawal()");
}
}
</source>

==Create an abstract class==

<source lang="csharp">
/*
C#: The Complete Reference
by Herbert Schildt
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/

// Create an abstract class.

using System;

abstract class TwoDShape {
double pri_width; // private
double pri_height; // private
string pri_name; // private

// A default constructor.
public TwoDShape() {
width = height = 0.0;
name = "null";
}

// Parameterized constructor.
public TwoDShape(double w, double h, string n) {
width = w;
height = h;
name = n;
}

// Construct object with equal width and height.
public TwoDShape(double x, string n) {
width = height = x;
name = n;
}

// Construct an object from an object.
public TwoDShape(TwoDShape ob) {
width = ob.width;
height = ob.height;
name = ob.name;
}

// Properties for width, height, and name
public double width {
get { return pri_width; }
set { pri_width = value; }
}

public double height {
get { return pri_height; }
set { pri_height = value; }
}

public string name {
get { return pri_name; }
set { pri_name = value; }
}

public void showDim() {
Console.WriteLine("Width and height are " +
width + " and " + height);
}

// Now, area() is abstract.
public abstract double area();
}

// A derived class of TwoDShape for triangles.
class Triangle : TwoDShape {
string style; // private

// A default constructor.
public Triangle() {
style = "null";
}

// Constructor for Triangle.
public Triangle(string s, double w, double h) :
base(w, h, "triangle") {
style = s;
}

// Construct an isosceles triangle.
public Triangle(double x) : base(x, "triangle") {
style = "isosceles";
}

// Construct an object from an object.
public Triangle(Triangle ob) : base(ob) {
style = ob.style;
}

// Override area() for Triangle.
public override double area() {
return width * height / 2;
}

// Display a triangle"s style.
public void showStyle() {
Console.WriteLine("Triangle is " + style);
}
}

// A derived class of TwoDShape for rectangles.
class Rectangle : TwoDShape {
// Constructor for Rectangle.
public Rectangle(double w, double h) :
base(w, h, "rectangle"){ }

// Construct a square.
public Rectangle(double x) :
base(x, "rectangle") { }

// Construct an object from an object.
public Rectangle(Rectangle ob) : base(ob) { }

// Return true if the rectangle is square.
public bool isSquare() {
if(width == height) return true;
return false;
}

// Override area() for Rectangle.
public override double area() {
return width * height;
}
}

public class AbsShape {
public static void Main() {
TwoDShape[] shapes = new TwoDShape[4];

shapes[0] = new Triangle("right", 8.0, 12.0);
shapes[1] = new Rectangle(10);
shapes[2] = new Rectangle(10, 4);
shapes[3] = new Triangle(7.0);

for(int i=0; i < shapes.Length; i++) {
Console.WriteLine("object is " + shapes[i].name);
Console.WriteLine("Area is " + shapes[i].area());

Console.WriteLine();
}
}
}

</source>

==Demostrates the use of an abstract class, including an abstract method and abstract properties==

<source lang="csharp">
/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa
Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/
//
// Abstract.cs -- Demostrates the use of an abstract class, including
// an abstract method and abstract properties.
//
// Compile this program with the following command line:
// C:>csc Abstract.cs
//
namespace nsAbstract
{
using System;

public class AbstractclsMain
{
static public void Main ()
{
// Create an instance of the derived class.
clsDerived derived = new clsDerived (3.14159);
// Calling GetAbstract() actually calls the public method in the
// base class. There is no GetAbstract() in the derived class.
derived.GetAbstract();
}
}
// Declare an abstract class
abstract class clsBase
{
// Declare an abstract method. Note the semicolon to end the declaration
abstract public void Describe();
// Declare an abstract property that has only a get accessor.
// Note that you
// do not prove the braces for the accessor
abstract public double DoubleProp
{
get;
}
// Declare an abstract property that has only a set accessor.
abstract public int IntProp
{
set;
}
// Declare an abstract propety that has both get and set accessors. Note
// that neither the get or set accessor may have a body.
abstract public string StringProp
{
get;
set;
}
// Declare a method that will access the abstract members.
public void GetAbstract ()
{
// Get the DoubleProp, which will be in the derived class.
Console.WriteLine ("DoubleProp = " + DoubleProp);
// You can only set the IntProp value. The storage is in the
// derived class.
IntProp = 42;
// Set the StringProp value
StringProp = "StringProperty actually is stored in " +
"the derived class.";
// Now show StringProp
Console.WriteLine (StringProp);

// Finally, call the abstract method
Describe ();
}
}
// Derive a class from clsBase. You must implement the abstract members
class clsDerived : clsBase
{
// Declare a constructor to set the DoubleProp member
public clsDerived (double val)
{
m_Double = val;
}
// When you implement an abstract member in a derived class, you may not
// change the type or access level.
override public void Describe()
{
Console.WriteLine ("You called Describe() from the base " +
"class but the code body is in the \r\n" +
"derived class");
Console.WriteLine ("m_Int = " + m_Int);
}
// Implement the DoubleProp property. This is where you provide a body
// for the accessors.
override public double DoubleProp
{
get {return (m_Double);}
}
// Implement the set accessor for IntProp.
override public int IntProp
{
set {m_Int = value;}
}

// Implement StringProp, providing a body for both the get
// and set accessors.
override public string StringProp
{
get {return (m_String);}
set {m_String = value;}
}

// Declare fields to support the properties.
private double m_Double;
private int m_Int;
private string m_String;
}
}

</source>

==Illustrates abstract classes and methods==

<source lang="csharp">
/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
Example7_9.cs illustrates abstract classes and methods
*/
using System;

// declare the abstract MotorVehicle class
abstract class MotorVehicle
{
// declare the fields
public string make;
public string model;
// define a constructor
public MotorVehicle(string make, string model)
{
this.make = make;
this.model = model;
}
// declare the abstract Accelerate() method (no code)
abstract public void Accelerate();
}

// declare the Car class (derived from MotorVehicle)
class Car : MotorVehicle
{
// define a constructor
public Car(string make, string model) :
base(make, model)
{
// do nothing
}
// override the Accelerate() method (contains code)
public override void Accelerate()
{
Console.WriteLine("In Car Accelerate() method");
Console.WriteLine(model + " accelerating");
}
}

public class Example7_9
{
public static void Main()
{
// create a Car object
Console.WriteLine("Creating a Car object");
Car myCar = new Car("Toyota", "MR2");
// call the Car object"s Accelerate() method
Console.WriteLine("Calling myCar.Accelerate()");
myCar.Accelerate();
}
}

</source>

==Test abstract class==

<source lang="csharp">
/*
Learning C#
by Jesse Liberty
Publisher: O"Reilly
ISBN: 0596003765
*/
using System;
abstract class Window
{
// constructor takes two integers to
// fix location on the console
public Window(int top, int left)
{
this.top = top;
this.left = left;
}
// simulates drawing the window
// notice: no implementation
abstract public void DrawWindow();
protected int top;
protected int left;
}
// ListBox derives from Window
class ListBox : Window
{
// constructor adds a parameter
public ListBox(
int top,
int left,
string contents):
base(top, left) // call base constructor
{
listBoxContents = contents;
}
// an overridden version implementing the
// abstract method
public override void DrawWindow()
{
Console.WriteLine ("Writing string to the listbox: {0}",
listBoxContents);
}
private string listBoxContents; // new member variable
}
class Button : Window
{
public Button(
int top,
int left):
base(top, left)
{
}
// implement the abstract method
public override void DrawWindow()
{
Console.WriteLine("Drawing a button at {0}, {1}\n",
top, left);
}
}
public class TesterAbstractClass
{
static void Main()
{
Window[] winArray = new Window[3];
winArray[0] = new ListBox(1,2,"First List Box");
winArray[1] = new ListBox(3,4,"Second List Box");
winArray[2] = new Button(5,6);
for (int i = 0;i < 3; i++)
{
winArray[i].DrawWindow();
}
}
}

</source>

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)

Csharp/C Sharp/Class Interface/Abstract Class - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия