关于C#中抽象类与接口的看法与理解

1.抽象类：一种特殊的类，除了不能被实例化以外，具有类的其他特征；而且还可以包括其他方法，这是普通类所做到的。抽象方法只能存在与抽象类中，而且必须使用关键字abstract关键字修饰，只能声明返回值类型，方法名以及参数列表，没有方法体。抽象类可以派生自己自一个抽象类，可以覆盖基类的方法也可以不覆盖。如果不覆盖，则其派生类必须覆盖它们。

2.接口:接口是引用类型,默认访问修饰符为"public",用"interface"关键子进行声明。在接口中声明未实现方法只声明其方法名和返回值类型如:"void Math();"。接口除了可以声明方法以外，还可以声明包括属性、索引器、事件,而且这些成员都被定义为共有的。除此之外不能包含任何成员。

3.抽象类与接口的相同点:1.都不能被实例化2.都包含未实现的方法的声明。派生类都必须实现其未实现的方法与其他成员。3.都不能被密封

4.抽象类与接口区别:

1.抽象类可以理解为其对象为类，也接口只是一个行为或者功能的规范。抽象类更多的定义在一系列关系紧密的类间，而接口大多数是在一些关系稀疏但都实现某一功能的类中。

2.接口基本上不具备类的任何特点它仅仅声明了能够调用和继承的方法，而抽象类不一样。

3.一个类一次只能继承一个抽象类，但能实现多个接口。

4.接口支持回调但是抽象类不支持。

5.抽象类实现的具体方法默认是虚方法,但接现接口的类中的接口方法默认为非虚的

6.抽象类实现的具体方法默认是虚方法,但接现接口的类中的接口方法默认为是非虚的。

5.抽象类和接口的使用

1.如果预计要创建组件的多个版本，则创建抽象类。由他提供简单的方法来控制组件版本。

2.如果创建的功能将在大范围的全异对象间使用，则使用接口，设计小而简练的代码块也使用接口较好。

3.抽象类主要用于关系密切的对象，而接口多用于不相关的类提供通用功能。

using System;

namespace 接口
{   
	public interface ISpeak{
		void ISpeak();
	}
	public interface IArea{
		void IArea();
	}
	public interface IVolumn:IArea{
		void IVolumn();
	}

	public class Baby:ISpeak
	{
		public void ISpeak ()
		{
			Console.WriteLine ("说话");
		}
		public Baby ()
		{
		}
	}
	public class ball:IVolumn{
		public int radius;
		public void IVolumn ()
		{
			Console.WriteLine ("体积:{0}",4/3*3.14*radius*radius*radius);
		}

		public void IArea ()
		{
			Console.WriteLine  ("表面积:{0}",4*radius*3.14*radius);
		}

		
	}
}
using System;

namespace 抽象类与抽象方法
{
	class MainClass
	{
		public static void Main (string[] args)
		{
//			Play p = new FootBallPlay ();
//			p.Practice ();
//			Class3 class3 = new Class3();
//			class3.Pratatic ();
			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 ()
		{
			Console.WriteLine ("重写T1");
		}
	}
	//如果部分实现抽象类的方法
	public abstract class Class6:Class5{
		public override void T2 ()
		{
			Console.WriteLine ("重写T2");
		}
	}
	//-----------------------------------------------------
	public class Class1{
		public string name;
		public Class1(){
			Console.WriteLine ("这个是Class1的构造方法");
		}
		public void Pratatic(){
			Console.WriteLine ("这个是Class1的Pratatic方法");
		}
	}
	//抽象类继承自非抽象类
	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 Emplyee{
		public	string name;
		public	int ID;
		public abstract int CalculateSalary();
		public abstract void WorkContent();
		public  void MakeMoney(){
			Console.WriteLine ("赚钱");
		}

	}
	public class Manager:Emplyee{
		public override int  CalculateSalary ()
		{
			return 100;
		}
		public override void WorkContent ()
		{
			Console.WriteLine ("搭建游戏平台");
		}
	}
	public abstract class Play
	{   
		public string name;
		protected int age;
		public Play()
		{
			Console.WriteLine ("这个是Play抽象类的构造函数");
		}
		public abstract int Age {
			get;
			set;
		}
			
		//抽象方法,必须定义在抽象类中
		public abstract  void Practice();
		public abstract void TrainingGround ();
		public abstract void RuleOfContest ();

	}
	public class FootBallPlay:Play
	{   
		public override int Age {
			get { 
				return Age;
			}
			set {
				Age = value;	
			}
		}
		public override void Practice ()
		{   
			Console.WriteLine ("踢足球");
		}
		public override void TrainingGround ()
		{
			Console.WriteLine ("跑操场");
		}
		public override void RuleOfContest ()
		{
			Console.WriteLine ("中心法则");
		}
	}
}