Csharp/CSharp Tutorial/Class/Class Definition
Содержание
- 1 A simple, but complete, C# class.
- 2 A Simple Class showing class definition syntax
- 3 A Simple Class with member fields and constrctor
- 4 C# Accessibility Keywords
- 5 Class can contain class
- 6 Class Fundamentals
- 7 Copy a class
- 8 Create two objects for one class
- 9 Declare an object of type Building
- 10 Encapsulation example
- 11 Extends class and implements interface
- 12 Implement multiple interfaces
- 13 Inherited member methods and fields
- 14 Reference to Base Class
- 15 The General Form of a Class
- 16 The modifiers can be applied to members of types, and have various uses.
- 17 Value Types: class vs struct
A simple, but complete, C# class.
<source lang="csharp">using System; class MainClass {
MainClass() {
Console.WriteLine("MainClass Constructor Called");
}
~MainClass() {
Console.WriteLine("MainClass Destructor Called");
}
void PrintAMessage(string msg) {
Console.WriteLine("PrintAMessage: {0}", msg);
}
void Dispose() {
GC.SuppressFinalize(this);
}
static void Main() {
Console.WriteLine("Top of function main");
MainClass app = new MainClass();
app.PrintAMessage("Hello from class");
Console.WriteLine("Bottom of function main");
app.Dispose();
}
}</source>
A Simple Class showing class definition syntax
<source lang="csharp">class MyClass {
int simpleValue = 0;
}</source>
A Simple Class with member fields and constrctor
<source lang="csharp">using System; class Point {
// constructor
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
// member fields
public int x;
public int y;
} class MainClass {
public static void Main()
{
Point myPoint = new Point(10, 15);
Console.WriteLine("myPoint.x {0}", myPoint.x);
Console.WriteLine("myPoint.y {0}", myPoint.y);
}
}</source>
myPoint.x 10 myPoint.y 15
C# Accessibility Keywords
<source lang="csharp">C# Access Modifier Meaning public Marks a member as accessible from an object variable and derived classes. private Marks a method as accessible only by the class that has defined the method.
In C#, all members are private by default.
protected Marks a method as usable by the defining class, and any derived classes.
Protected methods are not accessible from an object variable.
internal Defines a method that is accessible by any type in the same assembly, but not outside the assembly. protected internal Defines a method whose access is limited to the current assembly or types derived from the defining class in the current assembly.</source>
Class can contain class
<source lang="csharp">using System; public class Car {
private int maxSpeed;
private Radio theMusicBox = new Radio();
public Car()
{
maxSpeed = 100;
}
public void SwitchRadio(bool state)
{
theMusicBox.TurnOn(state);
}
} public class Radio {
public void TurnOn(bool on)
{
if(on)
Console.WriteLine("ON...");
else
Console.WriteLine("OFF...");
}
} public class MainClass {
public static void Main(string[] args)
{
// Make a car.
Car c1 = new Car();
c1.SwitchRadio(true);
c1.SwitchRadio(false);
}
}</source>
ON... OFF...
Class Fundamentals
- A class is a template that defines the form of an object.
- A class specifies both the data and the code that will operate on that data.
- Objects are instances of a class.
- The methods and variables that constitute a class are called members of the class.
7.1.Class Definition 7.1.1. Class Fundamentals 7.1.2. <A href="/Tutorial/CSharp/0140__Class/TheGeneralFormofaClass.htm">The General Form of a Class</a> 7.1.3. <A href="/Tutorial/CSharp/0140__Class/ASimpleClassshowingclassdefinitionsyntax.htm">A Simple Class showing class definition syntax</a> 7.1.4. <A href="/Tutorial/CSharp/0140__Class/AsimplebutcompleteCclass.htm">A simple, but complete, C# class.</a> 7.1.5. <A href="/Tutorial/CSharp/0140__Class/ASimpleClasswithmemberfieldsandconstrctor.htm">A Simple Class with member fields and constrctor</a> 7.1.6. <A href="/Tutorial/CSharp/0140__Class/DeclareanobjectoftypeBuilding.htm">Declare an object of type Building</a> 7.1.7. <A href="/Tutorial/CSharp/0140__Class/Createtwoobjectsforoneclass.htm">Create two objects for one class</a> 7.1.8. <A href="/Tutorial/CSharp/0140__Class/Copyaclass.htm">Copy a class</a> 7.1.9. <A href="/Tutorial/CSharp/0140__Class/Encapsulationexample.htm">Encapsulation example</a> 7.1.10. <A href="/Tutorial/CSharp/0140__Class/Classcancontainclass.htm">Class can contain class</a> 7.1.11. <A href="/Tutorial/CSharp/0140__Class/Inheritedmembermethodsandfields.htm">Inherited member methods and fields</a> 7.1.12. <A href="/Tutorial/CSharp/0140__Class/ReferencetoBaseClass.htm">Reference to Base Class</a> 7.1.13. <A href="/Tutorial/CSharp/0140__Class/Implementmultipleinterfaces.htm">Implement multiple interfaces</a> 7.1.14. <A href="/Tutorial/CSharp/0140__Class/Extendsclassandimplementsinterface.htm">Extends class and implements interface</a> 7.1.15. <A href="/Tutorial/CSharp/0140__Class/CAccessibilityKeywords.htm">C# Accessibility Keywords</a> 7.1.16. <A href="/Tutorial/CSharp/0140__Class/Themodifierscanbeappliedtomembersoftypesandhavevarioususes.htm">The modifiers can be applied to members of types, and have various uses.</a> 7.1.17. <A href="/Tutorial/CSharp/0140__Class/ValueTypesclassvsstruct.htm">Value Types: class vs struct</a>
Copy a class
<source lang="csharp">using System;
class MyClass {
public int x;
}
class MainClass {
public static void Main() {
MyClass a = new MyClass();
MyClass b = new MyClass();
a.x = 10;
b.x = 20;
Console.WriteLine("a.x {0}, b.x {1}", a.x, b.x);
a = b;
b.x = 30;
Console.WriteLine("a.x {0}, b.x {1}", a.x, b.x);
}
}</source>
a.x 10, b.x 20 a.x 30, b.x 30
Create two objects for one class
<source lang="csharp">using System;
class Building {
public int area; public int occupants;
}
class BuildingDemo {
public static void Main() {
Building house = new Building();
Building office = new Building();
int areaPP; // area per person
house.occupants = 4;
house.area = 2500;
office.occupants = 25;
office.area = 4200;
areaPP = house.area / house.occupants;
Console.WriteLine("house has:\n " +
house.occupants + " occupants\n " +
house.area + " total area\n " +
areaPP + " area per person");
Console.WriteLine();
areaPP = office.area / office.occupants;
Console.WriteLine("office has:\n " +
office.occupants + " occupants\n " +
office.area + " total area\n " +
areaPP + " area per person");
}
}</source>
house has: 4 occupants 2500 total area 625 area per person office has: 25 occupants 4200 total area 168 area per person
Declare an object of type Building
<source lang="csharp">using System;
class Building {
public int floors; public int area; public int occupants;
}
class BuildingDemo {
public static void Main() {
Building house = new Building(); // create a Building object
int areaPP;
house.occupants = 4;
house.area = 2500;
house.floors = 2;
areaPP = house.area / house.occupants;
Console.WriteLine("house has:\n " +
house.floors + " floors\n " +
house.occupants + " occupants\n " +
house.area + " total area\n " +
areaPP + " area per person");
}
}</source>
house has: 2 floors 4 occupants 2500 total area 625 area per person
Encapsulation example
<source lang="csharp">class MyRectangle {
private uint width;
private uint height;
private uint area;
public uint Width
{
get
{
return width;
}
set
{
width = value;
ComputeArea();
}
}
public uint Height
{
get
{
return height;
}
set
{
height = value;
ComputeArea();
}
}
public uint Area
{
get
{
return area;
}
}
private void ComputeArea()
{
area = width * height;
}
}</source>
Extends class and implements interface
<source lang="csharp">using System; using System.Collections.Generic; using System.Text; interface Talkable {
string Table();
} class Animal { } class Cat : Animal, Talkable {
string Talkable.Table() {
return "miao";
}
} class Dog : Animal, Talkable {
string Talkable.Table(){
return "bulk";
}
} class Elephant : Animal {
} class MainClass {
static void Main()
{
Animal[] AnimalArray = new Animal[3];
AnimalArray[0] = new Cat();
AnimalArray[1] = new Elephant();
AnimalArray[2] = new Dog();
foreach (Animal a in AnimalArray)
{
Talkable b = a as Talkable;
if (b != null)
Console.WriteLine("Baby is called: {0}", b.Table());
}
}
}</source>
Baby is called: miao Baby is called: bulk
Implement multiple interfaces
<source lang="csharp">using System; interface Getter {
int GetData();
} interface Setter {
void SetData(int x);
} class MyData : Getter, Setter {
int data;
public int GetData() {
return data;
}
public void SetData(int x) {
data = x;
}
} class MainClass {
static void Main()
{
MyData data = new MyData();
data.SetData(5);
Console.WriteLine("Value = {0}", data.GetData());
}
}</source>
Value = 5
Inherited member methods and fields
<source lang="csharp">using System; class BaseClass {
public string Field1 = "base class field";
public void Method1(string value)
{
Console.WriteLine("Base class -- Method1: {0}", value);
}
} class DerivedClass : BaseClass {
public string Field2 = "derived class field";
public void Method2(string value)
{
Console.WriteLine("Derived class -- Method2: {0}", value);
}
} class MainClass {
static void Main()
{
DerivedClass oc = new DerivedClass();
oc.Method1(oc.Field1); // Base method with base field
oc.Method1(oc.Field2); // Base method with derived field
oc.Method2(oc.Field1); // Derived method with base field
oc.Method2(oc.Field2); // Derived method with derived field
}
}</source>
Base class -- Method1: base class field Base class -- Method1: derived class field Derived class -- Method2: base class field Derived class -- Method2: derived class field
Reference to Base Class
<source lang="csharp">using System; class BaseClass {
public void Print()
{
Console.WriteLine("This is the base class.");
}
} class DerivedClass : BaseClass {
new public void Print()
{
Console.WriteLine("This is the derived class.");
}
} class Program {
static void Main()
{
DerivedClass derived = new DerivedClass();
BaseClass mybc = (BaseClass)derived;
derived.Print();
mybc.Print();
}
}</source>
This is the derived class. This is the base class.
The General Form of a Class
A class is created by use of the keyword class.
The general form of a class definition that contains only instance variables and methods:
<source lang="csharp">class classname {
// declare instance variables
access type var1;
access type var2;
// ...
access type varN;
// declare methods
access ret-type method1(parameters) {
// body of method
}
access ret-type method2(parameters) {
// body of method
}
// ...
access ret-type methodN(parameters) {
// body of method
}
}</source>
The modifiers can be applied to members of types, and have various uses.
<source lang="csharp">Modifier Applies To Description new Function members hides an inherited member with the same signature. static All members does not operate on a specific instance of the class. virtual Classes and function members only can be overridden by a derived class. abstract Function members only A virtual member that defines the signature of the member, but doesn"t provide an implementation. override Function members only overrides an inherited virtual or abstract member. sealed Classes overrides an inherited virtual member, but cannot be overridden by any classes that inherit from this class. extern static [DllImport] methods only implemented externally, in a different language.</source>
Value Types: class vs struct
<source lang="csharp">using System;
class EntryPoint
{
static void Main(string[] args)
{
TemperatureStruct ts = new TemperatureStruct();
TemperatureStruct tp = new TemperatureStruct();
TemperatureClass tc = new TemperatureClass();
Console.Write( "Enter degrees in Celsius: " );
string celsius = Console.ReadLine();
ts.Celsius = Convert.ToDouble(celsius);
Console.WriteLine( "Temperature in Fahrenheit = {0}", ts.Fahrenheit );
}
}
class TemperatureClass
{
private double degreesCelsius;
public double Fahrenheit
{
get
{
return ((9d/5d)*degreesCelsius)+32;
}
set
{
degreesCelsius = (5d/9d)*(value-32);
}
}
public double Celsius
{
get
{
return degreesCelsius;
}
set
{
degreesCelsius = value;
}
}
}
struct TemperatureStruct
{
public double Celsius;
public double Fahrenheit
{
get
{
return ((9d/5d)*Celsius)+32;
}
set
{
Celsius = (5d/9d)*(value-32);
}
}
}</source>
