c#面向对象程序设计——类的抽象

7.1类的抽象：

在面向对象思想中，所有的对象都可以通过类来描述。但并不是所有的类都是用来描述对象的，如果一个类中没有包含能够描述具体对象的信息，那么就称其为抽象类。
语法：
abstract class 类名{}
特性：
1、抽象成员必须放在抽象类中。
2、抽象类中的成员不一定全是抽象成员
3、抽象类不能实例化
4、抽象类方法不能有具体的实现
5、所有被继承的抽象成员都应在子类中实现
6、子类必须实现父类所有的抽象成员
代码示例：

//定义父类电器类，因为所有的电器都能充电，所以在类中定义充电方法，但是电器只是抽象的概念，因此充电方法无法实现，只能定义抽象方法。
abstract class Appliance
{
	public abstract void Charge();
}
//定义电脑子类和手机子类继承于电器类，并在子类中重写父类方法
class Computer:Appliance{
	public override void Charge(){
		Console.WriteLine("电脑使用220v电压充电")
	}
}
class Phone:Appliance{
	public override void Charge(){
		Console.WriteLine("手机使用110v电压充电")
	}
}
//创建电脑和手机对象，并调用充电方法
static void Main（string[] args）{
	Appliance cpt=new Computer();
	Appliance mp=new Phone();
	cpt.Charge();
	mp.charge();
}

7.2接口：

c#中子类最多只允许有一个父类，如果一个类需要具有多个类的特征或行为，那么就可以通过接口实现。c#中的接口用于约束类的行为。
自定义接口语法：

[访问修饰符] interface 接口名{}

注意点：
1、接口名一般使用大写字母"I"开头，表明它是接口类型
2、接口可包含方法、属性、事件和索引器，但不能包含字段
3、接口中定义的成员不允许有具体实现
代码示例一：

class Person:IComparable<Person>
{
    private string name;
    private int age;
    public Person(){}
    public Person(string name,int age){
    	this.Name = name;
    	this.Age = age;
    }
    public string Name{
    	get { return name; }
    	set { name = value; }
    }
    public int Age{
    	get { return age; }
    	set { age = value; }
    }
    public void Show(){
    	Console.WriteLine("大家好，我叫{0}，今年{1}岁",this.Name,this.Age);
    }
    public int CompareTo(Person other){
    	return this.Age.CompareTo(other.Age);//年龄递增
    	//年龄递减return other.Age.CompareTo(this.Age);
    }
}
static void Main(string[] args){
	Person ma = new Person("张三", 22);
	Person lei = new Person("李四", 20);
	Person chen = new Person("王五", 21);
	List<Person> list = new List<Person>();
	list.Add(ma);
	list.Add(lei);
	list.Add(chen);
	foreach(Person item in list){
		item.Show();
	}
	list.Sort();
	Console.WriteLine("=====================排序后===================");
	 foreach(Person item in list){
  		item.Show();
	 }
}

代码示二：

//自行车接口
class IBicycle{
	public interface IBicycle(){
		//使用方法
		void UsageMethod();
	}
}
//电机接口
calss IElectromotor{
	public interface IElectromotor(){
	        //充电方法
	        void Charging();
	}
}
public class EIectricBicycle{
	private string brand;
	public string Brand{
     		get { return brand; }
     		set { brand = value; }
    	}
    	public void UsageMethod(){
    		Console.WriteLine("{0}电动车是用电机驱动的"，Brand)；
    	}
    	public void Charging(){
    		Console.WriteLine("{0}电动车的充电电压 为220v"，Brand)；
    	}
}
static void Main(string[] args){
	EIectricBicycle eb=new EIectricBicycle();
	eb.Bran="天马"；
	eb.UsageMethod();
	eb.Charging();
}

7.3抽象类和接口的区别：

抽象类	接口
使用abstract关键字	使用interface关键字
可以包含字段和已实现成员	不能包含字段，只能包含未实现的成员
子类通过override实现抽象方法	子类直接实现所有成语

代码示例：

//妖怪抽象类
public abstract class Monster
{
       private string name;//名字
       private int hp;//生命值
       private int mp;//魔法值
       public string Name{
       	get { return name; }
       	set { name = value; }
       }
       public int Hp{
       	get { return hp; }
       	set { hp= value; }
      }
      public int Mp{
       get { return mp; }
       set { mp = value; }
      }
  //显示基本信息
     public void ShowInfo(){
            Console.WriteLine("{0}的生命值和魔法值为{1}，{2}",Name,Hp,Mp);
     }
     //恢复生命值
     public virtual void AutomaticHp(){
             Console.WriteLine("{0}自动恢复生命值，{2}",Name);
     }
}
//英雄和妖怪都有攻击的方法
public interface IAttack{
	//物理攻击
	void PhysicalAttack();
	//魔法攻击
	void MagicalAttack();
}
public class Fox:Monster,IAttack{
        public void PhysicalAttack(){
        	Console.WriteLine("狐妖的物理攻击是“金刚爪”。");
        }
        public void MagicalAttack(){
        	Console.WriteLine("狐妖的魔法攻击是“妖气爪”。")
        }
}
static void Main(string[] args){	
	Fox fox=new Fox(){Name="小狐狸",Hp=10000,Mp=4000};
	fox.ShowInfo();
	fox.AutomaticHp();
}