抽象类和接口的区别：

抽象类和接口的区别：
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象

B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承

C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

package day9;

/**
 * Created by admin on 2018/11/17.
 * 接口的特点：
     A:接口用关键字interface表示
        interface 接口名 {}
     B:类实现接口用implements表示
        class 类名 implements 接口名 {}
     C:接口不能实例化
         那么，接口如何实例化呢?
         按照多态的方式来实例化。
     D:接口的子类
         a:可以是抽象类。但是意义不大。
         b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

    由此可见：
         A:具体类多态(几乎没有)
         B:抽象类多态(常用)
         C:接口多态(最常用)
 */

interface AnimalTrain {
    void jump();
}

//抽象类实现接口
abstract class Dogs implements AnimalTrain {
    public void dogs(){
        System.out.println("this is dog");
    }
}
class Cats extends Dogs {
    @Override
    public void jump() {
        System.out.println("this is jump");
    }
}
public class InterfaceDemo {
    public static void main(String[] args){
        Dogs at = new Cats();
        at.jump();
        at.dogs();
    }

}

package day9;

/**
 * Created by admin on 2018/11/17.
 * 接口成员特点
     成员变量；只能是常量，并且是静态的。
     默认修饰符：public static final
     建议：自己手动给出。
     构造方法：接口没有构造方法。
     成员方法：只能是抽象方法。
     默认修饰符：public abstract
     建议：自己手动给出。

    所有的类都默认继承自一个类：Object。
    类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
 */
interface Inter{
    public int num = 10;
    public final int num2 = 20;
    public static final int num3 = 30;

    //错误: 需要<标识符>
    //public Inter() {}

    //接口方法不能带有主体
    //public void show() {}

    //abstract void show(); //默认public
    void show(); //默认abstract
}
//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
}
*/
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
    public void show() {}
}
public class InterfaceDemo2 {
    public static void main(String[] args) {
        System.out.println();
        InterImpl i = new InterImpl();
        i.show();
        Inter it = new InterImpl();
        System.out.println(it.num);
        System.out.println(it.num2);
        System.out.println(it.num3);
    }
}

package day9;

import com.sun.prism.impl.paint.PaintUtil;
import org.omg.CORBA.PUBLIC_MEMBER;

/**
 * Created by admin on 2018/11/17.
 * /*
 老师和学生案例,加入抽烟的额外功能

 分析：从具体到抽象
 老师：姓名，年龄，吃饭，睡觉
 学生：姓名，年龄，吃饭，睡觉

 由于有共性功能，我们提取出一个父类，人类。

 人类：
 姓名，年龄
 吃饭();
 睡觉(){}

 抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

 抽烟接口。

 部分老师抽烟：实现抽烟接口
 部分学生抽烟：实现抽烟接口

 实现：从抽象到具体

 使用：具体
 */

interface Smoking {
    void smoking();
}
abstract class People {
    String name;
    int age;
    public People(){}
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public void sleep(){
        System.out.println("sleep");
    }
}

class Teacher extends People implements Smoking{
    public Teacher(){}
    public Teacher(String name,int age){
        super(name, age);
    }
    public void eat() {
        System.out.println("Teacher eat baicai");
    }
    public void smoking(){
        System.out.println("Teacher smoking");
    }
}

abstract class Students extends People implements Smoking {
    public Students() {}
    public Students(String name,int age) {
        super(name, age);
    }

}
public class InterfaceTest {
    public static void main(String[] args) {
        Teacher t = new Teacher("BOB",20);
        System.out.println(t.getName() + t.getAge());
        t.eat();
        t.smoking();
    }

}