抽象类详解

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
比如，在一个图形编辑软件的分析设计过程中，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域并不是直接存在的，它就是一个抽象概念。而正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
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

同样的一个抽象父类，原工资一样，但设计的子类不同，输出了各自所要实现的。

通过以上程序，我们还可以发现，如果以后出现其他的部门类型，提升工资的方式不同，可以编写抽象类的子类完成，不需要更改顶层设计。也就是说抽象类的作用就是在于可以方便程序的扩展。这就是抽象类的好处。