C#中的抽象类和静态类

在了解抽象类和静态类之前，先来复习C#中的构造和析构方法：

        所谓构造：就是指在调用某个类对某个变量进行实例化操作的时候所执行的方法操作，主要是用来赋值初始化。

        所谓析构：就是指当对某个类的变量进行销毁操作的时候所执行的函数，一般是在主函数结束，系统要回收内存的时候才调用析构函数。

using System;

namespace Lesson12_2
{
	//构造和析构

	public class Person {
		public string name;
		public int age;

		//构造方法 - 负责初始化对象
		//1.构造方法的方法名必须和类名一致
		//2.构造方法没有返回值 , 不需要写void
//		public Person (){
//			Console.WriteLine ("Hello");
//			//初始化对象
//			name = "dzzhyk";
//			age = 18;
//		}

		//3.构造方法能够添加参数(在构造的时候就需要参数)
//		public Person(string name , int age) {
//			//注意这里的参数中变量名也为name 和 age ， 需要和类里面的 name 和 age
//			//区分开，因此使用this
//			this.name = name;
//			this.age = age;
//			//this.变量是类里面的变量
//		}

//		//4.构造方法允许重载
//		public Person() {
//			name = "dzzhyk";
//			age = 18;
//		}
//		public Person(string name , int age) {
//			this.name = name;
//			this.age = age;
//		}

//		//5.如果没有给类添加构造方法， 系统会提供一个默认构造
//		public Person() {
//			
//		}

		//6.构造方法前的访问修饰符可以修改
		//  如果将某个构造方法设为私有的，就不允许再通过这个构造方法创建对象
		//private 
		private Person() {
			name = "dzzhyk";
			age = 18;
		}
		public Person(string name , int age) {
			this.name = name;
			this.age = age;
		}

		//析构方法 - 在对象销毁时调用，用于释放内存
		//1.每个类只能有一个析构方法
		//2.析构函数不能有返回值
		//3.析构函数没有访问权限修饰符 public等
		//4.析构函数不能带有参数，更不能重载
		//5.析构函数只有在对象销毁时系统自动调用，不能手动调用
		~Person (){
			Console.WriteLine ("析构");
		}
	}
	class MainClass
	{
		public static void Main (string[] args)
		{
			//	new 后面的 Person() 就是在调用构造方法，就是在创建 Person 这个对象的
			//		时候就已经调用了Person的方法，可以在创建的时候就初始化成员变量
			Person p = new Person ("dzzhyk",18);
			Console.WriteLine (p.name,p.age);
			Console.WriteLine ("主函数结束，接下来回收内存空间");
		}
	}
}

        其实就是在生成这个类的某个变量的同时执行构造函数，再生成这个变量。

在了解抽象类之前，得先知道继承的操作，另一篇文章有记录

C#抽象类：

当一个类定义为抽象类的时候（abstract），需要通过这个抽象类的子类来定义变量。

using System;

namespace Lesson15_2
{
	//抽象类
	//抽象类不能直接实例化，需要通过其他的子类来new一个变量
	public abstract class Food {
		//抽象方法需要添加 abstract 关键字
		//1.在父类中定义的抽象方法不能够实现，需要在语句的后面直接加 ;
		//2.抽象类只能出现在抽象方法中，因此需要在类的定义中加上 abstract 修饰符
		//3.抽象方法不能使用 private 的访问修饰符
		public abstract void eat ();

		//抽象类中可以包含普通的方法
		public void A(){
			Console.WriteLine ("抽象类中可以包含普通的方法");
		}
	}
	public class Apple : Food {

		//注意：子类在实现父类的抽象方法时，需要添加 Override 关键字
		//子类的抽象方法名称和父类的抽象方法名称相同
		public override void eat (){
			Console.WriteLine ("HP + 10");
		}
	}


	public class Water : Food {
		public override void eat (){
			Console.WriteLine ("MP + 10");
		}
	}
	class MainClass
	{
		public static void Main (string[] args)
		{
//			Apple a = new Apple ();
//			a.eat ();
			//抽象类的使用
			Food f1 = new Apple ();
			Food f2 = new Water ();
			f1.eat ();
			f2.eat ();
			//抽象类中可有普通的方法
			f1.A ();
		}
	}
}

从代码最后的 f1.A 可以看出：以一个抽象类为父类的变量照常可以使用抽象父类中的方法。

C#中的静态类：

在计算机的内存中有5个区域来执行程序运行的存储操作：
            //1. 堆区 - 需要程序员手动开辟并管理内存
            //2. 栈区 - 由系统自动完成内存管理
            //3. 静态区（全局区） - 程序运行过程中内存中的数据一直存在
            //4. 常量区 - 存放常量
            //5. 代码区 - 存放程序运行所需要的代码

其中，静态区就是存储静态类变量、方法的区域。

using System;

namespace Lesson16_2
{
	
	//静态类 static
	//静态类不能实例化，内容只能包含静态成员(字段、属性、方法)和const类型
	public static class B{
		const int x = 10;
		public static void A () {
			Console.WriteLine ("这是静态类B中的静态A方法");
		}
		//静态构造方法,注意静态构造方法之前 “不能 ”添加访问修饰符
		//静态构造方法会在首次访问类中的静态成员时调用，调用是在调用其它的方法之前
		static B (){
			Console.WriteLine ("静态构造方法");
		}
	}


	//静态构造方法可以存在于静态类中，也可以在普通类中
	public class A {
		//静态的字段、属性或者方法只能由类调用，不能由实例调用，调用的时候不需要实例化
		//使用类创建对象的过程叫做实例化，对象也可以称作实例
		//静态的成员一旦加载完成就会一直存在
		public static int i = 15;
		//静态方法 - 会在调用这个非静态类 A 中的静态成员（i）的时候执行
		static A (){
			Console.WriteLine ("这是非静态类中的静态构造方法的输出");
		}
		//普通方法
		public void test () {
			Console.WriteLine ("非静态类中的普通方法");	
		}
		//除了静态构造函数之外可以再写一个普通构造函数
		//这个构造函数的执行 需要实例化
		public A (){
			Console.WriteLine ("这是普通类中的普通构造函数");
		}
	}
	class MainClass
	{
		public static void Main (string[] args)
		{
			//内存中一共有五个区域
			//1. 堆区 - 需要程序员手动开辟并管理内存
			//2. 栈区 - 由系统自动完成内存管理
			//3. 静态区（全局区） - 程序运行过程中内存中的数据一直存在
			//4. 常量区 - 存放常量
			//5. 代码区 - 存放程序运行所需要的代码

			//可以直接使用类中的静态方法，不需要提前实例化
			//在使用静态方法的时候如果在静态类的定义中有静态构造函数，则先执行静态构造函数
			B.A ();
			//普通类中的静态成员变量的调用，如果在普通类中有静态构造函数，则先调用静态构造函数
			//调用普通类中的静态成员的时候也不需要先进行实例化
			Console.WriteLine ("普通类中的const常量i = "+ A.i);
			//调用普通类中的其他普通成员的时候还是要先进行实例化
			A a = new A ();
			a.test ();
		}
	}
}