corejava_day5

最新推荐文章于 2024-11-03 11:01:20 发布

柑橘味柚芽

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量157

点赞数

分类专栏： corejava 文章标签： java 多态

本文链接：https://blog.csdn.net/weixin_41700993/article/details/106746833

版权

corejava 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

目标：类和对象

corejava_day5

类与对象

类与对象

1. OOP特征概述

Java的编程语言是面向对象，采用这种语言进行编程称为面向对象编程(Object-Oriented)

1. 抽象(abstract)

忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用关注细节。

例如：要设计一个学生成绩管理系统，那么对于学生，只关心他的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。

2. 封装(Encapsulation)

封装是面向对象的特征之一，是对象和类概念的主要特征。封装是把过程和数据包围起来，对数据的访问只能通过指定的方式。

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部可见的，哪些特性用于表示内部状态。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐蔽。

信息隐蔽是用户对封装性的认识，封装则为信息隐蔽提供支持。

封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

3. 继承(inheritance)

继承是一种联结类的层次模型，并且允许和支持类的重用，它提供了一种明确表述共性的方法。

新类继承了原始类后，新类就继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。

派生类（子类）可以从它的基类（父类）那里继承方法和实例变量，并且派生类（子类）中可以修改或增加新的方法使之更适合特殊的需要

继承性很好的解决了软件的可重用性问题。比如说，所有的windows应用程序都有一个窗口，它们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。

4. 多态(polymorphism)

多态性是指允许不同类的对象对同一消息作出响应。

多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

相同类域的不同对象，调用相同方法，表现出不同的结果

例如：

public class Person() {
    public void say() {
        
    }
}
public class Student extends Person {
    public void say() {
        System.out.println("I am a student");
    }
}
public class Teacher extends Person() {
    public void say() {
        System.out.println("I am a teacher");
    }
}

main:

Person s = new Student();
Person t = new Teacher();
s.say(); // I am a student
t.say(); // I am a teacher

2. 类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表一个具体的事物。

例如：我们生活中所说的词语：动物、植物、手机、电脑等等。

这些也都是抽象的概念，而不是指的某一个具体的东西。

例如：Person类、Room类、Car类等

这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

例如：张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

例如：

Student s = new Student(1L,"tom",20);
s.study();

Car c = new Car(1,"BWM",500000);
c.run();

对象s就是Student类的一个实例，对象c就是Car类的一个具体实例，能够使用的是具体实现，而不是类。类只是给对象的创建提供了一个参考的模版而已。

但是在Java中，没有类就没有对象，然而类又是根据具体的功能需求，进行实际的分析，最终抽象出来的。

3. 对象和引用的关系

引用“指向”对象

使用类类型、数组类型、接口类型声明出的变量，都可以指向对象，这种变量就是引用类型变量，简称引用。

在程序中，创建出对象后，直接使用并不方便，所以一般会用一个引用类型的变量去接收这个对象，这个就是所说的引用指向对象。

总结：对象和引用的关系，就如电视机和遥控器，风筝和线的关系一样。

4. 方法的定义和调用

方法一定是定义在类中的，属于类的成员。

1. 方法的定义：

修饰符 返回类型 方法名（参数列表）异常抛出类型{...}

1. 修饰符

public static abstract final等等都是修饰符，一个方法可以有多个修饰符。

例如程序入口main方法，就是用了public static这个两个修饰符

注：如果一个方法或者属性有多个修饰符，这多个修饰符是没有先后顺序的。

2. 返回类型

方法执行完如果有要返回的数据，那么就要声明返回数据的类型，如果没有返回的数据，那么返回类型就必须写void。

只有构造方法（构造器）不写任何返回类型也不写void

例如：

public String sayHello() {
    return "hello";
}
public int max(int a,int b) {
    return a>b?a:b;
}
public void print(String msg) {
    System.out.println(msg);
}

思考：声明返回类型的方法中一定要出现return语句，那么没有返回类型(void)的方法中，能不能出现return语句？

可以，只是单纯的跳出方法体。

注：break和return的区别

break结束当前循环 return是跳出当前方法

3. 方法名

遵守Java中标示符的命名规则即可。

4. 参数列表

根据需求定义，方法可以是无参的，也可以有一个参数，也可以有多个参数

5.异常抛出类型

如果方法中的代码在执行过程中，可能会出现一些异常情况，那么就可以在方法上把这些异常声明并抛出，也可以同时声明抛出多个异常，使用逗号隔开即可。

例如：

public void readFile(String file)throws IOException{
    
}
public void readFile(String file)throws IOException,ClassNotFoundException{
    
}

2. 方法的调用：

在类中的定义了方法，这个方法中的代码并不会执行，当这个方法被调用的时候，方法中的代码才会被一行一行顺序执行。

1. 非静态方法

没有使用static修饰符修饰的方法，就是非静态方法。

调用这种方法的时候，是“一定”要使用对象的。因为非静态方法是属于对象的。（非静态属性也是一样的）

例如：

public class Student{
    public void say(){
        
    }
}
main:
Student s = new Student();
s.say();

2. 静态方法

使用static修饰符修饰的方法，就是静态方法。

调用这种方法的时候，“可以”使用对象调用，也“可以”使用类来调用，但是推荐使用类进行调用，因为静态方法是属于类的。（静态属性也是一样的）

例如：

public class Student {
    public static void say() {
        
    }
}

main:
    Student.say();

3. 类中方法之间的调用

假设同一个类中有两个方法，a方法和b方法

a和b都是非静态方法，相互之间可以直接调用

public void a() {
    b();
}
public void b() {
    
}

a和b都是静态方法，相互之间可以直接调用

public static void a() {
    b();
}
public static void b(){
    
}

a静态方法，b是非静态方法

a方法中不能直接调用b方法，但是b方法中可以直接调用a方法

public static void a() {
    // b(); // 报错
}
public void b() {
    a();
}

另外：在同一个类中，静态方法内也不能直接访问到类中的非静态属性。

5. 调用方法时的传参

1. 形参和实参

例如：

// a = x;
public void test(int a) {
    // ...
}
main:
    int x = 1;
    t.test(x);

参数列表中的a是方法test的形参（形式上的参数）

调用方法时的x是方法test的实参（实际上的参数）

注意：形参的名字和实参的名字都只是一个变量的名字，是可以随便写的，我们并不关心这个名字，而是关心变量的类型以及变量接收的值。

2. 值传递和引用传递

调用方法进行传参时，分为值传递和引用传递两种。

如果参数的类型是基本数据类型，那么就是值传递。

如果参数的类型是引用数据类型，那么就是引用传递。

值传递是实参把自己变量本身存的简单数值赋值给形参。

引用传递是实参把自己变量本身存的对象内存地址值赋值给形参。

所以值传递和引用传递本质上是一回事，只不过传递的东西的意义不同而已。

3. 值传递的示例

public class Test() {
    public static void changeNum(int a) {
        a = 10;
    }
    public static void main(String[] args) {
        int a = 1;
        System.out.println("before:a = " + a); // 1
        changeNum(a);
        System.out.println("after:a = " + a); // 1
    }
}

4. 引用传递的示例

public class Test {
    public static void changeName(Student s) {
        s.name = "tom";
    }
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("before:name " + s.name); // null
        changeName(s);
        System.out.println("after:name " + s.name); // tom
    }
}

6. this关键字

在类中，可以使用this关键字表示一些特殊的作用。

1. 区别成员变量和局部变量

public class Student{
    private String name;
    public void setName(String name) {
        // this.name表示类中的属性name
        this.name = name;
    }
}

2. 调用类中的其他方法

public class Student {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void print() {
        // 表示调用当前类中的setName方法
        this.setName("tom");
    }
}

注：默认情况下，setName(“tom”)和this.setName(“tom”)的效果是一样的。

3. 调用类中的其他构造器

public class Student {
    private String name;
    public Student() {
        // 调用一个参数的构造器，并且参数的类型是String
        this("tom");
    }
    public Student(String name) {
        this.name = name;
    }
}

注：this的这种用法，只能在构造器中使用。普通的方法这种是不能使用的。并且这局调用的代码只能出现在构造器中的第一句。

例如：

public class Student {
    private String name;
    // 编译报错，因为this("tom")不是构造器中的第一句代码
    public Student() {
        System.out.println("hello");
        this("tom");
    }
    public Student(String name) {
        this.name = name;
    }
}

4. this关键字在类中的意义

this在类中表示当前类将来创建出的对象

例如：

public class Student{
    private String name;
    public Student() {
        System.out.println("this = " + this);
    }
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("s =  " + s);
    }
}

运行后看结果可知，this和s打印的结果是一样的，那么其实也就是变量s是从对象的外部执行对象，而this是在对象的内部执行对象本身。

这样也就能理解为什么this.name代表的是成员变量，this.setName(“tom”)代表的是调用成员方法，因为这两句代码从本质上讲，和在对象外部使用变量s来调用是一样的，s.name和s.setName(“tom”)。

this和s打印出来的内存地址是一样的，使用==比较的结果为true。

例如：

public class Student {
    public Student getStudent() {
        return this;
    }
    
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = s1.getStudent();
        System.out.println(s1 == s2); // true
    }
}

例如：类中的this是和s1相等还是和s2相等呢？

public class Student {
    private String name;
    public void test() {
        System.out.println(this);
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
        s1.test();
        s2.test();
    }
}

注：这句话是要这么来描述的，s1对象中的this和s1相等，s2对象中的this和s2相等，因为类是模版，模版中写的this并不是只有一个，每个对象中都有一个属于自己的this，就是每个对象中都一个属于自己的name属性一样。

7. 数据隐藏

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

例如：

// 对象不仅能在类中方法，还能在类的外部“直接”访问
public class Student {
    public String name;
    public void println() {
        System.out.println(this.name);
    }
}
public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "tom";
    }
}

在类中一般不会把数据直接暴露在外部的，而使用private（私有）关键字把数据隐藏起来

例如：

public class Student {
    private String name;
}
public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        // 编译报错，在类的外部不能直接访问类中的私有成员
        s.name = "tom";
    }
}

如果在类的外部需要访问这些私有属性，那么可以在类中提供对于的get和set方法，以便让用户在类的外部可以间接的访问到私有属性

例如：

// set负责给属性赋值
// get负责返回属性的值
public class Stduent {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}
public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("tom");
        System.out.println(s.getName());
    }
}

思考：这样处理私有属性的作用

为了实现良好的封装性
如果外面的程序可以随意修改一个类的成员变量，会造成不可预料的程序错误

8. 封装

隐藏代码的实现细节
统一用户的调用接口
提高系统的可维护性

9. 方法重载

类中有多个方法，有着相同的方法名，但是方法的参数各不相同，这种情况被称为方法的重载。

方法的重载可以提供方法调用的灵活性。

例如：

System.out.println()中的println方法，为什么可以把不同类型的参数传给这个方法？

例如：

public class Test{
    public void test(String str) {
        
    }
    public void test(int a) {
        
    }
}

方法重载必须满足以下条件：

方法名相同
参数列表不同（参数的类型、个数、顺序的不同）

public void test(String str) {}
public void test(int a) {}

public void test(String str,double d) {}
public void test(String str) {}
    
public void test(String str,double d) {}
public void test(double d,String str) {}

方法的返回值可以不同

注：在Java中，判断一个类中的两个方法是否相同，主要参考两个方面：方法名字和参数列表

思考：方法重载有什么好处？

只需要记住唯一一个方法名称，就可以实现类似的多个功能。

10. 创建和初始化对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

那么对main方法中的以下代码：

Student s = new Student();

为对象分配内存空间，将对象的实例变量自动初始化默认值为0/false/null。（实例变量的隐式赋值）
如果代码中实例变量有显式赋值，那么就将之前的默认值覆盖掉。（之后可以通过例子看到这个现象）

例如：显式赋值

private String name = "tom";

调用构造器
把对象内存地址值赋值给变量。（=号赋值操作）

11. 构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

必须和类的名字相同
必须没有返回类型，也不能写void

构造器的作用：

使用new创建对象的时候必须使用类的构造器
构造器中的代码执行后，可以给对象中的属性初始化赋值

例如：

public class Student {
    private String name;
    public Student() {
        name = "tom";
    }
}

构造器重载：

除了无参构造器之外，很多时候我们还会使用有参构造器，在创建对象时候可以给属性赋值。

例如：

public class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }
}

构造器之间的调用：

使用this关键字，在一个构造器中可以调用另一个构造器的代码。

注意：this的这种用法不会产生新的对象，只是调用了构造器中的代码而已。一般情况下只使用new关键字才会创建新对象。

例如：

public class Student {
    private String name;
    public Student() {
        this();
    }
}

默认构造器：

在Java中，即使我们在编写类的时候没有写构造器，那么在编译之后也会自动的添加一个无参构造器，这个无参构造器也被称为默认的构造器。

例如：

public class Student {
    
}
main:
    // 编译通过，因为有无参构造器
    Student s = new Student();

但是，如果我们手动搞得编写了一个构造器，那么编译后就不会添加任何构造器了

例如：

public class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }
}
main:
    // 编译报错，因为没有无参构造器
    Student s = new Student();

12. 继承

1. 继承是类和类之间的一种关系

除此之外，类和类之间的关系还有依赖、组合、聚合等。

2. 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。

子类继承父类，使用关键字extends来表示

例如：

public class Student extends Person {
    
}

3. 子类和父类之间，从意义上将应该具有 "is a"的关系

例如：

Student is a person
dog is a animal

4. 类和类之间的继承是单继承

一个子类只能“直接”继承一个父类，就像是一个人只能有一个亲生父亲。

一个父类可以被多子类继承，就像一个父类可以有多个孩子。

注：Java中接口和接口之间，有可以继承，并且是多继承。

5. 父类中的属性和方案可以被子类继承

子类中继承了父类中的属性和方法后，在子类中能不能直接使用这些属性和方法，是和这些属性和方法原有的修饰符(public protected defaul private)相关的。

例如：

父类中的属性和方法使用public修饰，在子类中继承后“可以直接”使用

父类中的属性和方法使用private修饰，在子类中继承后“不可以直接”使用

注：具体细节在修饰符部分详细说明

父类中的构造器是不能被子类继承的，但是子类的构造器，会隐式的调用父类的无参构造器（默认使用super关键字）。

注：具体细节在super关键字部分详细说明

6. Object类

Java中的每一个类都是“直接”或者“间接”的继承了Object类，所以每一个对象都和Object类有 "is a"的关系。从API文档中，可以看到任何一个类最上层的父类都是Object。（Object类本身除外）

AnyClass is a Object

例如：

System.out.println(任何对象 instanceof Object);
// 输出结果：true
注：任何对象也包含数组对象

例如：

// 编译后，Person类会默认继承Object
public class Person{}

// Student是间接的继承了Object
public class Student extends Person{}

在Object类中，提供了一些方法被子类继承，那么就意味着，在Java中，任何一个对象都可以调用这些被继承过来的方法。（因为Object是所有类的父类）

例如：toString方法、equals方法、getClass方法等

注：Object类中的每一个方法之后都会使用到。

思考：继承有什么好处？

子类能自动继承父类的对象
创建子类的对象时，无需创建父类的对象

13. super关键字

子类继承父类之后，在子类中可以使用this来表示访问或调用子类中的属性或方法，使用super就表示访问或调用子类中的属性和方法

1. 访问父类中的属性

例如：

public class Person {
    protected String name = "zs";
}
public class Student extends Person {
    private String name = "lisi";
    public void test() {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

2. 调用父类中的方法

例如：

public class Person {
    public void print() {
        System.out.println("Person");
    }
}
public class Student extends Person {
    public void print() {
        System.out.println("Student");
    }
    public void test() {
        print();
        this.print();
        super.print();
    }
}

3. 调用父类中的构造器

例如：

public class Person {
    
}
public class Student extends Person {
    // 编译通过，子类构造器中会隐式的调用父类的无参构造器
    // super();
    public Student() {
        
    }
}

例如：

public class Person {
    protected String name;
    public Person(String name) {
        this.name = name;
    }
}
public class Student extends Person {
    // 编译报错，子类构造器中隐式的调用父类的无参构造器，但是父类中没有无参构造器
    // super();
    public Student() {
        
    }
}

例如：

public class Person {
    protected String name;
    public Person(String name) {
        this.name = name;
    }
}
public class Student extends Person {
    // 编译通过，子类构造器中显式的调用父类的有参构造器
    public Student() {
        super("tom");
    }
}

注：不管是显式还是隐式的父类的构造器，super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用其调用构造器的功能，因为它们都要出现在第一行代码位置。

例如：

public class Person {
    protected String name;
    public Person(String name) {
        this.name = name;
    }
}
public class Student extends Person {
    // 编译报错，super调用构造器的语句不是第一行代码
    public Student() {
        System.out.println("Student");
        super("tom");
    }
}

例如：

public class Person {
    protected String name;
    public Person(String name) {
        this.name = name;
    }
}
// 编译通过
public class Student extends Person {
    private int age;
    public Student() {
        this(20);
    }
    public Student(int age) {
        super("tom");
        this.age = age;
    }
}

思考：这样做的目的是什么？

调用父类的构造方法主要是为了初始化父类的数据成员。

14. 方法重写（方法覆盖）

1. 方法重写只存在于子类和父类（包括直接父类和间接父类）之间。在同一个类中方法只能被重载，不能被重写。

2. 静态方法不能重写

a. 父类的静态方法不能被子类重写为非静态方法 // 编译出错
b. 父类的非静态方法不能被子类重写为静态方法 // 编译出错
c. 子类可以定义与父类的静态方法同名的静态方法（但是这个不是覆盖）

例如：

A类继承B类，A和B中都一个相同的静态方法test

B a = new A();
a.test(); // 调用到的时候B类中的静态方法test

A a = new A();
a.test(); // 调用到的时候A类中的静态方法test

可以看出静态方法的调用只和变量声明的类型相关

这个和非静态方法的重写之后的效果完全不同

3. 私有方法不能被子类重写

子类继承父类后，是不能直接访问父类中的私有方法的，那么就更谈不上重写了。

例如：

public class Person {
    private void run() {
        
    }
}
// 编译通过，但这不是重写，只是两个类中分别有自己的私有方法
public class Student extends Person {
    private void run() {
        
    }
}

4. 重写的语法

1. 方法名必须相同

2. 参数列表必须相同

3. 访问控制修饰符可以被扩大，但是不能被缩小

public protected default private

4. 抛出异常类型的范围可以被缩小，但是不能被扩大

ClassNotFoundException --> Exception

5. 返回类型可以相同，也可以不同，如果不同的话，子类重写后的方法返回类型是父类方法返回类型的子类型

例如：父类方法的返回类型是Person，子类重写后的返回类型可以是Person也可以是Person的子类型

注：一般情况下，重写的方法会和父类中的方法的声明完全保持一致。只有方法的实现不同。（也就是大括号中代码不一样）

例如：

public class Person {
    public void run() {}
    
    protected Object test()throws Exception {
        return null;
    }
}
// 编译通过，子类继承父类，重写了run和test方法。
public class Student extends Person {
    public void run() {}
    
    public String test() {
        return "";
    }
}

5. 为什么要重写

子类继承父类，继承了父类中的方法，但是父类中的方法并不一定能满足子类中的功能需要，所以子类中需要把方法进行重写。

15. 多态

允许不同类的对象同一消息做出相应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

相同类域的不同对象，调用相同的方法，执行结果是不同的

1. 一个对象的实际类型是确定的

例如：

new Student();
new Person();
...

2. 可以指向对象的引用的类型有很多

一个对象的实现类型虽然是确定的，但是这个对象所属的类型可能有很多种。

例如：Student继承了Person类

Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();

因为Person和Object都是Student的父类型

注：一个对象的实际类型是确定，但是可以指向这个对象的引用的类型，却是可以是这对象实际类型的任意父类型。

3. 一个父类引用可以指向它的任何一个子类对象

例如：

Object o = new AnyClass();
Person p = null;
p = new Student();
p = new Teacher();
p = new Person();

4. 多态中的方法调用

例如：

public class Person {
    public void run() {}
}
public class extends Person {
    
}
// 调用到的run方法，是Student从Person继承过来的run方法
main: 
    Person p = new Student();
    p.run();

例如：

public class Person{
    public void run() {}
}
public class Student extends Person {
    public void run() {
        // 重写run方法
    }
}
// 调用到的run方法，是Student中重写的run方法
main:
    Person p = new Student();
    p.run();

注：子类继承父类，调用a方案，如果a方法在子类中没有重写，那么就是调用的是子类继承父类的a方法，如果重写了，那么调用的就是重写之后的方法。

5. 子类中独有方法的调用

例如：

public class Person{
    public void run() {}
}
public class Stduent extends Person {
    public void test() {}
}
main:
    Person p = new Student();
    // 调用到继承的run方法
    p.run();
    
    // 编译报错，因为编译器检查
    变量p的类型是Person，但是在Person类中并没有发现test方法，所以编译报错。
    p.test():

注：一个变量x，调用一个方法test，编译器是否能让其编译通过，主要是看声明变量x的类型中有没有定义test方法，如果有则编译通过，如果没有则编译报错。而不是看x所指向的对象中有没有test方法。

思考：为什么编译器会是这样检查？

6. 子类引用和父类引用指向对象的区别

Student s = new Student();
Person p = new Student():

变量s能调用的方法是Student中有的方法（包括继承过来的），变量p能调用的方法是Person中有的方法（包括继承过来的）。

但是变量p是父类型的，p不仅可以指向Student对象，还可以指向Teacher类型对象等，但是变量s只能指向Student类型对象，及Student子类型对象。变量p能指向对象的范围是比变量s大的。

Object类型的变量o，能指向所有对象，它的范围最大，但是使用变量o能调用的方法也是最少的，只能调用到Object中的声明的方法，因为变量o声明的类型就是Object。

注：Java中的方法调用，是运行时动态和对象绑定的，不到运行的时候，是不知道到底哪个方法被调用的。

7. 重写、重载和多态的关系

重载是编译时多态

调用重载的方法，在编译期间就要确定调用的方法是谁，如果不能确定则编译报错。

重写是运行时多态

调用重写的方法，在运行期间才能确定这个方法到底是哪个对象中的。这个取决于调用方法的引用，在运行期间所指向的对象是谁，这个引用指向哪个对象那么调用的就是哪个对象中的方法。（Java中的方法调用，是运行时动态和对象绑定的）

8. 多态的使用

如果使用多态解决以下问题：

public class Game {
    public void start(BasketBall ball) {
        ball.run();
    }
}
public class BasketBall {
    public void run() {
        // 执行篮球游戏程序
    }
    
}

在这种情况下，用户不断的变动需求：
想要增加足球游戏的运行
想要增加乒乓球游戏的运行
想要增加橄榄球游戏的运行
想要增加羽毛球游戏的运行
想要增加铅球游戏的运行
...

如何处理？

instanceof和类型转换

例如：

public class Person {
    public void run() {}
}
public class Student extends Person {
    
}
public class Teacher extends Person {
    
}

main:
    Object o = new Student();
    System.out.println(o instanceof Student); // true
    System.out.println(o instanceof Person); // true
    System.out.println(o instanceof Object); // true
    System.out.println(o instanceof Teacher); // false
    System.out.println(o instanceof String); // false
    
    --------------------------------------------------
    
    Person o = new Student();
    System.out.println(o instanceof Student); // true
    System.out.println(o instanceof Person); // true
    System.out.println(o instanceof Object); // true
    System.out.println(o instanceof Teacher); // false
    // 编译报错
    System.out.println(o instanceof String); // false
    
    --------------------------------------------------
    
    Student o = new Student();
    System.out.println(o instanceof Student); // true
    System.out.println(o instanceof Person); // true
    System.out.println(o instanceof Object); // true
    // 编译报错
    System.out.println(o instanceof Teacher); 
    // 编译报错
    System.out.println(o instanceof String);

注1：

System.out.println(X instanceof Y);

该代码能否编译通过，主要是看声明变量X的类型和Y是否存在子父类的关系。有“子父类”关系就编译通过，没有子父类关系就是编译报错。

之后学习到的接口类型和这个是有点区别的。

注2：

System.out.println(X instanceof Y);
输出结果是true还是false，主要是看变量X所指向的对象实际类型是不是Y类型的“子类型”。

例如：

main:
    Object o = new Person();
    System.out.println(o instanceof Student); // false
    System.out.println(o instanceof Person); // true
    System.out.println(o instanceof Object); // true
    System.out.println(o instanceof Teacher); // false
    System.out.println(o instanceof String); // false

类型转换

public class Person {
    public void run() {}
}
public class Student extends Person {
    public void go() {}
}
public class Teacher extends Person {
    
}

为什么要类型转换

// 编译报错，因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();

// 需要把变量p的类型进行转换
Person p = new Stduent();
Student s = (Student)p;
s.go();
或者
// 注意这种形式前面必须要两个小括号
((Student)p).go();

类型转换中的问题

// 编译通过 运行没问题
Object o = new Stduent();
Person p = (Person)o;

// 编译通过 运行没问题
Object o = new Student();
Student s = (Stduent)o;

// 编译通过，运行报错
Object o = new Teacher();
Stduent s = (Student)o;

即：

X x = (X)o;
运行是否报错，主要是变量o所指向对象的实际类型，是不是X类型的子类型，如果不是则运行就会报错。

柑橘味柚芽

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录