C#Lesson10 抽象类与静态类

抽 象 类

抽象方法：在面向对象编程语言中抽象方法是指一些只有方法的声明而没有具
体实现的方法
抽象方法使用关键字abstract关键字修饰，这种方法只能声明返回值类型，方
法名以及参数列表，没有方法体。
格式：访问修饰符 abstract 方法名(参数列表);

注意⚠：

当一个类当中的存在抽象方法时，该类必须也使用abstract修饰

抽象方法特性

1. 抽象方法是隐式的虚方法
2. 抽象方法只能有声明不提供实际的实现
3. 只允许在抽象类中使用抽象方法声明
4. 抽象方法必须被子类重写并实现，否则其子类依旧为抽象类
5. 抽象方法不使用static或virtual修饰

抽象方法作用

抽象方法的意义在于规定基类的派生类当中必须拥有这样的功能，或者
是提供这样子的服务，但是实现该功能的方式会因为子类的不同而结构
不同。

注意⚠：

抽象方法的访问修饰符不能为private。因为抽象方法必须被派生类重写，派生类必须能够访问到

abstract关键字

1. abstract修饰符指示所修饰的内容缺少实现或未完全实现。
2. abstract可以用来修饰类，方法，属性，索引器和事件。
3. 在类的声明中使用abstract来修饰类表示该类为抽象类，只能是其他类的基类
4. 利用abstract关键字可以将方法声明抽象到父类当中，而方法的实现实现留在子类，更好的体现“共性放在父类”的原则。

抽象类

抽象类是用来表征对问题，对象的分析，设计出来的抽象概念，是一
系列看上去不同，但是本质上相同的具体概念抽象。
抽象类在类的声明当中使用abstract关键字修饰。
格式：
类访问修饰符 abstract class 类名{ 类成员 }

抽象类的特性

1. 抽象类不能使用new关键字进行实例化，抽象类是不完整的，只能作为基类被其他类继承
2. 抽象类除了可以拥有普通类成员外还可以有抽象方法
3. 从抽象类派生的非抽象类必须实现抽象类当中的所有抽象方法
4. 抽象类不能被实例化但可以有构造方法，构造方法不能为抽象方法
5. 不能使用sealed修饰符修饰抽象类，因为采用sealed修饰符的类是无法被继承的，而抽象类是必须被继承的

抽象类的使用

抽象类不能实例化，必须被子类继承。当抽象类当中有抽象方法时必须重写抽象方法。

总结

1. 抽象类与抽象方法都使用abstract关键字修饰
2. 抽象方法必须存在于抽象类当中，抽象类中可以有抽象方法也可以
没有抽象方法
3. 抽象类不可以实例化，但是可以有构造方法
4. 为了更好的体现“共性放在父类”原则，当同一方法在不同类当中
有不同实现时，就可以将该方法抽象到某个抽象类当中

--------------------------------------------------------------------------------------------------------------------------

静 态 类

静态成员

静态成员：静态成员变量是和类相关联的，可以作为类中“共”有的变量
(是一个共性的表现)，静态成员不依赖特定对象的存在，访问的时候通过
类来操作的。
静态成员使用static关键字修饰。

访问静态成员采用类名加点操作加静态成员

静态方法与实例方法的访问权限表

静态成员的特点

1.静态成员随着类的加载而加载，无论对一个类创建多少个实例，静态
成员都只有一个副本
2.静态方法可以被重载但不能被重写，因为他们是属于类，不属于任何
实例的
3.静态成员由类名通过点语法调用，非静态成员是由对象来调用
4.静态方法只能访问静态成员，包括静态成员变量和静态方法；实例方
法可以访问实例成员变量与实例方法，也可以访问静态成员

静态类的介绍

静态类用于创建无需创建类的实例就能访问的数据和函数，静态类只
能包含静态成员，不可以包含非静态成员。静态成员用于分离独立任
何对象标识的数据和行为：无论对象发生任何改变，这些数据和函数
都不会随之变化。
静态类使用static关键字修饰
格式：类修饰符 static 类名{ 静态成员 }

静态类特性

1. 静态类只能包含静态成员，不能包含非静态成员
2. 静态类无法实例化
3. 静态类是密封的，无法被继承
4. 静态不能包含有实例构造函数

静态构造函数

静态类不能有实例化构造函数，但是可以有静态构造函数。静态构造函
数用于初始化任何静态数据或用于执行仅需要执行一次的特定操作
格式：
static 类名(){ //初始化静态数据或执行其他操作
}

静态构造函数调用

静态构造函数无法像实例构造函数那样通过某一个关键字调用。静
态构造函数不可被直接调用，当创建类实例或引用任何静态成员之
前，静态构造函数会被调用。比如访问静态类Mathf当中的
mainFunc或是创建非静态类Hero实例都会调用类中的静态构造函
数。

静态构造函数特性

1. 静态构造函数是固定格式，不能有修饰符，不能带任何参数
2. 一个类只能有一个静态构造函数，即静态构造函数不可以重载
3. 静态构造函数不可被直接调用，当创建类实例或引用任何静态成
员之间，静态构造函数会被自动调用，并且只执行一次
4. 一个类的静态构造函数在它的所有派生类的静态构造函数执行之后执行

---------------------------------------------------------------------------------------------------------------------

单 例

单例模式

对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可能
存在多个打印任务，但是只能有一个正在工作的任务。针对这种情况如果
某个类只能有一个实例那么则满足我们的需求，我们将满足某个类只有一
个实例的代码设计方式称为单例模式。
单例模式的三要点：
（1）某个类只能有一个实例
（2）必须自行创建这个实例
（3）必须自行向外界提供这个实例

单例模式实现步骤

1. 默认构造使用private修饰
2. 内建该类的静态实例
3. 静态构造方法中给该静态实例做初始化
4. 对外提供获取该静态实例的方法

单例模式代码实现步骤

public class SingleTon
{
private SingleTon (){} //构造方法必须私有化
private static SingleTon instance; //定义静态实例
static SingleTon(){//静态构造函数中对静态实例进行初始化
instance = new SingleTon ();
}
public static SingleTon Instance{//对外提供获取该实例的接口
get{
if (instance == null) {
instance = new SingleTon ();
}
return instance;
}
}
}

单例的作用

单例模式是资源管理的必备模式，单例类只有一个实例对象，因此可
以通过该实例对象获取到管理的资源。
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保
所有对象都访问唯一实例。
因为类控制了实例化过程，所以类可以灵活更改实例化过程。
单例类能够节省大量创建对像的过程，从而节省内存开销。

--------------------------------------------------------------------------------------------------------------------------------

主函数

using System;

namespace Lesson10_1
{
	class MainClass
	{
		public static void Main (string[] args)
		{
//			Player p1 = new FootBallPlayer ();
//			p1.Practice ();
//			Class3 c3 = new Class3();
//			c3.Practice ();

//			Class2 c2 = new Class3 ();
//
		}
	}


	public abstract class Class4{
		public abstract void T1();
		public abstract void T2();
	}

	public abstract class Class5:Class4{
		public override void T1 ()
		{
			
		}
	}

	//部分重写
	public class Class6:Class5{
		public override void T2 ()
		{
			
		}
	}



	//---------------------------------------------------------------------------------------
//	public class Class1{
//		public string name;
//		public Class1(){
//			Console.WriteLine ("这是Class1的构造方法");
//		}
//		public void Practice(){
//			Console.WriteLine ("这是Class1的Practice方法");
//		}
//	}
//
//	//抽象类继承至非抽象类
//	public abstract class Class2:Class1{
//		public Class2(){
//			Console.WriteLine ("这是Class2的构造方法");
//		}
//		public Class2(string name){
//			this.name = name;
//		}
//	}
//
//	public class Class3:Class2{
//		public Class3(){
//			Console.WriteLine ("这是Class3的构造方法");
//		}
//	}
//




	//------------------------------------------------------------------------------
	//密封类无法派生子类
//	public sealed class Home{
//	}
//
//	public class BigHome:Home{
//
//	}

	//抽象类(无法实例化的)
	/*
	 * 1.抽象类不能为密封类
	*/
//	public abstract class Player{
//		public string name;
//		protected int age;
//		public Player(){
//			Console.WriteLine ("这个是Player抽象类的构造函数");
//		}
//		public abstract int Age {
//			get;
//			set;
//		}
//		//抽象方法必须定义在抽象类中
//		public abstract void Practice();
//	}
//
//	public class FootBallPlayer:Player{
//		public override int Age {
//			get {
//				return age;
//			}
//			set {
//				age = value;
//			}
//		}
//		public override void Practice ()
//		{
//			Console.WriteLine ("踢足球");
//		}
//	}
}