5.7.3.1 新旧车案例

我们用一个例子来总结解释一下多态情况下里对于变量与方法的调用问题。

车行里我们有一辆BmwX5车。

public class BmwX5{
public int price = 500000;
public void speed(){
System.out.println(“150KM/H”);
}
}
我们这里还有一辆二手的X5;
public class BmwX5_1 extends BmwX5{
public int price = 200000;
public void speed(){
System.out.println(“120KM/H”);
}
}

有人来买车，新车没了，只有一辆二手的在这。然后开着出去试驾了，工作人员说这是新车。

BmwX5 bmw = new BmwX5_1(); // 这叫向上转型

人问了，你这家多钱？

System.out.println(bmw.price); // 你说应该说这车多少钱？ 成员变量是事物的外物描述

然后，买车的人一脚油门下去。

bmw.speed(); // 最大能开多快？？ 成员方法是事物的具体功能

你赶紧拦着，说这边限速，只开到了90KM/H.

然后试驾的回去了。来了个人说买二手车。现在这个车，是二手车，还是新车？

BmwX5_1 bmw1 = (BmwX5_1)bmw; //向下转型
System.out.println(bmw1.price);
bmw1.speed();

5.7.3.2多态继承中的内存图解

class Car{
public String price = “10”;
public void print(){
System.out.println(“我就是辆车！”);
}
}

class BmwCar extends Car{
public String price = “55”;
public void print(){
System.out.println(“我是宝马车”);
}
public void price(){
System.out.println(“这个车有点贵”);
}
}

class TestDemo{
public static void main(String[] args){
Car car = new BmwCar();
System.out.println(car.price);
car.price();
car.print();
}
}

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

class Car{
public void print(){}
}

class BmwCar extends Car{
public void print(){}
public void price(){}
}
class BenzCar extends Car {
public void print(){};
public void speed(){}
}

class CarDemo{
public static void main(String[] args){
Car c = new Bmwcar();
c.print();
c.price();

BmwCar bmw = (BmwCar)c;
bmw.print();
bmw.price();

c = new BenzCar();
c.print();
c.speed();

BenzCar benz = (BenzCar)c;
benz.print();
benz.speed();

BmwCar bmw1 = (Benz)c;
}
}

画图之前，先看一下。代码哪里会出错误。

5.7.3.4多态需要注意的地方及练习：

例 1：

class Car{} class BmwCar extends Car{} class BenzCar extends Car{}
class CarDemo{
BmwCar bmw = new Car(); 错 从语法定义来看，车叫宝马。行吗？ 报错，不兼容类型
BmwCar bmw1 = new BenzCar(); 错 从语法定义来看，奔驰是宝马。报错，不兼容类型
}

例 2：看下面程序有没有问题，如果没有问题，结果是多少？

class Car {
public void print() {
System.out.println("I’m Car ");
}
}

class BmwCar extends Car {
public void print() {
System.out.println("I’m BmwCar");
}
public void price() {
System.out.println("500000");
}
}

class TestDemo {
public static void main(String[] args) {
Car c = new BmwCar();
c.print();
c.price();
}
}

例 3：

class A {
public void show() {
show2();
}
public void show2() {
System.out.println("A");
}
}
class B extends A {
public void show2() {
System.out.println("B");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("C");
}
}

public class TestDemo {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}

OK,这里总合一下。

多态成员访问特点：成员变量：编译运行都看左边。方法：编译看左边，运行看右边。

继承:子类中有和父类一样的方法，是重写。子类中没有出现父类中的方法，也继承了过来。

5.7.4 instanceof运算符

instanceof运算符的前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类（也可以是接口，接口也是类，是一种特殊的类），它用于判断前面引用变量所指向的具体对象是否是后面这个类，或者后面这个类的子类，或者后面这个类的实现类的一个实例对象。是则返回ture，否则返回false。

举例1：

package com.langsin.test;
public class Test {
public static void main(String[] args) {
Object obj = "hello";
System.out.println(obj instanceof Object);
//true
System.out.println(obj instanceof String);
//true
System.out.println(obj instanceof Math);
//false
String a = "hello";
//编译失败报错：Incompatible conditional operand types String and Math（不相容的条件和数学操作数类型字符串）
System.out.println(a instanceof Math);
}
}