想问一下抽象相比较继承的好处是什么，定义成抽象有什么好处，这一块我一直想不明白。

继承：查询父类功能，创建子类对象使用功能，
    1、提高代码复用性。
    2、类与类之间产生关系
抽象：不能被实例化，只能被继承，而且包含的是抽象的方法，没有句具体的实现方法。
比如说学生和工人，有相同的属性。当相同的属性有变化时，直接可以修改。

1. 通过继承它实现多态，后期绑定，可以为将来要实现的东西做好接口，实现重用性，
   
2. 例如：
   
3. abstract class A {
   
4.     public abstract void doSomething();
   
5. }
   
6. 
   
7. class B extends A {
   
8.     public void doSomething() {
   
9.         System.out.println("do B");
   
10.     }
    
11. }
    
12. 
    
13. class C extends A {
    
14.     public void doSomething() {
    
15.         System.out.println("do C");
    
16.     }
    
17. }
    
18. 
    
19. public class Test {
    
20.     public static void main(Stringp[] args) {
    
21.         A a1 = new B();
    
22.         A a2 = new C();
    
23.         B b = new B();
    
24.         C c = new C();
    
25.         doSomething(a1); //这里
    
26.         doSomething(a2); //这里
    
27.          doSomething(b); //这里，如果下面的方法不是用抽象类作参数，比如用C c做参数，这里会有什么问题？
    
28.          doSomething(c); //这里
    
29.     }
    
30. 
    
31.     public static void doSomething(A a) {  //这里传进来的数据用了A，父类对象指向子类
    
32.         a.doSomething();
    
33.     }
    
34. }

复制代码

继承抽象方法可以增强代码的扩展性和减少代码的重复，比如如果doSomething(C c)是这样，那么我每次调用doSomething不是都要重写一次吗？

能明白了吗？

越是抽象的类就更通用，处于继承层的顶端，有些层的基类非常通用，更适于作为其他类的框架，而不适用于作为具体类来使用其特定实例。
为什么进行如此高层的抽象呢？答案是这会使类设计更清晰。在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体的概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
继承是反映事物多态性的一种方式，使之类与类之间产生了直接的联系，比如子类继承父类可以使用父类中的字段，方法，可以修改已经过时的方法，主要体现在方法的重写或覆盖上。

继承就是子继承父，父类中都是公有方法。子类有多个，然后把子类中的共性提取出来就是父类的方法了。继承提高了复用性，而且java只支持单继承，但是可以有多接口。当子类覆盖父类时，子类权限必须大于等于父类。静态只能覆盖静态。这里得区分重载和覆盖的含义，覆盖是方法名称一样，参数一样，但是重载仅仅是方法名称一样，参数不能一样。继承中子父类构造函数关系：子类的所有构造函数，默认都会访问父类中空参数的构造函数super（）。

抽象类。我觉得抽象类中最重要的一个特性就是如果抽象类被继承，子类就得复写其所有抽象方法。当这个类中的方法不确定，就写个抽象方法，而且抽象类不能创建对象。

接口，存在多继承。接口的存在，等于变相的实现了类的多继承，因为类可以实现多个接口。

//Person抽象类，每个人都有名字和年龄，这是共性，所以不必定义成抽象的。
//但是吃饭eatFood和说话saySpeak方法每个人的方式都不同所以最好定义为抽象的。
//如果不用Person抽象类的话，直接定义一个Person类，那么每一个人的人的说话和吃饭动作都相同了。
abstract class Person
{
        public String name;
        public int age;

        public abstract void eatFood();
        public abstract void saySpeak();

        public void setName(String name){
                this.name = name;
        }

        public void setAge(int age){
                this.age = age;
        }

        public String getName(){
                return name;
        }

        public int getAge(){
                return age;
        }
}

class Student_tom extends Person
{
        public void eatFood(){
                System.out.println("I'm "+name+",I like fish");
        }

        public void saySpeak(){
                System.out.println("I'm "+name+",I age is "+age);
        }
}


public class PersonTool
{
        public static void main(String[] args){
                Student_tom s = new Student_tom();
                s.setName("tom");
                s.setAge(21);
                s.eatFood();
                s.saySpeak();
        }
}

你问的是不是说抽象类中的接口可以实现从而达到继承的功能，
为什么定义成抽象的？
这个问题问的好,我们先看看抽象类与一般类有什么区别：
抽象类中有抽象方法，抽象类中的方法可以被实现。
从而让其实现类继承其接口父类的抽象方法自由的扩展自己的功能，还能有自己的特殊方法。多强大的功能，只要存储空间够就可以无限扩展自己的功能

抽象
抽象我总觉得就是个抽象的东西。
不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象

术语名称：继承
继承是面向对象编程技术的一块基石，因为它允许创建分等级层次的类。运用继承，你能够创建一个通用类，它定义了一系列相关项目的一般特性。该类可以被更具体的类继承，每个具体的类都增加一些自己特有的东西。在Java 术语学中，被继承的类叫超类（superclass ），继承超类的类叫子类（subclass ）。因此，子类是超类的一个专门用途的版本，它继承了超类定义的所有实例变量和方法，并且为它自己增添了独特的元素。
继承一个类，只要用extends 关键字把一个类的定义合并到另一个中就可以了。