/*
 老师和学生案例,加入抽烟的额外功能
 
 分析：从具体到抽象
  老师：姓名，年龄，吃饭，睡觉
  学生：姓名，年龄，吃饭，睡觉
  
  由于有共性功能，我们提取出一个父类，人类。
  
  人类：
   姓名，年龄
   吃饭();
   睡觉(){}
   
  抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口
  
  抽烟接口。

  部分老师抽烟：实现抽烟接口
  部分学生抽烟：实现抽烟接口
  
 实现：从抽象到具体
  
 使用：具体
*/
//定义抽烟接口
interface Smoking {
 //抽烟的抽象方法
 public abstract void smoke();
}

//定义抽象人类
abstract class Person {
 //姓名
 private String name;
 //年龄
 private int age;
 
 public Person() {}
 
 public Person(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("睡觉觉了");
 }
}

//具体老师类
class Teacher extends Person {
 public Teacher() {}
 
 public Teacher(String name,int age) {
  super(name,age);
 }
 
 public void eat() {
  System.out.println("吃大白菜");
 }
}

//具体学生类
class Student extends Person {
 public Student() {}
 
 public Student(String name,int age) {
  super(name,age);
 }
 
 public void eat() {
  System.out.println("吃红烧肉");
 }
}

//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking {
 public SmokingTeacher() {}
 
 public SmokingTeacher(String name,int age) {
  super(name,age);
 }

 public void smoke() {
  System.out.println("抽烟的老师");
 }
}

//抽烟的学生
class SmokingStudent extends Student implements Smoking {
 public SmokingStudent() {}
 
 public SmokingStudent(String name,int age) {
  super(name,age);
 }

 public void smoke() {
  System.out.println("抽烟的学生");
 }
}

class InterfaceTest2 {
 public static void main(String[] args) {
  //测试学生
  SmokingStudent ss = new SmokingStudent();
  ss.setName("林青霞");
  ss.setAge(27);
  System.out.println(ss.getName()+"---"+ss.getAge());
  ss.eat();
  ss.sleep();
  ss.smoke();
  System.out.println("-------------------");
  
  SmokingStudent ss2 = new SmokingStudent("刘意",30);
  System.out.println(ss2.getName()+"---"+ss2.getAge());
  ss2.eat();
  ss2.sleep();
  ss2.smoke();
  
  //测试老师留给自己练习
 }
}/*
 猫狗案例,加入跳高的额外功能
 
 分析：从具体到抽象
  猫：
   姓名,年龄
   吃饭，睡觉
  狗：
   姓名,年龄
   吃饭，睡觉
   
  由于有共性功能，所以，我们抽取出一个父类：
  动物：
   姓名,年龄
   吃饭();
   睡觉(){}
   
  猫：继承自动物
  狗：继承自动物
  
  跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
  接口：
   跳高
   
  部分猫：实现跳高
  部分狗：实现跳高
 实现；
  从抽象到具体
  
 使用：
  使用具体类
*/
//定义跳高接口
interface Jumpping {
 //跳高功能
 public abstract void jump();
}

//定义抽象类
abstract class Animal {
 //姓名
 private String name;
 //年龄
 private int age;
 
 public Animal() {}
 
 public Animal(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("睡觉觉了");
 }
}

//具体猫类
class Cat extends Animal {
 public Cat(){}
 
 public Cat(String name,int age) {
  super(name,age);
 }
 
 public void eat() {
  System.out.println("猫吃鱼");
 }
}

//具体狗类
class Dog extends Animal {
 public Dog(){}
 
 public Dog(String name,int age) {
  super(name,age);
 }
 
 public void eat() {
  System.out.println("狗吃肉");
 }
}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
 public JumpCat() {}
 
 public JumpCat(String name,int age) {
  super(name,age);
 }

 public void jump() {
  System.out.println("跳高猫");
 }
}

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
 public JumpDog() {}
 
 public JumpDog(String name,int age) {
  super(name,age);
 }

 public void jump() {
  System.out.println("跳高狗");
 }
}

class InterfaceTest {
 public static void main(String[] args) {
  //定义跳高猫并测试
  JumpCat jc = new JumpCat();
  jc.setName("哆啦A梦");
  jc.setAge(3);
  System.out.println(jc.getName()+"---"+jc.getAge());
  jc.eat();
  jc.sleep();
  jc.jump();
  System.out.println("-----------------");
  
  JumpCat jc2 = new JumpCat("加菲猫",2);
  System.out.println(jc2.getName()+"---"+jc2.getAge());
  jc2.eat();
  jc2.sleep();
  jc2.jump();
  
  //定义跳高狗并进行测试的事情自己完成。
 }
}/*
 类与类：
  继承关系,只能单继承,可以多层继承。
 类与接口：
  实现关系,可以单实现,也可以多实现。
  并且还可以在继承一个类的同时实现多个接口。
 接口与接口：
  继承关系,可以单继承,也可以多继承。
*/
interface Father {
 public abstract void show();
}

interface Mother {
 public abstract void show2();
}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
 public void show() {
  System.out.println("show son");
 }
 
 public void show2() {
  System.out.println("show2 son");
 }
}

class InterfaceDemo3 {
 public static void main(String[] args) {
  //创建对象
  Father f = new Son();
  f.show();
  //f.show2(); //报错
 
  Mother m = new Son();
  //m.show(); //报错
  m.show2();
 }
}/*
 接口成员特点
  成员变量；只能是常量，并且是静态的。
    默认修饰符：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
 public void show(); //默认abstract
}

//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
 public InterImpl() {
  super();
 }
}
*/

class InterImpl extends Object implements Inter {
 public InterImpl() {
  super();
 }
 
 public void show() {}
}

//测试类
class InterfaceDemo2 {
 public static void main(String[] args) {
  //创建对象
  Inter i = new InterImpl();
  System.out.println(i.num);
  System.out.println(i.num2);
  //i.num = 100;
  //i.num2 = 200;
  //System.out.println(i.num); //无法为最终变量num分配值
  //System.out.println(i.num2);//无法为最终变量num2分配值
  System.out.println(Inter.num);
  System.out.println(Inter.num2);
  System.out.println("--------------");
 }
}/*
 接口的特点：
  A:接口用关键字interface表示 
   interface 接口名 {}
  B:类实现接口用implements表示
   class 类名 implements 接口名 {}
  C:接口不能实例化
   那么，接口如何实例化呢?
   按照多态的方式来实例化。
  D:接口的子类
   a:可以是抽象类。但是意义不大。
   b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
 
 由此可见：
  A:具体类多态(几乎没有)
  B:抽象类多态(常用)
  C:接口多态(最常用)
*/
//定义动物培训接口
interface AnimalTrain {
 public abstract void jump();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain {
}

//具体类实现接口
class Cat implements AnimalTrain {
 public void jump() {
  System.out.println("猫可以跳高了");
 }
}

class InterfaceDemo {
 public static void main(String[] args) {
  //AnimalTrain是抽象的; 无法实例化
  //AnimalTrain at = new AnimalTrain();
  //at.jump();
  
  AnimalTrain at = new Cat();
  at.jump();
 }
}抽象类和接口的区别：
A:成员区别
 抽象类：
  成员变量：可以变量，也可以常量
  构造方法：有
  成员方法：可以抽象，也可以非抽象
 接口：
  成员变量：只可以常量
  成员方法：只可以抽象
  
B:关系区别
 类与类
  继承，单继承
 类与接口
  实现，单实现，多实现
 接口与接口
  继承，单继承，多继承
  
C:设计理念区别
 抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
 接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。