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); //40
    k爹.teach(); //讲解论语
    //k爹.playGame(); //这是儿子才能做的
    
    //讲完了，下班回家了
    //脱下爹的装备，换上自己的装备
    //向下转型
    孔子 k = (孔子) k爹; 
    System.out.println(k.age); //20
    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();
    }
}