Java语言

面向对象

多态
  1. 概述：某一个事物，在不同时刻表现出来的不同状态。
    例：
    Cat c=new Cat();
    Animal a=new Cat();
    猫可以是猫的类型，猫 m = new 猫();
    同时猫也是动物的一种，也可以把猫称为动物，动物 d = new 猫();
  2. 多态前提：
    a:要有继承关系；
    b:要有方法重写； 其实没有也是可以的，但是如果没有这个多态就没有意义；
    c:要有父类引用指向子类对象；
    父 f = new 子();
  3. 多态中的成员访问特点：
    a:成员变量
    编译看左边，运行看左边。
    b:构造方法
    创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
    c:成员方法
    编译看左边，运行看右边。
    d:静态方法
    编译看左边，运行看左边。
    (静态和类相关，算不上重写，所以，访问还是左边的)
  4. 多态的好处：
    a:提高了代码的维护性(继承保证)
    b:提高了代码的扩展性(由多态保证)
    多态的弊端：
    不能使用子类特有的功能；若需使用，需将父类的引用强制转换为子类的引用即向下转型。
//定义一个Fu类，一个Zi类，用多态去访问成员；
public class MyTest {
    public static void main(String[] args) {
        FU fu = new Zi();//多态
        fu.method();
        System.out.println(fu.num);
        Zi zi= (Zi) fu;
        zi.methodd();//访问子类特有的方法，向下转型，还有一种表达方式：((Zi) fu).methodd();
        System.out.println(zi.num);
    }
}

class FU{
    int num=10;
    public void method(){}
}

class Zi extends FU{
    int num=20;
    @Override
    public void method() {
        System.out.println("Fu method");
    }
    public void methodd(){
        System.out.println("子类特有的方法");
    }
}
/*运行结果：
          10
          子类特有的方法
          20
*/
抽象类
  1. 概述：当人说到动物时，我们并不知道说的是什么动物，只有看到了具体的动物，才知道这是什么动物；所以说，动物本身并不是一个具体的事物，而是一个抽象的事物，只有真正的猫，狗才是具体的动物；同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。
    在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
  2. 抽象类特点：
    a:抽象类和抽象方法必须用abstract关键字修饰
    抽象类格式: abstract class 类名 {}
    抽象方法格式: public abstract void 方法名();
    b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类；
    c:抽象类中可以有构造方法,用于子类访问父类数据时的初始化；
    d:抽象类不能直接实例化，那么抽象类如何实例化呢?
    按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
    e:抽象类的子类：
    要么是抽象类
    要么重写抽象类中的所有抽象方法
  3. 抽象类的成员特点：
    a:成员变量：既可以是变量，也可以是常量。
    b:构造方法：用于子类访问父类数据的初始化。
    c:成员方法：既可以是抽象的，也可以是非抽象的。
  4. 抽象类的成员方法特性：
    a:抽象方法 强制要求子类做的事情。
    b:非抽象方法 子类继承的事情，提高代码复用性。
  5. abstract不能和哪些关键字共存?
    private 与 abstract 矛盾 abstract 强制子类重写， private 限定后又无法重写
    final 与 abstract 矛盾 abstract 强制子类重写， final 重写不了
    abstract 与 static 矛盾

例1.
假如我们在开发一个系统时需要对员工(Employee)类、经理(Manager)类进行设计，员工包含2个属性：姓名、年龄；
经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性；
然后定义工作的方法.
请使用继承、抽象的思想设计出员工类和经理类。

//员工(Employee)类：
public abstract class Employee {
    private String  name;
    private int 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 work();
}
//经理(Manager)类：
public class Manager extends Employee{
    private double bonus;
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    @Override
    public void work() {
        System.out.println("经理进行的工作");
    }
    public void fitness(){
        System.out.println("经理进行的特有的工作----健身");
    }
}
//测试类：
public class MyTest {
    public static void main(String[] args) {
        Employee employee = new Manager();
        employee.setName("张三");
        employee.setAge(25);
        Manager manager = (Manager) employee;
        manager.setBonus(30000);
        System.out.println(employee.getName());
        System.out.println(employee.getAge());
        System.out.println(manager.getBonus());
        manager.work();
        manager.fitness();
    }
}
/*运行结果：
          张三
          25
          30000.0
          经理进行的工作
          经理进行的特有的工作----健身
*/
接口
  1. 概述：继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，但是，现在有很多的人可以训练出：猫钻火圈，狗跳高，狗做计算等特殊技能，这些特殊的技能，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的，故这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可；即接口。
  2. 接口特点：
    a:接口用关键字interface表示 格式: interface 接口名 {}
    b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
    c:接口不能实例化，那么，接口如何实例化呢?
    按照多态的方式来实例化。
    d:接口的子类
    a:可以是抽象类，但是意义不大。
    b:可以是具体类，要重写接口中的所有抽象方法。
  3. 类与类,类与接口,接口与接口的关系
    a:类与类：
    继承关系,只能单继承,可以多层继承。
    b:类与接口：
    实现关系,可以单实现,也可以多实现。
    并且还可以在继承一个类的同时实现多个接口。
    c:接口与接口：
    继承关系,可以单继承,也可以多继承。
  4. 抽象类和接口的区别
  • 成员区别
    抽象类：
    成员变量：可以变量，也可以常量
    构造方法：有
    成员方法：可以抽象，也可以非抽象
    接口：
    成员变量：只可以常量
    成员方法：只可以抽象
  • 关系区别
    类与类
    继承，单继承
    类与接口
    实现，单实现，多实现
    接口与接口
    继承，单继承，多继承
  • 设计理念区别
    抽象类 被继承体现的是：”is a”的关系，抽象类中定义的是该继承体系的共性功能。
    接口 被实现体现的是：”like a”的关系，接口中定义的是该继承体系的扩展功能。

例2.
动物类：姓名，年龄，吃饭，睡觉；
动物培训接口：跳高
狗继承动物类
部分狗继承狗类并实现跳高接口
通过抽象类测试基本功能
通过接口测试扩展功能。

//动物类：
public class Animal {
    int age;
    String name;
    public void eat(){
    }
    public void sleep(){
    }
}
//狗类：
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗睡觉");
    }
}
//会跳高的部分狗：
public class 会跳高的狗 extends Dog implements Jump{
    @Override
    public void jump() {
        System.out.println("布鲁斯会跳高了！！");
    }
}
//测试类：
public class Test{
    public static void main(String[] args) {
        会跳高的狗 dog = new 会跳高的狗();
        dog.name="布鲁斯";
        dog.age=3;
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat();
        dog.sleep();
        dog.jump();
    }
}
/*运行结果：
         布鲁斯
         3
         狗吃骨头
         狗睡觉
         布鲁斯会跳高了！！
*/