1.抽象类的特点：
 
	A.抽象类和抽象方法必须使用abstract修饰
	B.抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类
	C.抽象类不能实例化
			因为他不是具体的。
			抽象类具有构造方法，但是不能实例化。构造方法的作用是什么？子类对父类数据进行初始化
	D：抽象的的子类
			a:如果不想重写方法，该子类是一个抽象类
			b:	重写所有的的抽象方法，这时候子类是一个具体的类
 
package test9;
abstract class animal{
	public abstract void eat();
}
//子类是抽象类
abstract class Dog extends animal{
	
}
//子类是具体类，重写抽象方法
class cat extends animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}
public class main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//抽象类不能实例化，但是却可以通过多态的方式，来实现
		animal a=new cat();
		a.eat();//猫吃鱼
	}

}

 
2.抽象类的成员特点：
 
	成员变量：既可以是变量，也可以是常量
	构造方法：有。
				用于子类访问父类数据的初始化
	成员方法：既可以是抽象的，也可以是非抽象的
 
3.抽象类的成员方法特性：
 
	A：抽象方法 强制要求子类做的事情
	B：非抽象方法 子类继承的事情，提高代码的复用性

一、抽象类的基本概念
 
普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。
 
那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
 
而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。
 
范例：定义一个抽象类
 
abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}
 
二、抽象类的使用
 
我们先看范例。
 范例：直接实例化抽象类的对象
 
package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

public class TestDemo {

	public static void main(String[] args) {
		A a = new A();
	}
}
 
运行：
 
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Cannot instantiate the type A

	at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)

 
从上可知，A是抽象的，无法直接进行实例化操作。为什么不能直接实例化呢？当一个类实例化之后，就意味着这个对象可以调用类中的属性或者放过了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。
 
抽象类的使用原则如下：
 （1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
 （2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
 （3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
 （4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
 
范例：
 
package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

	@Override
	public void print() {//强制要求覆写
		System.out.println("Hello World !");
	}
	
}
public class TestDemo {

	public static void main(String[] args) {
		A a = new B();//向上转型
		
		a.print();//被子类所覆写的过的方法
	}
}

 
运行结果：
 
Hello World !

 
现在就可以清楚的发现：
 （1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写；
 （2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样；
 （3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。
 
虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。
 
三、抽象类的使用限制
 
（1）抽象类中有构造方法么？
 由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
 并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。
 
范例如下：
 
package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
	
	public A(){
		System.out.println("*****A类构造方法*****");
	}

	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类

	public B(){
		System.out.println("*****B类构造方法*****");
	}
	
	@Override
	public void print() {//强制要求覆写
		System.out.println("Hello World !");
	}
	
}
public class TestDemo {

	public static void main(String[] args) {
		A a = new B();//向上转型
	}

}

 
执行结果：
 
*****A类构造方法*****
*****B类构造方法*****
 
（2）抽象类可以用final声明么？
 不能，因为抽象类必须有子类，而final定义的类不能有子类；
 
（3）抽象类能否使用static声明？
 先看一个关于外部抽象类的范例：
 
package com.wz.abstractdemo;

static abstract class A{//定义一个抽象类
	
	public abstract void print();
	
}

class B extends A{
	
	public void print(){
		System.out.println("**********");
	}
}
public class TestDemo {

	public static void main(String[] args) {
		A a = new B();//向上转型
		a.print();
	}

}

 
执行结果
 
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Illegal modifier for the class A; only public, abstract & final are permitted

	at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
	at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
	at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)

 
再看一个关于内部抽象类：
 
package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
	
	static abstract class B{//static定义的内部类属于外部类
		public abstract void print();
	}
	
}

class C extends A.B{
	
	public void print(){
		System.out.println("**********");
	}
}
public class TestDemo {

	public static void main(String[] args) {
		A.B ab = new C();//向上转型
		ab.print();
	}

}

 
执行结果：
 
**********
 
由此可见，外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。
 
（4）可以直接调用抽象类中用static声明的方法么？
 任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。
 范例如下：
 
package com.wz.abstractdemo;

abstract class A{//定义一个抽象类
	
	public static void print(){
		System.out.println("Hello World !");
	}
	
}

public class TestDemo {

	public static void main(String[] args) {
		A.print();
	}

}

 
运行结果：
 
Hello World !

 
（5）有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。
 范例如下：
 
package com.wz.abstractdemo;

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 TestDemo {

	public static void main(String[] args) {
		
		//此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
		A a = A.getInstance();
		a.print();
	}
}

 
运行结果：
 
Hello World !
 
四、抽象类的应用——模板设计模式
 
例如，现在有三类事物：
 （1）机器人：充电，工作；
 （2）人：吃饭，工作，睡觉；
 （3）猪：进食，睡觉。
 现要求实现一个程序，可以实现三种不同事物的行为。
 
先定义一个抽象行为类：
 
package com.wz.abstractdemo;

public abstract class Action{
	
	public static final int EAT = 1 ;
	public static final int SLEEP = 3 ;
	public static final int WORK = 5 ;
	
	public abstract void eat();
	public abstract void sleep();
	public abstract void work();
	
	public void commond(int flags){
	  switch(flags){
		case EAT:
			this.eat();
			break;
		case SLEEP:
			this.sleep();
			break;
		case WORK:
			this.work();
			break;
		case EAT + SLEEP:
			this.eat();
			this.sleep();
			break;
		case SLEEP + WORK:
			this.sleep();
			this.work();
			break;
		default:
			break;
		}
	}
}

 
定义一个机器人的类：
 
package com.wz.abstractdemo;

public class Robot extends Action{

	@Override
	public void eat() {
		System.out.println("机器人充电");
		
	}

	@Override
	public void sleep() {
		
	}

	@Override
	public void work() {
		System.out.println("机器人工作");
		
	}
	
}


 
定义一个人的类：
 
package com.wz.abstractdemo;

public class Human extends Action{

	@Override
	public void eat() {
		System.out.println("人吃饭");
		
	}

	@Override
	public void sleep() {
		System.out.println("人睡觉");
		
	}

	@Override
	public void work() {
		System.out.println("人工作");
		
	}
	
}
 
定义一个猪的类：
 
package com.wz.abstractdemo;

public class Pig extends Action{

	@Override
	public void eat() {
		System.out.println("猪进食");
		
	}

	@Override
	public void sleep() {
		System.out.println("猪睡觉");
		
	}

	@Override
	public void work() {
		
		
	}
	
}

 
测试主类：
 
package com.wz.abstractdemo;

public class AbstractDemo {

	public static void main(String[] args) {
		
		fun(new Robot());
		
		fun(new Human());
		
		fun(new Pig());

	}
	
	public static void fun(Action act){
		act.commond(Action.EAT);
		act.commond(Action.SLEEP);
		act.commond(Action.WORK);
	}

}

 
运行结果：
 
机器人充电
机器人工作
人吃饭
人睡觉
人工作
猪进食
猪睡觉

 
所有的子类如果要想正常的完成操作，必须按照指定的方法进行覆写才可以，而这个时候抽象类所起的功能就是一个类定义模板的功能。

 
 
接口可以继承接口。
 
 
 
 
抽象类并不能继承接口，但可以实现接口。
 
 
 
 
抽象类可以继承具体类，前提是具体类必须具有构造函数且具有访问权限。这里需要说明，当一个具体类没有写构造函数时，系统会自动生成默认的无参构造器，意味着没有写构造函数的具体类也可以被抽象类继承。但是，一旦将具体类的无参构造器设置访问修饰符为 private 时，抽象类则不可以继承。
 
 
 
 
抽象类可以有静态的 main 方法。抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方法都可以是静态的. 静态的意义其实就是在栈内存中只有一个, 所以该成员也会先于对象出现在内存中, 所以静态并没有违反抽象的原则. 抽象类中可以定义静态成员.
 
 
interface IA{}
interface IB{}
interface I extends IA,IB{}//接口可以继承多个接口
abstract class E implements IA{} //抽象类可以实现接口，但不可以继承接口
abstract class F extends C{}//抽象类可以继承具体类
class D{private D(){}}
//abstract class G extends D{}//Implicit super constructor D() is not visible for default constructor. Must define an explicit constructor抽象类不可以继承无权限构造器的具体类
abstract class H{public static void main() {}}//抽象类可以有静态的main方法

抽象类
 
定义：
   在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。简单来说，使用关键字 abstract 修饰的类就叫做抽象类。
 使用：
 
abstract class AbstractAnimal {
    public AbstractAnimal() {
        System.out.println("Init AbstractAnimal.");
    }
    static String name = "AbstractAnimal";
    public abstract void eat();
    public void run() {
        System.out.println("AbstractAnimal Run.");
    }
}
class Animal extends AbstractAnimal {
    public static void main(String[] args) {
        AbstractAnimal animal = new Animal();
        animal.run();
        System.out.println(animal.name);
        animal.eat();
    }
  // 必须重写抽象父类方法
    @Override
    public void eat() {
        System.out.println("Animal Eat.");
    }
}
 
执行的结果：
 
Init AbstractAnimal.
AbstractAnimal Run.
AbstractAnimal
Animal Eat.
 
抽象方法：
   使用 abstract 关键字修饰的方法叫做抽象方法，抽象方法仅有声明没有方法体。如下代码：
 
public abstract void m();
 
抽象类的特性：
 
抽象类不能被初始化
抽象类可以有构造方法
抽象类的子类如果为普通类，则必须重写抽象类中的所有抽象方法
抽象类中的方法可以是抽象方法或普通方法
一个类中如果包含了一个抽象方法，这个类必须是抽象类
子类中的抽象方法不能与父类中的抽象方法同名
抽象方法不能为 private、static、final 等关键字修饰
抽象类中可以包含普通成员变量，访问类型可以任意指定，也可以使用静态变量（static）
 
接口
 
定义：
   接口（interface）是抽象类的延伸，它允许一个类可以实现多个接口，弥补了抽象类不能多继承的缺陷，接口是对类的描述，使用 interface 关键字来声明。
 使用：
 
interface IAnimal {
    void run();
}
class AnimalImpl implements IAnimal {
    public static void main(String[] args) {
        IAnimal animal = new AnimalImpl();
        animal.run();
    }
    @Override
    public void run() {
        System.out.println("AnimalImpl Run.");
    }
}
 
相关面试题
 
1.抽象类中能不能包含方法体？
 答：抽象类中可以包含方法体。抽象类的构成也可以完全是包含方法体的普通方法，只不过这样并不是抽象类最优的使用方式。
 
题目解析：包含了方法体的抽象类示例代码如下：
 
abstract class AbstractAnimal {
    public void run() {
        System.out.println("AbstractAnimal Run.");
    }
}
class Animal extends AbstractAnimal {
    public static void main(String[] args) {
        AbstractAnimal animal = new Animal();
        animal.run();
    }
}
 
执行结果：
 AbstractAnimal Run.
 
2.抽象类能不能被实例化？为什么？
 答：抽象类不能被实例化，因为抽象类和接口的设计就是用来规定子类行为特征的，就是让其他类来继承，是多态思想的一种设计体现，所以强制规定抽象类不能被实例化。
 
3.抽象方法可以被 private 修饰吗？为什么？
 答：抽象方法不能使用 private 修饰，因为抽象方法就是要子类继承重写的，如果设置 private 则子类不能重写此抽象方法，这与抽象方法的设计理念相违背，所以不能被 private 修饰。
 
4.添加以下哪个选项不会引起编译器报错？
 
abstract class AbstractAnimal {
    static String animalName = "AbstractAnimal";
      // 添加代码处
}
 
A：protected abstract void eat();
 B： void eat();
 C：abstract void eat(){};
 D：animalName += “Cat”;
 
答：A
 
题目解析：选项 B 普通方法必须有方法体；选项 C 抽象方法不能有方法体；选项 D 变量赋值操作必须在方法内。
 
5.以下关于抽象类和抽象方法说法正确的是？
 A：抽象类中的方法必须全部为抽象方法
 B： 抽象类中必须包含一个抽象方法
 C：抽象类中不能包含普通方法
 D：抽象类中的方法可以全部为普通方法（包含方法体）
 
答：D
 
题目解析：抽象类中可以没有方法或者全部为普通方法，都是允许的，如下代码所示：
 
abstract class AbstractAnimal {
    public void run() {
        System.out.println("AbstractAnimal Run.");
    }
}
class Animal extends AbstractAnimal {
    public static void main(String[] args) {
        AbstractAnimal animal = new Animal();
        animal.run();
    }
}

 
程序执行的结果为：
 
AbstractAnimal Run.
 
6.接口和普通类有什么关系？
 答：在 Java 语言设计中，接口不是类，而是对类的一组需求描述，这些类必须要遵循接口描述的统一格式进行定义。
 
7.接口能不能有方法体？
 答：JDK 8 之前接口不能有方法体，JDK 8 之后新增了 static 方法和 default 方法，可以包含方法体。
 
8.执行以下代码会输出什么结果？
 
interface IAnimal {
    static String animalName = "Animal Name";
}
class AnimalImpl implements IAnimal {
    static String animalName = new String("Animal Name");
    public static void main(String[] args) {
        System.out.println(IAnimal.animalName == animalName);
    }
}
 
答：执行的结果为 false。
 
题目解析：子类使用 new String… 重新创建了变量 animalName，又因为使用 == 进行内存地址比较，所以结果就是 false。
 
9.抽象类和接口有什么区别？
 答：抽象类和接口的区别，主要分为以下几个部分。
 
默认方法
抽象类可以有默认方法的实现
JDK 8 之前接口不能有默认方法的实现，JDK 8 之后接口可以有默认方法的实现
继承方式
子类使用 extends 关键字来继承抽象类
子类使用 implements 关键字类实现接口
构造器
抽象类可以有构造器
接口不能有构造器
方法访问修饰符
抽象方法可以用 public / protected / default 等修饰符
接口默认是 public 访问修饰符，并且不能使用其他修饰符
多继承
一个子类只能继承一个抽象类
一个子类可以实现多个接口
 
10.以下抽象方法描述正确的是？
 A：抽象方法可以是静态（static）的
 B：抽象方法可同时是本地方法（native）
 C：抽象方法可以被 synchronized 修饰
 D：以上都不是
 
答：D
 
题目解析：抽象方法需要被子类重写，而静态方法是无法被重写的，因此抽象方法不能被静态（static）修饰；本地方法是由本地代码实现的方法，而抽象方法没有实现，所以抽象方法不能同时是本地方法；synchronized 和方法的实现细节有关，而抽象方法不涉及实现细节，因此抽象方法不能被 synchronized 修饰。