抽象类学习-摩杜云开发者社区

一、前言引入

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

二、抽象类的定义语法

2.1 抽象类的使用

普通类可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static、成员变量、局部变量；而所谓的抽象类就是在普通类的结构里面增加抽象方法的组成部分。

***拥有抽象方法的类一定属于抽象类，抽象类要使用abstract声明。***

代码示例

abstract class A{//定义一个抽象类
public void fun(){//普通方法
		System.out.println("普通方法拥有方法体的方法");
	}
  // 抽象方法没有方法体的声明，并且存在有abstract关键字，表示抽象方法
	public abstract void print();
}

定义了抽象类，那么可否直接使用这个抽象类。
直接产生对象？？？？？？？？？？？？？？？？？？A是抽象类，无法实例化

当这个类可以实例化产生对象的时候意味着，这个对象可以使用调用类中的属性和方法了，但是在抽象类里面存在抽象方法，那么这个抽象方法，这个抽象方法没有方法体，即就不能调用，进而不能实例化抽象类。

抽象类的使用原则如下：

抽象类必须有子类，每一个抽象类一定要被子类所继承；
抽象类的子类（子类不是抽象类）必须覆写抽象类中的全部抽象方法（强调子类覆写）
抽象类的对象实例化需要依靠子类来完成，采用向上转型的方式处理。

示例代码：正确使用抽象类

abstract class A { // 定义一个抽象类
	public void fun() { // 普通方法
		System.out.println("普通方法拥有方法体的方法");
	}
//	抽象方法没有方法体的声明，并且存在有abstract关键字，表示抽象方法
	public abstract void print();
}
// 一个子类只能继承一个抽象类，单继承
class B extends A{ // B是抽象类的子类，并且是一个普通类
	public void print() { // 强制要求覆写的方法 
				System.out.println("hello world");
	} 
}
public class TestDemo{
	public static void main(String args[]) throws Exception{
		A a = new B();//向上转型
		a.print();//被子类所覆写过的方法
	}
}

抽象类中定义静态方法

在任何情况下，如果要执行类中的static方法的时候，都可以在没有对象的时候直接调用，抽象类也是如此。

  abstract class A{
//	static定义的内部类属于外部类
	static abstract class B{
		public abstract void print();
	}
}
class X extends A.B{//X继承静态内部类
	public void print(){
		System.out.println("************");
	}
}
public class TestDemo{
	public static void main(String args[]) throws Exception{
		A.B ab=new X();//向上转型
		ab.print();
	}
}

总结：
1、抽象类中子类里面会有明确的方法覆写要求，而普通的方法没有；
2、抽象类只比普通类多一些抽象方法，其他部分一样；
3、普通类可以直接实例化，而抽象类必须经过向上转型之后才可以得到实例化对象。

虽然一个子类可以任意继承一个普通类，可是在实际开发中要求来讲，普通类不要去继承另外一个普通类，继承抽象类更好。

2.2 抽象类的相关限制

抽象类的组成和普通类的区别不大，但是由于有一点点定义上的区别，可能会有如下会被忽略的概念：

抽象类里面由于会有一些属性，那么在抽象类中会存在构造方法，目的：为属性初始化，并且子类对象实例化的时候依然满足先执行父类构造，再执行子类构造的情况。
抽象类不能使用final定义：final定义的类不能有子类，抽象类必须有子类。
外部的抽象类不能使用static声明，而内部的抽象类允许使用static声明，使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用 “外部类.内部类” 的形式表示类名称。

示例代码

abstract class A{
//	static定义的内部类属于外部类
	static abstract class B{
		public abstract void print();
	}
}
class X extends A.B{  // X继承静态内部类
	public void print(){
		System.out.println("************");
	}
}
public class TestDemo{
	public static void main(String args[]) throws Exception{
		A.B ab = new X();//向上转型
		ab.print();
	}
}

在任何情况下，如果要执行类中的static方法的时候，都可以在没有对象的时候直接调用，抽象类也是如此。

abstract class A{
	public static void print(){
		System.out.println("Hello World");
	}
}
public class TestDemo{
	public static void main(String args[]){
		A.print();
	}
}

抽象类在类库中的例子

由于抽象类只需要一个特定的系统子类操作，所以可以忽略掉外部子类。
示例代码

abstract class A{
	public abstract void print();
	private static class B extends A{//内部抽象子类
		public void print(){ // 覆写抽象类的方法
			System.out.println("hello world");
		}
	}
	// 这个方法不受实例化对象的控制
	public static A getInstance(){ // 感觉有点单例的意思
		return new B();
	}
}
public class Test4{
	public static void main(String args[]){
		// 此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
		A a = A.getInstance(); // 能通过返回A的实例化对象
        A.getInstance().print();
            
		a.print();
	}
}

这样的设计在系统类库中比较常见。

目的：为用户隐藏不需要知道的子类。

三、抽象类的应用模板

例如，现在有三类事物：

机器人：充电、工作；
- 人：吃饭、工作、睡觉；
- 猪：吃饭、睡觉。
  要求可以实现以上的操作控制，即：可以实现任意的控制人、机器人、猪的操作行为（吃、睡、工作）。

代码实现（行为）

abstract class Action {
	public static final int EAT = 1;
	public static final int SLEEP = 5;
	public static final int WORK = 7;

	public void command(int flag) {
		// sitch()只支持数值判断，而if还支持条件判断
		switch (flag) {
		case EAT:
			this.eat();
			break;
		case SLEEP:
			this.sleep();
			break;
		case WORK:
			this.work();
			break;
		case EAT + WORK:
			this.eat();
			this.work();
			break;
		case EAT + SLEEP:
			this.eat();
			this.sleep();
			break;
		}
	}

	// 因为现在不确定子类的是实现是，什么样的
	public abstract void eat();

	public abstract void sleep();

	public abstract void work();
}

代码实现：下面定义Robot类

class Robot extends Action {
    public void eat() {
    	// TODO Auto-generated method stub
    	System.out.println("机器人补充能量");	
    }
    @Override
    public void sleep() {
    	// TODO Auto-generated method stub	
    }
    @Override
    public void work() {
    	// TODO Auto-generated method stub
    	System.out.println("机器人努力工作");
    }
}

代码实现：下面定义Human类

class Pig extends  Action {
       @Override
        public void eat() {
        	// TODO Auto-generated method stub
        	System.out.println("人类在吃饭");
        }
        @Override
        public void sleep() {
        	// TODO Auto-generated method stub
        	System.out.println("人在睡觉");	
        }
        @Override
        public void work() {
        	// TODO Auto-generated method stub
        	System.out.println("人在努力工作");
        }
    }

代码实现：下面定义Pig类

class pig extends Action {

	@Override
	public void eat() {
		
	}

	@Override
	public void sleep() {
		
	}

	@Override
	public void work() {
		
	}
	
}

这三个类都属于行为的子类，都可以通过行为来控制

 public class TestDemo{
    public static void main(String args[]){
  
    	fun(new Robot());
    	fun(new Human());
    	fun(new Pig());
    }
    public static void fun(Action act){
    	act.command(Action.EAT);
    	act.command(Action.SLEEP);
    	act.command(Action.WORK);
    }
}

这些不同的类型最终都在行为上成功的进行了抽象，即：如果想使用行为操作，那么就必须按照Action()类的标准来实现子类。根据用户不同的要求，去执行不同功能，调用不同的子类去实现不同的操作的具体实现方式。这种实现的模板就像按照要求标准填写表格一样，要求什么填写什么信息。

总结

1、如果要使用继承的话，那么就多使用抽系类
2、抽象类强制规定了子类的必须要做的事情，而且可以与抽象类的普通方法相配合使用；
3、抽象类的缺陷：单继承。