【结构】
语法:
结构修饰符 struct 结构名
{
}
class Program
{
public struct Rect//定义一个矩形结构
{
public double width;//矩形的宽
public double height;//矩形的高
/// <summary>
/// 构造函数,初始化矩形的宽和高
/// </summary>
/// <param name="x">矩形的宽</param>
/// <param name="y">矩形的高</param>
public Rect(double x, double y)
{
width = x;
height = y;
}
/// <summary>
/// 计算矩形面积
/// </summary>
/// <returns>矩形面积</returns>
public double Area()
{
return width * height;
}
}
static void Main(string[] args)
{
Rect rect1;//创建矩形结构
rect1.width = 5;//为矩形宽赋值
rect1.height = 3;//为矩形高赋值
Console.WriteLine("矩形面积为:" + rect1.Area());
Rect rect2 = new Rect(6, 4);//使用构造函数实例化矩形结构
Console.WriteLine("矩形面积为:" + rect2.Area());
}
}
【构造函数】
定义一个类之后,C#就会隐式的创建一个默认的构造函数,如果想创建多个构造函数,就得把默认的构造函数显式的写出来。
class Program
{
public int x = 3;//定义int型变量,作为加数
public int y = 5;//定义int型变量,作为被加数
public int z = 0;//定义int型变量,记录加法运算的和
public Program()
{
z = x + y;//在构造函数中为和赋值
}
static void Main(string[] args)
{
Program program = new Program();//使用构造函数实例化Program对象
Console.WriteLine("结果:" + program.z);//使用实例化的Program对象输出加法运算的和
}
}
【析构函数】
相当于垃圾回收。
当某个类的实例被看作无效,并且满足析构条件时,就会直接调用析构函数。
一个类只能有一个析构函数,并且无法调用析构函数,他是自动调用的。
class Program
{
~Program() //析构函数
{
Console.WriteLine("析构函数自动调用");//输出一个字符串
}
static void Main(string[] args)
{
Program program = new Program();//实例化Program对象
}
}
输出结果为“析构函数自动调用”
【类的面向对象特性】
1.类的封装
以类作为数据封装的基本单位,可以使数据和方法封装成单一元素。
/// <summary>
/// 自定义类,封装加数和被加数属性
/// </summary>
class MyClass
{
private int x = 0;//定义int型变量,作为加数
private int y = 0;//定义int型变量,作为被加数
/// <summary>
/// 加数
/// </summary>
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
/// <summary>
/// 被加数
/// </summary>
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
/// <summary>
/// 求和
/// </summary>
/// <returns>加法运算和</returns>
public int Add()
{
return X + Y;
}
}
class Program
{
static void Main(string[] args)
{
MyClass myclass = new MyClass();//实例化MyClass的对象
myclass.X = 3;//为MyClass类中的属性赋值
myclass.Y = 5;//为MyClass类中的属性赋值
Console.WriteLine(myclass.Add());//调用MyClass类中的Add方法求和
Console.ReadLine();
}
}
2.类的继承
任何类都可以从另外一个类继承,这个类拥有它继承的类的所有成员。被继承的类称为父类或基类。C#只支持单继承不支持多重继承,多重继承由接口来实现。
/// <summary>
/// 自定义类
/// </summary>
class MyClass1
{
private int x = 0;//定义int型变量,作为加数
private int y = 0;//定义int型变量,作为被加数
/// <summary>
/// 加数
/// </summary>
public int X
{
get
{
return x;
}
set
{
x = value;
}
}
/// <summary>
/// 被加数
/// </summary>
public int Y
{
get
{
return y;
}
set
{
y = value;
}
}
/// <summary>
/// 求和
/// </summary>
/// <returns>加法运算和</returns>
public int Add1()
{
return X + Y;
}
}
/// <summary>
/// 自定义类,该类继承自MyClass1
/// </summary>
class MyClass2 : MyClass1
{
private int z = 0;//定义int型变量,作为第二个被加数
/// <summary>
/// 被加数
/// </summary>
public int Z
{
get
{
return z;
}
set
{
z = value;
}
}
/// <summary>
/// 求和
/// </summary>
/// <returns>加法运算和</returns>
public int Add2()
{
return X + Y + Z;
}
}
class Program
{
static void Main(string[] args)
{
MyClass1 myclass1 = new MyClass1(); //实例化MyClass1的对象
MyClass2 myclass2 = new MyClass2(); //实例化MyClass2的对象
myclass1.X = 3; //为MyClass1类中的属性赋值
myclass1.Y = 5; //为MyClass1类中的属性赋值
myclass2.X = 3; //使用MyClass2类对象调用基类中的属性并赋值
myclass2.Y = 5; //使用MyClass2类对象调用基类中的属性并赋值
myclass2.Z = 7; //为MyClass2类中的属性赋值
Console.WriteLine(myclass1.Add1()); //调用MyClass1类中的Add1方法求和
Console.WriteLine(myclass2.Add1()); //使用MyClass2类对象调用基类中的方法
Console.WriteLine(myclass2.Add2()); //调用MyClass2类中的Add2方法求和
}
}
3.类的多态
比如说一个学生类,可以有多个子类,小学生类、中学生类、大学生类等等。
这里就可以说成,小学生是学生。
class Myclass1
{
}
class Myclass2
{
}
Myclass2 c2 = new Myclass2();
Myclass1 c1 = (Myclass1)Myclass2;//使用子类的对象实例化基类的对象
这里c1其实仍然指向的是Myclass2。如果用c1调用类中的方法的话,还是调用的Myclass2中的方法。