9.0 Java面向对象三大特性

• 封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的
• 多态概念：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
• 动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
• 关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果

9.1 Java面向对象（多态的概述及其代码体现）

• 多态（polymorphic）概述

  • 事物存在多种形态

• 多态前提（三个必要条件）

  • 1.要有继承关系
  • 2.要有方法重写
  • 3.要有父类引用指向子类对象

Animal an = new Cat(); //父类引用指向子类对象
an.eat();  //行为结果却是子类的行为

9.2 多态中的成员访问特点

• 1.成员变量
  • 编译看左边，运行看左边。
• 2.成员方法
  • 编译看左边（父类），运行看右边（子类）。（动态绑定）
• 3.静态方法
  • 编译看左边，运行看左边。
  • 静态和类相关，算不上重写，所以访问还是看左边。
  • 只有非静态的成员方法，编译看左边，运行看右边。

多态中的成员变量内存图.png

9.3 多态中的向上转型 和 向下转型

class Person {
    String name = "普通人";
    
    public void xxoo () {
        System.out.println("我是普通人...");
    }
}

class SuperMan extends Person {
    String name = "超人";
    
    public void xxoo () {
        System.out.println("我是超人...");
    }
    
    public void fly() {
        System.out.println("超人会飞...");
    }
}

Person p = new SuperMan();   //向上转型。父类引用指向子类对象
SuperMan sm = (SuperMan)p;   //向下转型。

Person p = new SuperMan();   //父类引用指向子类对象
System.out.println(p.name);  //成员属性，输出父类的属性值
        
p.xxoo();   //成员方法，运行结果 是子类的行为
p.fly();    //编译错误，子类的方法，父类指针内部 找不到子类方法，只有强制转型之后，才可以使用。

System.out.println("---------------");
        
SuperMan sm = (SuperMan)p;
System.out.println(sm.name);
sm.xxoo();
sm.fly();

内存图.png

9.4多态的优缺点

• 多态的好处：
  • 1.提高了代码的可维护性（继承保证）
  • 2.提高了代码的扩展性（多态保证）
  • 3.可以当作形参，接收任意子类对象
• 多态的弊端
  • 不能使用子类特有的属性和行为（需要强转）

// 方法 参数是 动物类
public void method(Animal aniaml) {
    // 关键字 instanceof 判断前面的引用是否是后边的数据类型
    if (aniaml instanceof Cat) {
        Cat cat = (Cat)aniaml ;
    }
    else if (aniaml instanceof Dog) {
        Dog dog = (Dog)aniaml ;
    }
    else return ;
}

9.5多态代码题

• 题目一：多态的理解

class Fu {    // 父类
    int num = 10;
    
    public void show() {
        System.out.println("fu show");
    }
}

class Zi extends Fu {   // 子类
    int num = 20 ;
    
    public void show() {
        System.out.println("zi show");
    }
}

// 运行代码

Fu fu = new Zi();
System.out.println(fu.num);   // 结果10 ：成员变量，编译看左边，运行看左边
fu.show();  // 结果 "zi show" 成员方法，编译看左边，运行看右边

9.6 抽象类

• A:抽象类概述
  • 抽象就是看不懂的
• B:抽象类的特点

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

    • abstract class ClassName {}
    • public abstract void xxoo() ; //注意没有{ }

  • 2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者接口

  • 3.抽象类不能直接实例化，必须由其具体子类实例化，所谓 抽象类多态

  • 4.抽象类的子类：要么是抽象类，要么重写抽象类中的所有抽象方法

abstract class Animal { //抽象类
    int num = 10;
    static final int num2 = 200 ;
    
    public void sleep() {}  //普通方法
    
    public abstract void eat() ;  //抽象方法
}

class Cat extends Animal {  // 子类实现抽象类
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

// Cat 继承并实现了 抽象类Animal
Animal cat = new Cat();
cat.eat();

// 匿名内部类  的方式实例化抽象类
// 只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现
// 这种方式常见于 多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口
Animal dog = new Animal() {
    public void eat() {
        System.out.println("狗啃骨头");
    }
};
dog.eat();

• 抽象类的成员特点：
  • 1.成员变量：既可以是变量，也可以是常量。abstract不能修饰变量/常量
  • 2.抽象类有构造方法（必须有啊，不然子类怎么super()）
  • 3.成员方法： 既可以是抽象的，也可以是非抽象的。

9.7 抽象类面试题

• A.面试题一

  • 一个抽象类如没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
  • 可以
  • 这么做的目的只有一个：就是不让其他类创建本类对象，交给子类完成。

• 面试题二

  • abstract不能和哪些关键字共存？
  • 不能和：final 、static、private 共存

9.8 接口

• A.接口概述

  • 从狭义角度讲就是指的java中的interface
  • 从广义角度讲对外提供规则的都是接口

• B.接口特点

  • 1.接口用关键字interface声明表示：
  • 2.类实现接口用 implements表示
  • 3.接口不能直接实例化，需要实现接口的类，或者多态的方式
  • 4.接口的子类可以是抽象类（但是意义不大），也可以是具体类，实现接口中所有的抽象方法。

9.9 接口的成员特点

• A：成员变量，只能是常量，并且是静态的公共的。
  • 默认修饰符是： public、static、final
• 构造方法：接口没有构造方法，实现接口，不是继承！
• 成员方法：只能是抽象方法。默认修饰符：public、abstract，建议自己手动给出。

interface InreName { //接口定义
    int num = 10;  //成员变量，只能是常量，并且是 public、static、final
    public abstract void print(); //接口中的方法都是抽象的
}

class Demo implements InreName { //实现接口
    public void print() {
        System.out.println("实现接口的全部方法");
    }
}

9.10 类与类，类与接口，接口与接口的关系

• 类与类：
  • 继承关系，只能单继承，可以多层继承
• 类与接口：
  • 实现关系，可以单实现，也可以多实现；可以继承一个类的同时，实现多个接口。
• 接口与接口：
  • 继承关系，可以单继承，也可以多继承。

class ClassB extends ClassA implements InterA,InterB {
    // 类可以继承一个类的同时，实现多个接口
}

interface InterC extends InterA, InterB {
    // 接口可以多继承其他接口，切只能是接口
}

9.11 抽象类与接口的区别

设计理念区别：

• 抽象类 被继承体现的是 is a 的关系，抽象类中定义的是该继承体系的共性功能。
• 接口 被实现体现的是 like a 的关系，接口中定义的是改继承体系的扩展功能。

END。
我是小侯爷。
在魔都艰苦奋斗，白天是上班族，晚上是知识服务工作者。
如果读完觉得有收获的话，记得关注和点赞哦。
非要打赏的话，我也是不会拒绝的。