在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
比如，在一个图形编辑软件的分析设计过程中，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域并不是直接存在的，它就是一个抽象概念。而正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
c#中的抽象类的特征
final：在Java中final可以修饰变量、方法、类。
·使用final修饰的变量就是常量，只能赋值一次，而且常量一般使用大写字母表示常量名称。
·使用final修饰的方法不能被子类覆写
·使用final修饰的类就是太监类，不能拥有子类
抽象类：使用abstract修饰的类就是抽象类
抽象方法：使用abstract修饰的方法就是抽象方法
public abstract class OopDemo003 {//定义抽象类
public abstract void eat();//声明抽象方法
}
抽象方法只需要声明，不需要实现，有一个抽象方法的类必须定义为抽象类。
抽象类和普通类相比区别：抽象类比普通类多了抽象方法，普通类中所有的定义都可以在抽象类中使用。
抽象类的使用规则：
·抽象类本身不能实例化
·抽象类中的抽象方法只需要声明，不需要实现
·含有抽象方法的类必须声明为抽象类
·抽象类必须要有子类，不然抽象类没有任何意义，抽象类的子类必须要覆写抽象类的全部抽象方法。
抽象类的实例化过程：
抽象类子类实例化对象的时候，会先调用抽象类的构造方法，那么肯定就构造了一个抽象类的对象，那么抽象类的对象怎么取得呢？
public class OopDemo05 {
public static void main(String[] args) {
OopDemo003 oop = new OopDemo04();//子类对象作为父类对象使用
}
}
举一个实例来帮助理解它：
一个公司，有两个部门,A和B，B部门是核心技术部门，A为普通技术部门，每个部门下都有一级，二级两类技工
公司每年有涨薪制度，但每个部门涨薪幅度不一样，核心部门涨薪幅度大，定义一个抽象类，把共有的属性放在抽象类中，比如姓名和原来工资
定义工资提升的抽象方法
public abstract class Types {
private String name;
private double salary;
public abstract void upSalary();//定义工资提升的抽象方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Types(String name, double salary) {
super();
this.name = name;
this.salary = salary;
}
public Types() {
super();
// TODO Auto-generated constructor stub
}
}
A继承了抽象父类，重写了父类中的抽象方法，即定义工资提升的抽象方法，为A部门不同等级技工设计了一套属于自己的涨薪类
public class A extends Types {
private String post;//岗位等级
@Override
public void upSalary() {//重写抽象父类中的方法
// TODO Auto-generated method stub
double salary=super.getSalary();
if(this.post.equals("一级技工")){
super.setSalary(salary*1.1);
}else if(this.post.equals("二级技工")){
super.setSalary(salary*1.2);
}
}
public String getPost() {
return post;
}
public void setPost(String post) {
this.post = post;
}
public A() {
super();
// TODO Auto-generated constructor stub
}
public A(String name, double salary) {
super(name, salary);
// TODO Auto-generated constructor stub
}
public A(String name, double salary, String post) {
super(name, salary);
this.post = post;
}
}
B继承了抽象父类，重写了父类中的抽象方法，即定义工资提升的抽象方法，为B部门不同等级技工设计了一套属于自己的涨薪类
public class B extends Types {
private String post;
@Override
public void upSalary() {//B类职位也覆写了父类的抽象方法
double salary=super.getSalary();
if(this.post.equals("一级技工")){
super.setSalary(salary*1.3);
}else if(this.post.equals("二级技工")){
super.setSalary(salary*1.5);
}
}
public String getPost() {
return post;
}
public void setPost(String post) {
this.post = post;
}
public B() {
super();
// TODO Auto-generated constructor stub
}
public B(String name, double salary) {
super(name, salary);
// TODO Auto-generated constructor stub
}
public B(String name, double salary, String post) {
super(name, salary);
this.post = post;
}
}
接着用一个测试方法，来输出结果：
public class Test {
public static void main(String[] args) {
Types t1=new A("张三",1000,"一级技工");//子类对象作为父类对象使用
Types t2=new B("李四",1000,"一级技工");
t1.upSalary();
System.out.println("该员工涨薪后的工资应该是："+t1.getSalary());
t2.upSalary();
System.out.println("该员工涨薪后的工资应该是："+t2.getSalary());
}
}
输出的结果为：
该员工涨薪后的工资应该是：1100.0
该员工涨薪后的工资应该是：1300.0
同样的一个抽象父类，原工资一样，但设计的子类不同，输出了各自所要实现的。
通过以上程序，我们还可以发现，如果以后出现其他的部门类型，提升工资的方式不同，可以编写抽象类的子类完成，不需要更改顶层设计。也就是说抽象类的作用就是在于可以方便程序的扩展。这就是抽象类的好处。