JavaSE学习总结第09天_面向对象4

 

09.01 final关键字引入

例:

 class Fu
 {
     public final void show()
     {
         System.out.println("访问底层资源");
     }
 }
 class Zi extends Fu
 {
     public void show()
     {
         System.out.println("Zi show run");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Zi z = new Zi();
         z.show();
     }
 }

上面的代码中父类中的show()方法如果不想被子类覆盖，可以使用final关键字修饰，当子类覆盖了父类中的show()方法，将会报以下错误:

final关键字是最终的意思，可以修饰类，成员变量，成员方法

09.02 final关键字修饰类,方法以及变量的特点

修饰类，类不能被继承

修饰方法，方法不能被重写

修饰变量，变量就变成了常量，只能被赋值一次

09.03 final关键字修饰局部变量

例:

 class Student
 {
     int age = 10;
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //final修饰基本类型的局部变量
         final int x = 10;
         //x = 20; 值不能被改变
         System.out.println(x);

         //final修饰引用类型的局部变量
         final Student s = new Student();
         //s = new Student(); 引用类型的地址值不能变
         s.age = 20;
         System.out.println(s.age);
     }
 }

final修饰基本类型的局部变量，该变量的值不能被改变

final修饰引用类型的局部变量，引用类型的地址值不能变

09.04 final修饰变量的初始化时机

例:

 class Test
 {
     int num1;
     final int num2; //在对象构造完毕前即可
     public Test()
     {
         num1 = 100;
         num2 = 200;
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Test t = new Test();
         System.out.println(t.num1);
         System.out.println(t.num2);
     }
 }

09.05 多态的概述和前提条件

多态概述:某一个对象，在不同时刻表现出来的不同状态。

举例:猫可以是猫的类型。Cat c = new Cat();

同时猫也是动物的一种，也可以把猫称为动物。Animal a = new Animal();

多态的前提:

1.有继承关系 

2.有方法重写 

3.有父类引用指向子类对象

09.06 按照多态前提给出代码体现

 class Fu
 {
     public void show()
     {
         System.out.println("Fu show run")
     }
 }
 class Zi extends Fu
 {
     public void show()
     {
         System.out.println("Zi show run")
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //父类引用指向子类对象
         Fu f = new Zi();
     }
 }

09.07 多态中的成员访问特点

1.成员变量  编译看左边，运行看左边

例:

 class Fu
 {
     public int num1 = 10;
 }
 class Zi extends Fu
 {
     public int num1 = 20;
     public int num2 = 30;

 }
 class Demo
 {
     public static void main(String[] args)
     {
         //编译时查看Fu类中是否有num1，有就编译通过
         Fu f = new Zi();
         //运行时输出Fu类中的num1
         System.out.println(f.num1);
         //Fu类中没有num2，编译失败
         //System.out.println(f.num2);
     }
 }

2.成员方法  编译看左边，运行看右边

例:

 class Fu
 {
     public void show()
     {
         System.out.println("Fu show run");
     }

 }
 class Zi extends Fu
 {
     public void show()
     {
         System.out.println("Zi show run");
     }
     public void method()
     {
         System.out.println("Zi method run");
     }

 }
 class Demo
 {
     public static void main(String[] args)
     {
         Fu f = new Zi();
         //编译时查看Fu类中是否有show()方法，有就编译通过
         //运行时输出Zi类中show()方法
         f.show();
         //Fu类中没有num2，编译失败
         //f.method();
     }
 }

3.静态方法  编译看左边，运行看左边(静态方法与类相关，不能算方法的重写)

例:

 class Fu
 {
     public static void show()
     {
         System.out.println("Fu show run");
     }

 }
 class Zi extends Fu
 {
     public static void show()
     {
         System.out.println("Zi show run");
     }
     public void method()
     {
         System.out.println("Zi method run");
     }

 }
 class Demo
 {
     public static void main(String[] args)
     {
         Fu f = new Zi();
         //编译时查看Fu类中是否有show()方法，有就编译通过
         //运行时输出Fu类中show()方法
         f.show();
     }
 }

09.08 多态的好处

多态的好处

提高了程序的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

例:

 class Animal
 {
     public void eat()
     {
         System.out.println("eat");
     }
 }
 class Cat extends Animal
 {
     public void eat()
     {
         System.out.println("猫吃鱼");
     }
 }
 class Dog extends Animal
 {
     public void eat()
     {
         System.out.println("狗吃肉");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Cat c = new Cat();
         Dog d = new Dog();
         method(c);
         method(d);
     }
 　　 //提高了代码的扩展性，前期定义的代码可以使用后期的内容
     public static void method(Animal a)
     {
         a.eat();
     }
 }

09.09 多态的弊端

多态的弊端:不能访问子类特有功能

例:

 class Fu
 {
     public void show()
     {
         System.out.println("Fu show run");
     }
 }
 class Zi extends Fu
 {
     public void show()
     {
         System.out.println("Zi show run");
     }
     public void method()
     {
         System.out.println("Zi method run");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Fu f = new Zi();
         f.show();
         //错误，不能访问子类特有功能
         //f.method();
     }
 }

09.10 多态中向上转型和向下转型

例:

 class Fu
 {
     public void show()
     {
         System.out.println("Fu show run");
     }
 }
 class Zi extends Fu
 {
     public void show()
     {
         System.out.println("Zi show run");
     }
     public void method()
     {
         System.out.println("Zi method run");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Fu f = new Zi();
         f.show();
         //使用向下转型以使用子类特有方法
         Zi z = (Zi)f;
         z.method();
     }
 }

运行结果:

Zi show run
Zi method run

向上转型:从子到父，父类引用指向子类对象。例:Fu f = new Zi();

向下转型:从父到子，父类引用转为子类对象。例:Zi z = (Zi)f;

09.11 孔子装爹案例讲解多态现象

多态的问题理解:

 class 孔子爹
 {
     public int age = 40;

     public void teach()
     {
         System.out.println("讲解JavaSE");
     }
 }

 class 孔子 extends 孔子爹
 {
     public int age = 20;
     public void teach()
     {
         System.out.println("讲解论语");
     }
     public void playGame()
     {
         System.out.println("英雄联盟");
     }
 }

     //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
     //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
     //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
     //向上转型
     孔子爹 k爹 = new 孔子();
     //到人家那里去了
     System.out.println(k爹.age); //
     k爹.teach(); //讲解论语
     //k爹.playGame(); //这是儿子才能做的

     //讲完了，下班回家了
     //脱下爹的装备，换上自己的装备
     //向下转型
     孔子 k = (孔子) k爹;
     System.out.println(k.age); //
     k.teach(); //讲解论语
     k.playGame(); //英雄联盟

09.12 多态继承中的内存图解

09.13 多态中的对象变化内存图解

09.14 猫狗案例多态版

 class Animal
 {
     public void eat()
     {
         System.out.println("吃饭");
     }
 }
 class Cat extends Animal
 {
     public void eat()
     {
         System.out.println("猫吃鱼");
     }
     public void playGame()
     {
         System.out.println("猫玩游戏");
     }
 }
 class Dog extends Animal
 {
     public void eat()
     {
         System.out.println("狗吃肉");
     }
     public void lookDoor()
     {
         System.out.println("狗看门");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Animal a = new Dog();
         a.eat();
         Dog d = (Dog)a;
         d.lookDoor();
         System.out.println("------");
         a = new Cat();
         a.eat();
         Cat c = (Cat)a;
         c.playGame();
     }
 }

运行结果:

狗吃肉
狗看门
------
猫吃鱼
猫玩游戏

09.15 南北方人案例

 class Person
 {
     String name;
     Person(String name)
     {
         this.name = name;
         System.out.println(name);
     }
     public void eat()
     {
         System.out.println("吃饭");
     }
 }

 class SouthPerson extends Person
 {
     SouthPerson(String name)
     {
         super(name);
     }
     public void eat()
     {
         System.out.println("炒菜,吃米饭");
     }

     public void jingShang()
     {
         System.out.println("经商");
     }
 }

 class NorthPerson extends Person
 {
     NorthPerson(String name)
     {
         super(name);
     }
     public void eat()
     {
         System.out.println("炖菜,吃馒头");
     }

     public void yanJiu()
     {
         System.out.println("研究");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //测试
         //南方人
         Person p = new SouthPerson("南方人");
         p.eat();
         SouthPerson sp = (SouthPerson)p;
         sp.jingShang();
         System.out.println("--------");

         //北方人
         p = new NorthPerson("北方人");
         p.eat();
         NorthPerson np = (NorthPerson)p;
         np.yanJiu();
     }
 }

运行结果:

南方人
炒菜,吃米饭
经商
--------
北方人
炖菜,吃馒头
研究

09.16 多态的练习题看程序写结果

1.看程序写结果:先判断有没有问题，如果没有，写出结果

 class Fu
 {
     public void show()
     {
         System.out.println("fu show run");
     }
 }

 class Zi extends Fu
 {
     public void show()
     {
         System.out.println("zi show run");
     }

     public void method()
     {
         System.out.println("zi method run");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         Fu f = new Zi();
         //找不到符号
         //f.method();
         f.show();
     }
 }

运行结果:

zi show run

2.看程序写结果:先判断有没有问题，如果没有，写出结果

 class A
 {
     public void show()
     {
         show2();
     }
     public void show2()
     {
         System.out.println("hello ");
     }
 }
 class B extends A
 {
     /*
     //从父类继承
     public void show()
     {
         show2();
     }
     */

     public void show2()
     {
         System.out.println("world ");
     }
 }
 class C extends B
 {
     public void show()
     {
         super.show();
     }
     public void show2()
     {
         System.out.println("java ");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         A a = new B();
         a.show();

         B b = new C();
         b.show();
     }
 }

运行结果:

world
java

09.17 抽象类的引入

动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

09.18 抽象类的特点

抽象类特点:

1.抽象类和抽象方法必须用abstract关键字修饰

格式: abstract class 类名 {}

public abstract void method();

2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类不能实例化，因为抽象类不是具体的，抽象类有构造方法，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

4.抽象类的子类如果不重写父类中的抽象方法，那么该子类还是抽象类，否则必须重写抽象类中的所有抽象方法

例:

 abstract class Animal
 {
     public abstract void eat();
 }
 class Cat extends Animal
 {
     public void eat()
     {
         System.out.println("猫吃鱼");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //多态
         Animal a = new Cat();
         a.eat();
     }
 }

运行结果:

猫吃鱼

09.19 抽象类的成员特点

成员变量:可以是变量，也可以是常量

构造方法:有构造方法，但是不能实例化，构造方法的作用是用于子类访问父类数据的初始化

成员方法:可以有抽象方法限定子类必须完成某些动作，也可以有非抽象方法提高代码复用性

例:

 abstract class Animal
 {
     public int num1 = 10;//变量
     public final int num2 = 20;//常量
     public Animal(){}//构造函数
     public abstract void show();//抽象方法
     public void method()//非抽象方法
     {
         System.out.println("Animal method run");
     }
 }
 class Cat extends Animal
 {
     public void show()
     {
         System.out.println("Cat show run");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //创建对象
         Animal a = new Cat();
         System.out.println(a.num1);//访问变量
         System.out.println(a.num2);//访问常量
         a.show();//访问抽象方法
         a.method();//访问非抽象方法
     }
 }

运行结果:

10
20
Cat show run
Animal method run

09.20 抽象类练习猫狗案例

 /*
 猫狗案例
         具体事物:猫，狗
         共性:姓名，年龄，吃饭

 分析:从具体到抽象
 猫:
     成员变量:姓名，年龄
     构造方法:无参，带参
     成员方法:吃饭(猫吃鱼)

 狗:
     成员变量:姓名，年龄
     构造方法:无参，带参
     成员方法:吃饭(狗吃肉)

 因为有共性的内容，所以就提取了一个父类。动物。
 但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
 而方法是抽象的类，类就必须定义为抽象类。

 抽象动物类:
             成员变量:姓名，年龄
             构造方法:无参，带参
             成员方法:吃饭();

 实现:从抽象到具体
 动物类:
     成员变量:姓名，年龄
     构造方法:无参，带参
     成员方法:吃饭();

 狗类:
     继承自动物类
     重写吃饭();

 猫类:
     继承自动物类
     重写吃饭();
 */
 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();
 }
 //定义具体的狗类
 class Dog extends Animal
 {
     public Dog() {}

     public Dog(String name,int age)
     {
         super(name,age);
     }

     public void eat()
     {
         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 Demo
 {
     public static void main(String[] args)
     {
         //测试狗类，具体类用法 方式1
         Dog d = new Dog();
         d.setName("旺财");
         d.setAge(3);
         System.out.println(d.getName()+"---"+d.getAge());
         d.eat();
         //测试狗类，具体类用法 方式2:
         Dog d2 = new Dog("旺财",3);
         System.out.println(d2.getName()+"---"+d2.getAge());
         d2.eat();
         System.out.println("-------------");
         //测试狗类，多态用法 方式1:
         Animal a = new Dog();
         a.setName("旺财");
         a.setAge(3);
         System.out.println(a.getName()+"---"+a.getAge());
         a.eat();
         //测试狗类，多态用法 方式2:
         Animal a2 = new Dog("旺财",3);
         System.out.println(a2.getName()+"---"+a2.getAge());
         a2.eat();
     }
 }

运行结果:

旺财---3
狗吃肉
旺财---3
狗吃肉
-------------
旺财---3
狗吃肉
旺财---3
狗吃肉

09.21 抽象类练习老师案例

 /*
 老师案例
         具体事物:基础班老师，就业班老师
         共性:姓名，年龄，讲课。

 分析:
     基础班老师
         姓名，年龄
         讲课。
     就业班老师
         姓名，年龄
         讲课。
 实现:
     老师类
         基础班老师
         就业班老师
 */
 //定义抽象的老师类
 abstract class Teacher
 {
     //姓名
     private String name;
     //年龄
     private int age;

     public Teacher() {}

     public Teacher(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 teach();
 }

 //基础班老师类
 class BasicTeacher extends Teacher
 {
     public BasicTeacher(){}

     public BasicTeacher(String name,int age)
     {
         super(name,age);
     }

     public void teach()
     {
         System.out.println("基础班老师讲解JavaSE");
     }
 }

 //就业班老师类
 class WorkTeacher extends Teacher
 {
     public WorkTeacher(){}

     public WorkTeacher(String name,int age)
     {
         super(name,age);
     }

     public void teach()
     {
         System.out.println("就业班老师讲解JavaEE");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //多态测试
         //基础班老师
         Teacher t = new BasicTeacher();
         t.setName("小明");
         t.setAge(30);
         System.out.println(t.getName()+"---"+t.getAge());
         t.teach();
         System.out.println("--------------------");

         t = new BasicTeacher("小明",30);
         System.out.println(t.getName()+"---"+t.getAge());
         t.teach();
         System.out.println("--------------------");

         //就业班老师
         t = new WorkTeacher();
         t.setName("小红");
         t.setAge(35);
         System.out.println(t.getName()+"---"+t.getAge());
         t.teach();
         System.out.println("--------------------");

         t = new WorkTeacher("小红",35);
         System.out.println(t.getName()+"---"+t.getAge());
         t.teach();
     }
 }

运行结果:

小明---30
基础班老师讲解JavaSE
--------------------
小明---30
基础班老师讲解JavaSE
--------------------
小红---35
就业班老师讲解JavaEE
--------------------
小红---35
就业班老师讲解JavaEE

09.22 抽象类练习学员案例

 /*
 学生案例
         具体事务:基础班学员，就业班学员
         共性:姓名，年龄，班级，学习，吃饭

 分析:
     基础班学员
         成员变量:姓名，年龄，班级
         成员方法:学习，吃饭
     就业班学员
         成员变量:姓名，年龄，班级
         成员方法:学习，吃饭

 得到一个学员类。
     成员变量:姓名，年龄，班级
     成员方法:学习，吃饭

 实现:
     学员类
     基础班学员
     就业班学员
 */
 //定义抽象学员类
 abstract class Student
 {
     //姓名
     private String name;
     //年龄
     private int age;
     //班级
     private String grand;

     public Student() {}

     public Student(String name,int age,String grand)
     {
         this.name = name;
         this.age = age;
         this.grand = grand;
     }

     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 String getGrand()
     {
         return grand;
     }

     public void setGrand(String grand)
     {
         this.grand = grand;
     }

     //学习
     public abstract void study();

     //吃饭
     public void eat()
     {
         System.out.println("吃饭");
     }
 }

 //具体基础班学员类
 class BasicStudent extends Student
 {
     public BasicStudent() {}

     public BasicStudent(String name,int age,String grand)
     {
         super(name,age,grand);
     }
     //重写父类抽象方法
     public void study()
     {
         System.out.println("基础班学员学习JavaSE");
     }
 }

 //具体就业班学员类
 class WorkStudent extends Student
 {
     public WorkStudent() {}

     public WorkStudent(String name,int age,String grand)
     {
         super(name,age,grand);
     }
     //重写父类抽象方法
     public void study()
     {
         System.out.println("就业班学员学习JavaEE");
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //按照多态的方式测试基础班学员
         Student s = new BasicStudent();
         s.setName("小明");
         s.setAge(27);
         s.setGrand("1111");
         System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
         s.study();
         s.eat();
         System.out.println("--------------");

         s = new BasicStudent("小红",28,"1111");
         System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
         s.study();
         s.eat();
     }
 }

运行结果:

小明---27---1111
基础班学员学习JavaSE
吃饭
--------------
小红---28---1111
基础班学员学习JavaSE
吃饭

09.23 抽象类练习员工案例

假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性:姓名、工号以及工资。

经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。

请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

 /*

 分析:
     普通员工类
             成员变量:姓名、工号以及工资。
             成员方法:工作
     经理类:
             成员变量:姓名、工号以及工资，奖金属性
             成员方法:工作

 实现:
     员工类:
     普通员工类:
     经理类:
 */
 //定义员工类
 abstract class Employee
 {
     //姓名、工号以及工资
     private String name;
     private String id;
     private int salary;

     public Employee() {}

     public Employee(String name,String id,int salary)
     {
         this.name = name;
         this.id = id;
         this.salary = salary;
     }

     public String getName()
     {
         return name;
     }

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

     public String getId()
     {
         return id;
     }

     public void setId(String id)
     {
         this.id = id;
     }

     public int getSalary()
     {
         return salary;
     }

     public void setSalary(int salary)
     {
         this.salary = salary;
     }

     //工作
     public abstract void work();
 }

 //普通员工类
 class Programmer extends Employee
 {
     public Programmer(){}

     public Programmer(String name,String id,int salary)
     {
         super(name,id,salary);
     }

     public void work()
     {
         System.out.println("按照需求写代码");
     }
 }

 //经理类
 class Manager extends Employee
 {
     //奖金
     private int money;

     public Manager(){}

     public Manager(String name,String id,int salary,int money)
     {
         super(name,id,salary);
         this.money = money;
     }

     public void work()
     {
         System.out.println("跟客户谈需求");
     }

     public int getMoney()
     {
         return money;
     }

     public void setMoney(int money)
     {
         this.money = money;
     }
 }
 class Demo
 {
     public static void main(String[] args)
     {
         //测试普通员工
         Employee emp = new Programmer();
         emp.setName("小明");
         emp.setId("czbk001");
         emp.setSalary(18000);
         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
         emp.work();
         System.out.println("-------------");
         emp = new Programmer("小明","czbk001",18000);
         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
         emp.work();
         System.out.println("-------------");

         //由于子类有特有的内容，所以我们用子类来测试
         Manager m = new Manager();
         m.setName("小红");
         m.setId("czbk002");
         m.setSalary(8000);
         m.setMoney(2000);
         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
         m.work();
         System.out.println("-------------");

         //通过构造方法赋值
         m = new Manager("小红","czbk002",8000,2000);
         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
         m.work();
     }
 }

运行结果:

小明---czbk001---18000
按照需求写代码
-------------
小明---czbk001---18000
按照需求写代码
-------------
小红---czbk002---8000---2000
跟客户谈需求
-------------
小红---czbk002---8000---2000
跟客户谈需求

09.24 抽象类中的小问题

1.一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

可以。不让创建对象。

2.abstract不能和哪些关键字共存

private 冲突

final   冲突

static  无意义

09.25 接口的引入

为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

09.26 接口的特点

接口特点:接口用关键字interface表示，格式:interface 接口名 {}

类实现接口用implements表示，格式:class 类名 implements 接口名 {}

接口不能实例化，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

接口的子类要么是抽象类，要么重写接口中的所有抽象方法

09.27 接口的成员特点

成员变量:只能是常量，默认修饰符 public static final

构造方法:没有，因为接口主要是扩展功能的，而没有具体存在

成员方法:只能是抽象方法，默认修饰符 public abstract

09.28 类与类,类与接口,接口与接口的关系

类与类的关系:继承关系，只能单继承，但是可以多层继承

类与接口的关系:实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口的关系:继承关系，可以单继承，也可以多继承

09.29 抽象类和接口的区别

成员区别:

抽象类:成员变量，可以是变量也可以是常量。构造方法，有。成员方法，可以是抽象方法也可以是非抽象方法

接口:成员变量，只可以是常量。构造方法，没有。成员方法，只可以是抽象方法

关系区别:

类与类继承，单继承

类与接口实现，单实现，多实现

接口与接口继承，单继承，多继承

设计理念区别:

抽象类被继承体现的是:”is a”的关系。继承体系的共性功能

接口被实现体现的是:”like a”的关系。继承体系的扩展功能

09.30 猫狗案例加入跳高功能分析

猫狗案例,加入跳高的额外功能

分析:从具体到抽象

猫:姓名,年龄  吃饭，睡觉

狗:姓名,年龄  吃饭，睡觉

由于有共性功能，所以，我们抽取出一个父类:

动物:姓名,年龄     吃饭();睡觉(){}      

猫:继承自动物

狗:继承自动物

跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口:跳高   

部分猫:实现跳高

部分狗:实现跳高

实现:从抽象到具体

使用:使用具体类

09.31 猫狗案例加入跳高功能代码实现

 //定义跳高接口
 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 Demo
 {
     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();
     }
 }

运行结果:

哆啦A梦---3
猫吃鱼
睡觉
跳高猫
------------
加菲猫---2
猫吃鱼
睡觉
跳高猫

09.32 老师学生案例加入抽烟功能分析及代码实现

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