关键词：
谈到抽象，就先谈谈面向对象语言的三大特性，也是人们口中常说的封装、继承、多态。
封装：什么是封装，按到我的理解，封装就是把某些类的相关属性和方法封装，对内实现数据影城，对外提供稳定接口。
继承：从字面上理解，就是声明一个父类，然后子类可以继承，并且子类拥有父类的一切属性和方法。
多态，值一个类实例相同的方法不同情形有不同表现形式
讲完这些说说主题，抽象类和接口。
先来说说抽象类：
1）抽象类的本质还是一个类，里面可以包含一切类可以包含的
2）抽象成员 必须包含在抽象类里面，抽象类还可以包含普通成员
3）继承抽象类后，必须显示的override其抽象成员
4）抽象类不能直接实例化，声明的对象只能使用抽象类里的方法，不能用子类新增的方法
5）父类只有一个
比如说声明一个手机的抽象类，手机又打电话，品牌，系统等一些基本属性。
public abstract class BasePhone
{
public int Id { get; set; }
public string Name = "123";
public delegate void DoNothing();
public event DoNothing DoNothingEvent;
public void Show()
{
Console.WriteLine("这里是Show1");
}
public virtual void ShowVirtual()
{
Console.WriteLine("这里是Show");
}
/// <summary>
/// 品牌
/// </summary>
/// <returns></returns>
public abstract string Brand();
/// <summary>
/// 系统
/// </summary>
/// <returns></returns>
public abstract string System();
/// <summary>
/// 打电话
/// </summary>
public abstract void Call();
/// <summary>
/// 拍照
/// </summary>
public abstract void Photo();
public abstract void Do<T>();
}
然后有一台苹果手机；应该怎么做呢，这时候就可以继承这个抽象类。
public class iPhone : BasePhone
{
/// <summary>
/// 品牌
/// </summary>
/// <returns></returns>
public override string Brand()
{
return "iPhone";
}
/// <summary>
/// 系统
/// </summary>
/// <returns></returns>
public override string System()
{
return "IOS";
}
/// <summary>
/// 打电话
/// </summary>
public override void Call()
{
Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
}
/// <summary>
/// 拍照
/// </summary>
public override void Photo()
{
Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
}
public override void Do<T>()
{
}
}
那如果这台手机需要实现一个支付功能呢，怎么办，可以在苹果手机类中添加一个支付功能，但是手机不只是有苹果，还有别的品牌，如果都有支付功能，不可能在每个类中都添加一个这样的方法吧，这样太麻烦了，有人会讲，在抽象类中抽象一个支付方法，但是在抽象类中添加了方法，所有继承了这个类的都需要实现这个方法，这样太不方便了，这个时候就需要接口。
1）接口不是类，里面可以包含属性、方法、事件 不能包含字段，委托，不能用访问修饰符
2）接口只能包含没有实现的方法
3）实现接口的话，必须实现全部方法
4）接口不能直接实例化，声明的对象只能使用接口里的方法，不能用子类新增的方法
5）接口可以实现多个
public interface IPay
{
void Pay();
}
这样在苹果类实现这个接口，就既可以实现支付功能，又不会影响其他类。
public class iPhone : BasePhone, IPay
{
/// <summary>
/// 品牌
/// </summary>
/// <returns></returns>
public override string Brand()
{
return "iPhone";
}
/// <summary>
/// 系统
/// </summary>
/// <returns></returns>
public override string System()
{
return "IOS";
}
/// <summary>
/// 打电话
/// </summary>
public override void Call()
{
Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
}
/// <summary>
/// 拍照
/// </summary>
public override void Photo()
{
Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
}
public override void Do<T>()
{
}
public void Pay()
{
throw new NotImplementedException();
}
}
说了这么多。那么什么时候用抽象类，什么时候用接口呢
抽象是模板化，减少一定的代码量；
接口是功能化，增加一定的灵活性；
用经典的话说，就是is a，和has a 的关系。
抽象类本质还是一个类，就好比上面举的例子，BasePhone这个类他的本质还是是一份手机，只不过是把手机一些共有的性能给抽象出来一个类。
在比如IPay这个接口，它只是为了手机拥有这个功能而存在的，但不是所有的手机都拥有了这个功能，所以说只能把支付功能声明为一个接口。
最后说说重写overwrite(new) 覆写override 重载overload(方法)
在这里就不细说了，直接通过代码是讲述。
声明一个父类：有普通方法，虚方法，抽象方法，然后子类继承，
#region abstract
public abstract class ParentClass
{
/// <summary>
/// CommonMethod
/// </summary>
public void CommonMethod()
{
Console.WriteLine("ParentClass CommonMethod");
}
/// <summary>
/// virtual 虚方法 必须包含实现 但是可以被重载
/// </summary>
public virtual void VirtualMethod()
{
Console.WriteLine("ParentClass VirtualMethod");
}
public abstract void AbstractMethod();
}
public class ChildClass : ParentClass
{
/// <summary>
/// new 隐藏
/// </summary>
public new void CommonMethod()
{
Console.WriteLine("ChildClass CommonMethod");
}
/// <summary>
/// virtual 可以被覆写
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override void VirtualMethod()
{
Console.WriteLine("ChildClass VirtualMethod");
base.VirtualMethod();
}
public override void AbstractMethod()
{
Console.WriteLine("ChildClass AbstractMethod");
}
}
#endregion abstract
通过控制台程序看效果。
class Program{
static void Main(string[] args)
{
Console.WriteLine("*******************************************");
Console.WriteLine("*******************************************");
Console.WriteLine("*******************************************");
ParentClass instance = new ChildClass();
Console.WriteLine("下面是instance.CommonMethod()");
instance.CommonMethod();
Console.WriteLine("下面是instance.VirtualMethod()");
instance.VirtualMethod();
Console.WriteLine("下面是instance.AbstractMethod()");
instance.AbstractMethod();
}
}
可以看出普通方法，是调用父类的方法，虚方法和抽象方法都是调用子类的，其实不难理解，因为虚方法和抽象方法都被子类给override（覆写）了。
那什么是重载呢，重载就是方法名相同，参数不同
public new void CommonMethod()
{
Console.WriteLine("ChildClass CommonMethod");
}
public void CommonMethod(string name)
{
Console.WriteLine("ChildClass CommonMethod");
}
public void CommonMethod(int id)
{
Console.WriteLine("ChildClass CommonMethod");
}
public void CommonMethod(int id, string name)
{
Console.WriteLine("ChildClass CommonMethod");
}
java之关键字abstract(抽象类与抽象方法)
/**abstract关键字的使用*1.abstract:抽象的*2.abstract可以用来修饰的结构：类、方法**3.abstract修饰类：抽象类*>此类不能实例化*>抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）*>开发中，都... 查看详情
abstract抽象类
抽象类的概念：是使用关键字abstract修饰的类就是抽象类；抽象类的产生：当多个不能相互继承的类具有相同的功能时，就需要将共同的信息向上抽取，放到公共的父类中；如果公共的父类只能描述所有子类都具有的功能，但描... 查看详情
abstract抽象
如有不足，多多指导 abstract可以修饰类，方法。 作用：强制使用多态 注意：1.抽象类中不一定有抽象方法，但抽象方法的类，一定是个抽象类 2.子类继承抽象类后，必须实现父类定义的所有... 查看详情
abstract关键字
一，abstract关键字：abstract关键字表示的是抽象的意思，可以用来修饰类和方法。修饰的类我们称之为抽象类，修饰的方法我们称为抽象方法二.abstract修饰类，抽象类：publicabstractclass类名{}抽象类用来表示一些抽象的概念抽象类... 查看详情
抽象abstract
...时候要先进行子类对其实例化。然后实现它的方法。 abstract和final不 查看详情
抽象类abstract
抽象类的关键字：abstract 什么是抽象类?抽象类的意思在于，该方法定义为抽象方法，不需要去写具体的方法执行体。而只需要写方法名与方法定义的关键字即可，例如：publicabstractvoid方法名();-->切记，如果方法没有具... 查看详情
抽象类abstract
抽象类就是拿来继承的抽象方法就是拿来重写的1.用abstract可以用来修饰类或方法，分别叫抽象类和抽象方法。2.含有抽象方法的类必须被声明为抽象类。，抽象类必须被继承，抽象方法也必须被重写。3.抽象类不能被实例化。4.... 查看详情
abstract抽象类
一个类，如果它至少有一个方法是抽象的，这个类必须声明为抽象的抽象类不能被实例化抽象方法只能声明，不能定义具体实现继承抽象类的子类必须定义父类所有抽象方法，且这些方法的访问控制必须和父类一样或者更宽松 查看详情
面向对象---多态-抽象
面向对象编程---抽象：可以使用abstract来修饰一个类或者方法。用abstract修饰的类表示这个类是一个抽象类，用abstract修饰的方法表示这个方法是一个抽象方法。抽象类不能被实例化。抽象方法是只有方法声明，而没有方法的实现... 查看详情
abstract
...类中可以有一个或多个抽象方法，但也可以没有抽象方法abstractclassclassName{//属性//抽象方法[访问控制修饰符]abstract返回值类型方法名（参数列表）；}所谓抽象方法，是指在类中仅仅定义“要处理数据”，但“不知如何处理数据... 查看详情
abstract关键字
一，abstract关键字： abstract关键字表示的是抽象的意思，可以用来修饰类和方法。修饰的类我们称之为抽象类，修饰的方法我们称为抽象方法二.abstract修饰类，抽象类： publicabstractclass类名{} ... 查看详情
abstract关键字
一，abstract关键字： abstract关键字表示的是抽象的意思，可以用来修饰类和方法。修饰的类我们称之为抽象类，修饰的方法我们称为抽象方法二.abstract修饰类，抽象类： publicabstractclass类名{} ... 查看详情
abstract关键词
一，abstract关键字： abstract关键字表示的是抽象的意思，可以用来修饰类和方法。修饰的类我们称之为抽象类，修饰的方法我们称为抽象方法二.abstract修饰类，抽象类： publicabstractclass类名{} ... 查看详情
12抽象函数-abstract
...抽象函数1.抽象函数就是没有函数体的函数2.抽象类使用abstract来定义3.抽象类不能生产对象，但是可以拥有构造函数 abstractvoidfun();以下代码编译不过：classPerson{ Stringname; intage; voidintroduce() { System.out.prin... 查看详情
java中的抽象类（abstract）
...的画一般都是被称为抽象的。在java里面可以使用关键字abstract修饰--个类,这样的类被称为抽象类,abstract修饰的方法叫做抽象方法。抽象类或抽象方法-般也是看不懂的，因为里面可能根本就没有代码。抽象类的特点■抽象类无法... 查看详情
抽象类abstract
packageTest;/**抽象方法子类必须重写*/publicclassAbstract publicstaticvoidmain(String[]args) //Animala=newAnimal();错误，抽象类不能被实例化，必须由子类实例化 AnimalOnea=newDog();//猫吃鱼 a.eat(); abstractclassAni 查看详情
abstract关键字
abstract:抽象的 1.可以用来修饰：类、方法 abstract修饰类：抽象类: >此类不能实例化 >抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程） >开发中，都会提供... 查看详情
面向对象_06抽象类：abstract接口：interface实现：implements
抽象类：abstract抽象：没有足够的描述功能，事物不具体的描述，却又有共性。特点： 1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中，该类也必须被abstract修饰。 2... 查看详情