2018-07-08 13:47:26
final关键字
多态
从右向前念
多态的成员访问特点及转型的理解
1 多态的问题理解： 2 class 孔子爹 { 3 public int age = 40; 4 5 public void teach() { 6 System.out.println("讲解JavaSE"); 7 } 8 } 9 10 class 孔子 extends 孔子爹 { 11 public int age = 20; 12 13 public void teach() { 14 System.out.println("讲解论语"); 15 } 16 17 public void playGame() { 18 System.out.println("英雄联盟"); 19 } 20 } 21 22 //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了 23 //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢? 24 //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹 25 //向上转型 26 孔子爹 k爹 = new 孔子(); 27 //到人家那里去了 28 System.out.println(k爹.age); //40 29 k爹.teach(); //讲解论语 30 //k爹.playGame(); //这是儿子才能做的 31 32 33 //讲完了，下班回家了 34 //脱下爹的装备，换上自己的装备 35 //向下转型 36 孔子 k = (孔子) k爹; 37 System.out.println(k.age); //20 38 k.teach(); //讲解论语 39 k.playGame(); //英雄联盟 40
多态继承中的内存图解
向上转型
向下转型
抽象类
1 /* 2 抽象类的概述： 3 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。 4 我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。 5 6 抽象类的特点： 7 A:抽象类和抽象方法必须用abstract关键字修饰 8 B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类 9 C:抽象类不能实例化 10 因为它不是具体的。 11 抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢? 12 用于子类访问父类数据的初始化 13 D:抽象的子类 14 a:如果不想重写抽象方法，该子类是一个抽象类。 15 b:重写所有的抽象方法，这个时候子类是一个具体的类。 16 17 抽象类的实例化其实是靠具体的子类实现的。是多态的方式。 18 Animal a = new Cat(); 19 */ 20 21 //abstract class Animal //抽象类的声明格式 22 abstract class Animal { 23 //抽象方法 24 //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体 25 public abstract void eat(); 26 27 public Animal(){} 28 } 29 30 //子类是抽象类 31 abstract class Dog extends Animal {} 32 33 //子类是具体类，重写抽象方法 34 class Cat extends Animal { 35 public void eat() { 36 System.out.println("猫吃鱼"); 37 } 38 } 39 40 class AbstractDemo { 41 public static void main(String[] args) { 42 //创建对象 43 //Animal是抽象的; 无法实例化 44 //Animal a = new Animal(); 45 //通过多态的方式 46 Animal a = new Cat(); 47 a.eat(); 48 } 49 }
1 /* 2 抽象类的成员特点： 3 成员变量：既可以是变量，也可以是常量。 4 构造方法：有。 5 用于子类访问父类数据的初始化。 6 成员方法：既可以是抽象的，也可以是非抽象的。 7 8 抽象类的成员方法特性： 9 A:抽象方法 强制要求子类做的事情。 10 B:非抽象方法 子类继承的事情，提高代码复用性。 11 */ 12 abstract class Animal { 13 public int num = 10; 14 public final int num2 = 20; 15 16 public Animal() {} 17 18 public Animal(String name,int age){} 19 20 public abstract void show(); 21 22 public void method() { 23 System.out.println("method"); 24 } 25 } 26 27 class Dog extends Animal { 28 public void show() { 29 System.out.println("show Dog"); 30 } 31 } 32 33 class AbstractDemo2 { 34 public static void main(String[] args) { 35 //创建对象 36 Animal a = new Dog(); 37 a.num = 100; 38 System.out.println(a.num); 39 //a.num2 = 200; 40 System.out.println(a.num2); 41 System.out.println("--------------"); 42 a.show(); 43 a.method(); 44 } 45 }
猫狗案例
*注意：分析和实现的过程
1 /* 2 猫狗案例 3 具体事物：猫，狗 4 共性：姓名，年龄，吃饭 5 6 分析：从具体到抽象 7 猫: 8 成员变量：姓名，年龄 9 构造方法：无参，带参 10 成员方法：吃饭(猫吃鱼) 11 12 狗: 13 成员变量：姓名，年龄 14 构造方法：无参，带参 15 成员方法：吃饭(狗吃肉) 16 17 因为有共性的内容，所以就提取了一个父类。动物。 18 但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的， 19 而方法是抽象的类，类就必须定义为抽象类。 20 21 抽象动物类： 22 成员变量：姓名，年龄 23 构造方法：无参，带参 24 成员方法：吃饭(); 25 26 实现：从抽象到具体 27 动物类: 28 成员变量：姓名，年龄 29 构造方法：无参，带参 30 成员方法：吃饭(); 31 32 狗类： 33 继承自动物类 34 重写吃饭(); 35 36 猫类： 37 继承自动物类 38 重写吃饭(); 39 */ 40 //定义抽象的动物类 41 abstract class Animal { 42 //姓名 43 private String name; 44 //年龄 45 private int age; 46 47 public Animal() {} 48 49 public Animal(String name,int age) { 50 this.name = name; 51 this.age = age; 52 } 53 54 public String getName() { 55 return name; 56 } 57 58 public void setName(String name) { 59 this.name = name; 60 } 61 62 public int getAge() { 63 return age; 64 } 65 66 public void setAge(int age) { 67 this.age = age; 68 } 69 70 //定义一个抽象方法 71 public abstract void eat(); 72 } 73 74 //定义具体的狗类 75 class Dog extends Animal { 76 public Dog() {} 77 78 public Dog(String name,int age) { 79 super(name,age); 80 } 81 82 public void eat() { 83 System.out.println("狗吃肉"); 84 } 85 } 86 87 //定义具体的猫类 88 class Cat extends Animal { 89 public Cat() {} 90 91 public Cat(String name,int age) { 92 super(name,age); 93 } 94 95 public void eat() { 96 System.out.println("猫吃鱼"); 97 } 98 } 99 100 //测试类 101 class AbstractTest { 102 public static void main(String[] args) { 103 //测试狗类 104 //具体类用法 105 //方式1： 106 Dog d = new Dog(); 107 d.setName("旺财"); 108 d.setAge(3); 109 System.out.println(d.getName()+"---"+d.getAge()); 110 d.eat(); 111 //方式2： 112 Dog d2 = new Dog("旺财",3); 113 System.out.println(d2.getName()+"---"+d2.getAge()); 114 d2.eat(); 115 System.out.println("---------------------------"); 116 117 Animal a = new Dog(); 118 a.setName("旺财"); 119 a.setAge(3); 120 System.out.println(a.getName()+"---"+a.getAge()); 121 a.eat(); 122 123 Animal a2 = new Dog("旺财",3); 124 System.out.println(a2.getName()+"---"+a2.getAge()); 125 a2.eat(); 126 127 //练习：测试猫类
128 } 129 }
员工案例
1 /* 2 假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。 3 经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。 4 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。 5 6 分析： 7 普通员工类 8 成员变量：姓名、工号以及工资。 9 成员方法：工作 10 经理类： 11 成员变量：姓名、工号以及工资，奖金属性 12 成员方法：工作 13 14 实现： 15 员工类： 16 普通员工类： 17 经理类： 18 */ 19 //定义员工类 20 abstract class Employee { 21 //姓名、工号以及工资 22 private String name; 23 private String id; 24 private int salary; 25 26 public Employee() {} 27 28 public Employee(String name,String id,int salary) { 29 this.name = name; 30 this.id = id; 31 this.salary = salary; 32 } 33 34 public String getName() { 35 return name; 36 } 37 38 public void setName(String name) { 39 this.name = name; 40 } 41 42 public String getId() { 43 return id; 44 } 45 46 public void setId(String id) { 47 this.id = id; 48 } 49 50 public int getSalary() { 51 return salary; 52 } 53 54 public void setSalary(int salary) { 55 this.salary = salary; 56 } 57 58 //工作 59 public abstract void work(); 60 } 61 62 //普通员工类 63 class Programmer extends Employee { 64 public Programmer(){} 65 66 public Programmer(String name,String id,int salary) { 67 super(name,id,salary); 68 } 69 70 public void work() { 71 System.out.println("按照需求写代码"); 72 } 73 } 74 75 //经理类 76 class Manager extends Employee { 77 //奖金 78 private int money; //bonus 奖金 79 80 public Manager(){} 81 82 public Manager(String name,String id,int salary,int money) { 83 super(name,id,salary); 84 this.money = money; 85 } 86 87 public void work() { 88 System.out.println("跟客户谈需求"); 89 } 90 91 public int getMoney() { 92 return money; 93 } 94 95 public void setMoney(int money) { 96 this.money = money; 97 } 98 } 99 100 class AbstractTest4 { 101 public static void main(String[] args) { 102 //测试普通员工 103 Employee emp = new Programmer(); 104 emp.setName("林青霞"); 105 emp.setId("czbk001"); 106 emp.setSalary(18000); 107 System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary()); 108 emp.work(); 109 System.out.println("-------------"); 110 emp = new Programmer("林青霞","czbk001",18000); 111 System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary()); 112 emp.work(); 113 System.out.println("-------------"); 114 115 /* 116 emp = new Manager(); 117 emp.setName("刘意"); 118 emp.setId("czbk002"); 119 emp.setSalary(8000); 120 emp.setMoney(2000); 121 */ 122 //由于子类有特有的内容，所以我们用子类来测试 123 Manager m = new Manager(); 124 m.setName("刘意"); 125 m.setId("czbk002"); 126 m.setSalary(8000); 127 m.setMoney(2000); 128 System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney()); 129 m.work(); 130 System.out.println("-------------"); 131 132 //通过构造方法赋值 133 m = new Manager("刘意","czbk002",8000,2000); 134 System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney()); 135 m.work(); 136 } 137 }
接口
new 对象时 从右往前念
接口的概念和特点
1 /* 2 接口的特点： 3 A:接口用关键字interface表示 4 interface 接口名 {} 5 B:类实现接口用implements表示 6 class 类名 implements 接口名 {} 7 C:接口不能实例化 8 那么，接口如何实例化呢? 9 按照多态的方式来实例化。 10 D:接口的子类 11 a:可以是抽象类。但是意义不大。 12 b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案) 13 14 由此可见： 15 A:具体类多态(几乎没有) 16 B:抽象类多态(常用) 17 C:接口多态(最常用) 18 */ 19 //定义动物培训接口 20 interface AnimalTrain { 21 public abstract void jump(); 22 } 23 24 //抽象类实现接口 25 abstract class Dog implements AnimalTrain { 26 } 27 28 //具体类实现接口 29 class Cat implements AnimalTrain { 30 public void jump() { 31 System.out.println("猫可以跳高了"); 32 } 33 } 34 35 class InterfaceDemo { 36 public static void main(String[] args) { 37 //AnimalTrain是抽象的; 无法实例化 38 //AnimalTrain at = new AnimalTrain(); 39 //at.jump(); 40 41 AnimalTrain at = new Cat(); 42 at.jump(); 43 } 44 }
接口的默认修饰符：
public static final ...
建议自己手动给出
接口成员的特点：
成员变量：
只能是常量，并且是静态的
默认修饰符：public static final
建议：自己手动给出
构造方法：接口没有构造方法
成员方法：
只能是抽象方法
默认修饰符：public abstrac
建议自己手动给出
所有的类都默认继承自一个类：Object.
类Object是类层次结构的根类。每个类都使用Object作为超类
1 /* 2 接口成员特点 3 成员变量；只能是常量，并且是静态的。 4 默认修饰符：public static final 5 建议：自己手动给出。 6 构造方法：接口没有构造方法。 7 成员方法：只能是抽象方法。 8 默认修饰符：public abstract 9 建议：自己手动给出。 10 11 所有的类都默认继承自一个类：Object。 12 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。 13 */ 14 interface Inter { 15 public int num = 10; 16 public final int num2 = 20; 17 public static final int num3 = 30; 18 19 //错误: 需要<标识符> 20 //public Inter() {} 21 22 //接口方法不能带有主体 23 //public void show() {} 24 25 //abstract void show(); //默认public 26 public void show(); //默认abstract 27 } 28 29 //接口名+Impl这种格式是接口的实现类格式 30 /* 31 class InterImpl implements Inter { 32 public InterImpl() { 33 super(); 34 } 35 } 36 */ 37 38 class InterImpl extends Object implements Inter { 39 public InterImpl() { 40 super(); 41 } 42 43 public void show() {} 44 } 45 46 //测试类 47 class InterfaceDemo2 { 48 public static void main(String[] args) { 49 //创建对象 50 Inter i = new InterImpl(); 51 System.out.println(i.num); 52 System.out.println(i.num2); 53 //i.num = 100; 54 //i.num2 = 200; 55 //System.out.println(i.num); //无法为最终变量num分配值 56 //System.out.println(i.num2);//无法为最终变量num2分配值 57 System.out.println(Inter.num); 58 System.out.println(Inter.num2); 59 System.out.println("--------------"); 60 } 61 }
类与类，类与接口，接口与接口的关系
类与类：
继承关系，只能单继承，可以多层继承
类与接口：
实现关系，可以单实现，也可以多实现
并且还可以继承一个类的同时实现多个接口
接口与接口：
继承关系，可以单继承，也可以多继承
1 /* 2 类与类： 3 继承关系,只能单继承,可以多层继承。 4 类与接口： 5 实现关系,可以单实现,也可以多实现。 6 并且还可以在继承一个类的同时实现多个接口。 7 接口与接口： 8 继承关系,可以单继承,也可以多继承。 9 */ 10 interface Father { 11 public abstract void show(); 12 } 13 14 interface Mother { 15 public abstract void show2(); 16 } 17 18 interface Sister extends Father,Mother { 19 20 } 21 22 //class Son implements Father,Mother //多实现 23 class Son extends Object implements Father,Mother { 24 public void show() { 25 System.out.println("show son"); 26 } 27 28 public void show2() { 29 System.out.println("show2 son"); 30 } 31 } 32 33 class InterfaceDemo3 { 34 public static void main(String[] args) { 35 //创建对象 36 Father f = new Son(); 37 f.show(); 38 //f.show2(); //报错 39 40 Mother m = new Son(); 41 //m.show(); //报错 42 m.show2(); 43 } 44 }
2018-07-09 08:06:34
接口 接口中定义的是该继承体系的扩展功能
分析过程：从具体到抽象
实现过程：从抽象到具体
1 /* 2 猫狗案例,加入跳高的额外功能 3 4 分析：从具体到抽象 5 猫： 6 姓名,年龄 7 吃饭，睡觉 8 狗： 9 姓名,年龄 10 吃饭，睡觉 11 12 由于有共性功能，所以，我们抽取出一个父类： 13 动物： 14 姓名,年龄 15 吃饭(); 16 睡觉(){} 17 18 猫：继承自动物 19 狗：继承自动物 20 21 跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口 22 接口： 23 跳高 24 25 部分猫：实现跳高 26 部分狗：实现跳高 27 实现； 28 从抽象到具体 29 30 使用： 31 使用具体类 32 */ 33 //定义跳高接口 34 interface Jumpping { 35 //跳高功能 36 public abstract void jump(); 37 } 38 39 //定义抽象类 40 abstract class Animal { 41 //姓名 42 private String name; 43 //年龄 44 private int age; 45 46 public Animal() {} 47 48 public Animal(String name,int age) { 49 this.name = name; 50 this.age = age; 51 } 52 53 public String getName() { 54 return name; 55 } 56 57 public void setName(String name) { 58 this.name = name; 59 } 60 61 public int getAge() { 62 return age; 63 } 64 65 public void setAge(int age) { 66 this.age = age; 67 } 68 69 //吃饭(); 70 public abstract void eat(); 71 72 //睡觉(){} 73 public void sleep() { 74 System.out.println("睡觉觉了"); 75 } 76 } 77 78 //具体猫类 79 class Cat extends Animal { 80 public Cat(){} 81 82 public Cat(String name,int age) { 83 super(name,age); 84 } 85 86 public void eat() { 87 System.out.println("猫吃鱼"); 88 } 89 } 90 91 //具体狗类 92 class Dog extends Animal { 93 public Dog(){} 94 95 public Dog(String name,int age) { 96 super(name,age); 97 } 98 99 public void eat() { 100 System.out.println("狗吃肉"); 101 } 102 } 103 104 //有跳高功能的猫 105 class JumpCat extends Cat implements Jumpping { 106 public JumpCat() {} 107 108 public JumpCat(String name,int age) { 109 super(name,age); 110 } 111 112 public void jump() { 113 System.out.println("跳高猫"); 114 } 115 } 116 117 //有跳高功能的狗 118 class JumpDog extends Dog implements Jumpping { 119 public JumpDog() {} 120 121 public JumpDog(String name,int age) { 122 super(name,age); 123 } 124 125 public void jump() { 126 System.out.println("跳高狗"); 127 } 128 } 129 130 class InterfaceTest { 131 public static void main(String[] args) { 132 //定义跳高猫并测试 133 JumpCat jc = new JumpCat(); 134 jc.setName("哆啦A梦"); 135 jc.setAge(3); 136 System.out.println(jc.getName()+"---"+jc.getAge()); 137 jc.eat(); 138 jc.sleep(); 139 jc.jump(); 140 System.out.println("-----------------"); 141 142 JumpCat jc2 = new JumpCat("加菲猫",2); 143 System.out.println(jc2.getName()+"---"+jc2.getAge()); 144 jc2.eat(); 145 jc2.sleep(); 146 jc2.jump(); 147 148 //定义跳高狗并进行测试的事情自己完成。 149 } 150 }
老师和学生案例，加入抽烟功能的额外功能
1 /* 2 老师和学生案例,加入抽烟的额外功能 3 4 分析：从具体到抽象 5 老师：姓名，年龄，吃饭，睡觉 6 学生：姓名，年龄，吃饭，睡觉 7 8 由于有共性功能，我们提取出一个父类，人类。 9 10 人类： 11 姓名，年龄 12 吃饭(); 13 睡觉(){} 14 15 抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口 16 17 抽烟接口。 18 19 部分老师抽烟：实现抽烟接口 20 部分学生抽烟：实现抽烟接口 21 22 实现：从抽象到具体 23 24 使用：具体 25 */ 26 //定义抽烟接口 27 interface Smoking { 28 //抽烟的抽象方法 29 public abstract void smoke(); 30 } 31 32 //定义抽象人类 33 abstract class Person { 34 //姓名 35 private String name; 36 //年龄 37 private int age; 38 39 public Person() {} 40 41 public Person(String name,int age) { 42 this.name = name; 43 this.age = age; 44 } 45 46 public String getName() { 47 return name; 48 } 49 50 public void setName(String name) { 51 this.name = name; 52 } 53 54 public int getAge() { 55 return age; 56 } 57 58 public void setAge(int age) { 59 this.age = age; 60 } 61 62 //吃饭(); 63 public abstract void eat(); 64 65 //睡觉(){} 66 public void sleep() { 67 System.out.println("睡觉觉了"); 68 } 69 } 70 71 //具体老师类 72 class Teacher extends Person { 73 public Teacher() {} 74 75 public Teacher(String name,int age) { 76 super(name,age); 77 } 78 79 public void eat() { 80 System.out.println("吃大白菜"); 81 } 82 } 83 84 //具体学生类 85 class Student extends Person { 86 public Student() {} 87 88 public Student(String name,int age) { 89 super(name,age); 90 } 91 92 public void eat() { 93 System.out.println("吃红烧肉"); 94 } 95 } 96 97 //抽烟的老师 98 class SmokingTeacher extends Teacher implements Smoking { 99 public SmokingTeacher() {} 100 101 public SmokingTeacher(String name,int age) { 102 super(name,age); 103 } 104 105 public void smoke() { 106 System.out.println("抽烟的老师"); 107 } 108 } 109 110 //抽烟的学生 111 class SmokingStudent extends Student implements Smoking { 112 public SmokingStudent() {} 113 114 public SmokingStudent(String name,int age) { 115 super(name,age); 116 } 117 118 public void smoke() { 119 System.out.println("抽烟的学生"); 120 } 121 } 122 123 class InterfaceTest2 { 124 public static void main(String[] args) { 125 //测试学生 126 SmokingStudent ss = new SmokingStudent(); 127 ss.setName("林青霞"); 128 ss.setAge(27); 129 System.out.println(ss.getName()+"---"+ss.getAge()); 130 ss.eat(); 131 ss.sleep(); 132 ss.smoke(); 133 System.out.println("-------------------"); 134 135 SmokingStudent ss2 = new SmokingStudent("刘意",30); 136 System.out.println(ss2.getName()+"---"+ss2.getAge()); 137 ss2.eat(); 138 ss2.sleep(); 139 ss2.smoke(); 140 141 //测试老师留给自己练习 142 } 143 }
今日总结：
1:final关键字(掌握)
(1)是最终的意思，可以修饰类，方法，变量。
(2)特点：
A:它修饰的类，不能被继承。
B:它修饰的方法，不能被重写。
C:它修饰的变量，是一个常量。
(3)面试相关：
A:局部变量
a:基本类型 值不能发生改变
b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
B:初始化时机
a:只能初始化一次。
b:常见的给值
定义的时候。(推荐)
构造方法中。
2:多态(掌握)
(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。
多态的分类：
a:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量
编译看左边，运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边
为什么?
因为成员方法有重写。
(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端：
父不能使用子的特有功能。
现象：
子可以当作父使用，父不能当作子使用。
(6)多态中的转型
A:向上转型
从子到父
B:向下转型
从父到子
(7)孔子装爹的案例帮助大家理解多态
(8)多态的练习
A:猫狗案例
B:老师和学生案例
3:抽象类(掌握)
(1)把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是一个抽象类。
b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
A:成员变量
有变量，有常量
B:构造方法
有构造方法
C:成员方法
有抽象，有非抽象
(4)抽象类的练习
A:猫狗案例练习
B:老师案例练习
C:学生案例练习
D:员工案例练习
(5)抽象类的几个小问题
A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
为了不让创建对象
C:abstract不能和哪些关键字共存
a:final 冲突
b:private 冲突
c:static 无意义
4:接口(掌握)
(1)回顾猫狗案例，它们仅仅提供一些基本功能。
比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
(2)接口的特点：
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract
(4)类与类,类与接口,接口与接口
A:类与类
继承关系，只能单继承，可以多层继承
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口
C:接口与接口
继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别(自己补齐)?
A:成员区别
抽象类：
接口：
B:关系区别:
类与类：
类与接口：
接口与接口：
C:设计理念不同
抽象类：is a，抽象类中定义的是共性功能。
接口：like a，接口中定义的是扩展功能。
(6)练习：
A:猫狗案例，加入跳高功能
B:老师和学生案例，加入抽烟功能0