【JAVA】面向对象之——继承和多态

最新推荐文章于 2023-05-07 16:41:28 发布

同学潘

最新推荐文章于 2023-05-07 16:41:28 发布

阅读量427

点赞数 1

分类专栏： JAVA 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/m0_46468731/article/details/121459823

版权

JAVA 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1、包

包是组织类的一种方式；使用包的主要目的是保证类的唯一性。

例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过。

1.1 导入包中的类

Java 中已经提供了很多现成的类供我们使用，例如可以使用 java.util.Date 这种方式引入 java.util 这个包中的 Date 类。

public class Test {
    public static void main(String[] args) {
        java.util.Date date=new java.util.Date();
        System.out.println(date.getTime());//得到一个毫秒级别的时间戳
    }
}

但是这种写法比较麻烦一些, 可以使用 import 语句导入包。

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date=new Date();
        System.out.println(date.getTime());//得到一个毫秒级别的时间戳
    }
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
" * "号是通配符，说明你可以使用包中的任何一个类，但一般不建议这样使用。

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date=new Date();
        System.out.println(date.getTime());//得到一个毫秒级别的时间戳
    }
}

但是更建议显式的指定要导入的类名，否则还是容易出现冲突的情况。

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        //由于util和sql中都存在一个Date这样的类，此时就会出现歧义，编译出现错误
        Date date=new Date();
        System.out.println(date.getTime());//得到一个毫秒级别的时间戳
    }
}

在这里插入图片描述
在这种情况下需要使用完整的类名：

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        java.util.Date date=new java.util.Date();
        System.out.println(date.getTime());//得到一个毫秒级别的时间戳
    }
}

注意事项：

import 和 C++ 的 #include 差别很大，C++ 必须 #include 来引入其他文件内容，但是 Java 不需要。
import 只是为了写代码的时候更方便， import 更类似于 C++ 的 namespace 和 using。

1.2 静态导入

使用 import static 可以导入包中的静态的方法和字段。

import static java.lang.System.*;
public class Test {
    public static void main(String[] args) {
        out.println("hello");
    }
 }

使用这种方式可以更方便的写一些代码, 例如:

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x=10;
        double y=20;
        //静态导入的方式写起来更方便一些
        //double result=Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
        double result=sqrt(pow(x,2)+pow(y,2));
        System.out.println(result);
    }
 }

1.3 将类放到包中

基本规则：

在文件的最上方加上一个 package 语句指定该代码在哪个包中。
包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1）。
包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码。
如果一个类没有 package 语句, 则该类被放到一个默认包中。

操作步骤如下：
1、在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
在这里插入图片描述
2、在弹出的对话框中输入包名，例如cn，然后按回车
3、在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可

4、此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

5、同时我们也看到了, 在新创建的 Demo.java 文件的最上方, 就出现了一个 package 语句
在这里插入图片描述

1.4 包的访问权限控制

我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用。
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用。

下面的代码给了一个示例， Demo 和 Demo1 是同一个包中, Test 是其他包中。
Demo.java

package cn;
public class Demo {
     int value=10;
}

Demo1.java

package cn;
public class Demo1 {
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.value);
    }
}

执行结果如下：（说明能够访问到 value 变量）
在这里插入图片描述
Test.java

package cn.demo;
import cn.Demo;
public class Test {
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.value);
    }
}

执行结果如下：（编译出现了问题）
在这里插入图片描述

1.5 常见的系统包

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reflect:java 反射编程包；
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

2、继承

2.1 背景

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法)。
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联。

例如, 设计一个类表示动物

注意：我们可以给每个类创建一个单独的 java 文件. 类名必须和 .java 文件名匹配(大小写敏感）

// Animal.java 
public class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name+"正在吃"+food);
    }
}
// Cat.java
public class Cat {
    public String name;

    public Cat(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name+"正在吃"+food);
    }
}
// Bird.java 
public class Bird {
    public String name;

    public Bird(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name+"正在吃"+food);
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}

这个代码我们发现其中存在了大量的冗余代码！
仔细分析后，我们就可以发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系：

这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的。
这三个类都具备一个相同的 name 属性, 而且意义是完全一样的。
从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义)。

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果。

此时, Animal 这样被继承的类, 我们称为父类 , 基类或超类, 对于像 Cat 和 Bird 这样的类, 我们称为子类,派生类和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果。

2.2 语法规则

基本语法：

class 子类 extends 父类 { 
 
}

使用 extends 指定父类。
Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承)。
子类会继承父类的所有 public 的字段和方法。
对于父类的 private 的字段和方法, 子类中是无法访问的。
子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用。

对于上面的代码, 可以使用继承进行改进. 此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法。

public class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name+"正在吃"+food);
    }
}
public class Cat extends Animal{
    public Cat(String name) {
        //使用super调用父类的构造方法
        super(name);
    }
}
public class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Cat cat=new Cat("小红");
        cat.eat("猫粮");
        Bird bird=new Bird("胖胖");
        bird.fly();
    }
}

执行结果如下：
在这里插入图片描述

extends 英文原意指 “扩展”. 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 “扩展”。
例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 fly 方法。

如果我们把 name 改成 private, 那么此时子类就不能访问了
在这里插入图片描述

2.3 protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.
两全其美的办法就是 protected 关键字

对于类的调用者来说, protected 修饰的字段和方法是不能访问的
对于类的子类和同一个包的其他类来说, protected 修饰的字段和方法是可以访问的

// Animal.java
public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name+"正在吃"+food);
    }
}
// Bird.java 
public class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
    // 对于父类的 protected 字段, 子类可以正确访问
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}

// Test.java 和 Animal.java 不在同一个 包 之中了. 
public class Test {
    public static void main(String[] args) {
        Animal animal=new Animal("小动物");
        System.out.println(animal.name);
    }
}

结果如下：（此时编译出错, 无法访问 name）
在这里插入图片描述
小结： Java 中对于字段和方法共有四种访问权限

private：类内部能访问, 类外部不能访问。
默认(也叫包访问权限)：类内部能访问, 同一个包中的类可以访问, 其他类不能访问。
protected：类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问。
public：类内部和类的调用者都能访问。

什么时候下用哪一种呢?

我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出必要的信息给类的调用者。
因此我们在使用的时候应该尽可能的使用比较严格的访问权限。
例如如果一个方法能用 private, 就尽量不要用public。 另外, 还有一种简单粗暴的做法: 将所有的字段设为private, 将所有的方法设为public. 不过这种方式属于是对访问权限的滥用, 还是更希望我们大家在写代码的时候可以认真思考一下, 该类提供的字段方法到底给 “谁” 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用)

2.4 更复杂的继承关系

刚才我们的例子中, 只涉及到 Animal, Cat 和 Bird 三种类. 但是如果情况更复杂一些呢?
针对 Cat 这种情况, 我们可能还需要表示更多种类的猫~
在这里插入图片描述
这个时候使用继承方式来表示, 就会涉及到更复杂的体系

// Animal.java 
public Animal { 
 ... 
} 
// Cat.java 
public Cat extends Animal { 
 ... 
} 
// ChineseGardenCat.java 
public ChineseGardenCat extends Cat { 
 ... 
} 
// OrangeCat.java 
public Orange extends ChineseGardenCat { 
 ... 
} 
......

如刚才这样的继承方式称为多层继承, 即子类还可以进一步的再派生出新的子类。

时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂。
但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了。
如果想从语法上进行限制继承, 就可以使用 final 关键字

2.5 final 关键字

曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示常量 (不能修改)。

final int a = 10; 
a = 20; // 编译出错

final 关键字也能修饰类, 此时表示被修饰的类就不能被继承。

final public class Animal { 
 ... 
} 
public class Bird extends Animal { 
 ... 
} 
// 编译出错
//Error:(3, 27) java: 无法从最终cnm.Animal进行继承

final 关键字的功能是 限制类被继承

“限制” 这件事情意味着 “不灵活”. 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.
是用 final修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的.

3、组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果.

例如表示一个学校：

public class Student { 
 ... 
} 
public class Teacher { 
 ... 
} 
public class School { 
 public Student[] students; 
 public Teacher[] teachers; 
}

组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。
这是我们设计类的一种常用方式之一。

组合表示 has - a 语义在刚才的例子中, 我们可以理解成一个学校中 “包含” 若干学生和教师。
继承表示 is - a 语义在上面的 “动物和猫” 的例子中, 我们可以理解成一只猫也 “是” 一种动物。
要注意体会两种语义的区别！！！

4、多态

4.1 向上转型

在刚才的例子中, 我们写了形如下面的代码

Bird bird = new Bird("胖胖");

这个代码也可以写成这个样子

Bird bird = new Bird("胖胖"); 
Animal bird2 = bird;

或者写成下面的方式

Animal bird2 = new Bird("胖胖");

此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为向上转型。

向上转型这样的写法可以结合 is - a 语义来理解. 例如：我让我媳妇去喂圆圆, 我就可以说, “媳妇你喂小鸟了没?”, 或者 “媳妇你喂鹦鹉了没?”
因为圆圆确实是一只鹦鹉, 也确实是一只小鸟~~

为啥叫 “向上转型”?

在面向对象程序设计中, 针对一些复杂的场景(很多类, 很复杂的继承关系), 程序猿会画一种 UML 图的方式来表示类之间的关系. 此时父类通常画在子类的上方. 所以我们就称为 “向上转型” , 表示往父类的方向转.
注意: 关于 UML 图的规则我们在这里就不详细讨论了,有兴趣的友友们可以自己去查找一下。

向上转型发生的时机：

直接赋值
方法传参
方法返回

直接赋值的方式上面我们已经演示了. 而另外两种方式和直接赋值没有本质区别。
方法传参：

public class Test1 {
    public static void main(String[] args) {
        Bird bird=new Bird("胖胖");
        fead(bird);
    }
    public static void fead(Animal animal){
        animal.eat("谷子");
    }
}

执行结果如下：
在这里插入图片描述

此时形参 animal 的类型是 Animal (基类), 实际上对应到 Bird (父类) 的实例。

方法返回：

public class Test1 { 
 public static void main(String[] args) { 
 Animal animal = findMyAnimal(); 
 } 
 public static Animal findMyAnimal() { 
 Bird bird = new Bird("胖胖"); 
 return bird; 
 } 
}

此时方法 findMyAnimal 返回的是一个 Animal 类型的引用, 但是实际上对应到 Bird 的实例。

4.2 动态绑定

当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢?

对前面的代码稍加修改, 给 Bird 类也加上同名的 eat 方法, 并且在两个 eat 中分别加上不同的日志.

// Animal.java 
public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println("我是一只小动物");
        System.out.println(this.name+"正在吃"+food);
    }
}
// Bird.java 
public class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
    public void eat(String food){
        System.out.println("我是一只小鸟");
        System.out.println(this.name+"正在吃"+food);
    }
}
// Test.java 
public class Test1 {
    public static void main(String[] args) {
        Animal animal=new Animal("胖胖");
        animal.eat("谷子");
        Animal animal1=new Bird("圆圆");
        animal1.eat("谷子");
    }
}

执行结果如下：
在这里插入图片描述
此时, 我们可以发现:

animal 和 animal1 虽然都是 Animal 类型的引用, 但是 animal 指向 Animal 类型的实例， animal1 指向Bird 类型的实例。
针对 animal和 animal1 分别调用 eat 方法, 发现 animal.eat() 实际调用了父类的方法, 而animal1.eat() 实际调用了子类的方法。

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定。

4.3 方法重写

针对刚才的 eat 方法来说:

子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为覆写/重写/覆盖(Override)。

关于重写的注意事项：

重写和重载完全不一样，不要混淆！！！
普通方法可以重写, static 修饰的静态方法不能重写。
重写中子类的方法的访问权限不能低于父类的方法访问权限。
重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外)。

方法权限示例: （将子类的 eat 改成 private）

// Animal.java 
public class Animal { 
 public void eat(String food) { 
 ... 
 } 
} 
// Bird.java 
public class Bird extends Animal { 
 // 将子类的 eat 改成 private 
 private void eat(String food) { 
 ... 
 } 
} 
// 编译出错
//Error:(8, 10) java: com.bit.Bird中的eat(java.lang.String)无法覆盖cmn.Animal中的eat(java.lang.String) 
 //正在尝试分配更低的访问权限; 以前为public

另外, 针对重写的方法, 可以使用 @Override 注解来显式指定：

// Bird.java 
public class Bird extends Animal { 
 @Override 
 private void eat(String food) { 
 ... 
 } 
}

有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet方法, 就会编译报错, 提示无法构成重写.
个人推荐在代码中进行重写方法时显式加上 @Override 注解

小结: 重载和重写的区别
在这里插入图片描述

4.4 向下转型

向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象。相比于向上转型来说, 向下转型没那么常见,但是也有一定的用途。

//Animal.java
public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food){
        System.out.println("我是一只小动物");
        System.out.println(this.name+"正在吃"+food);
    }
}
//Bird.java
public class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
    public void eat(String food){
        System.out.println("我是一只小鸟");
        System.out.println(this.name+"正在吃"+food);
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}

接下来是我们所熟悉的操作：

Animal animal=new Bird("胖胖");
        animal.eat("谷子");

结果如下：
在这里插入图片描述
接下来让我们尝试让胖胖飞起来：

animal.fly();

但是胖胖好像飞不起来：（编译出错）
在这里插入图片描述
注意事项：
编译过程中, animal 的类型是 Animal, 此时编译器只知道这个类中有一个 eat 方法, 没有 fly 方法.虽然 animal 实际引用的是一个 Bird 对象, 但是编译器是以 animal 的类型来查看有哪些方法的。
对于 Animal animal = new Bird(“圆圆”) 这样的代码：

编译器检查有哪些方法存在, 看的是 Animal 这个类型
执行时究竟执行父类的方法还是子类的方法, 看的是 Bird 这个类型

那么想实现刚才的效果, 就需要向下转型：

Bird bird=(Bird)animal;
        bird.fly();

胖胖飞起来啦：
在这里插入图片描述
但是这样的向下转型有时是不太可靠的，例如：

 Animal animal=new Cat("小红");
 Bird bird=(Bird)animal;
        bird.fly();

执行结果如下：（抛出异常）
在这里插入图片描述
animal 本质上引用的是一个 Cat 对象, 是不能转成 Bird 对象的. 运行时就会抛出异常。
所以, 为了让向下转型更安全, 我们可以先判定一下看看 animal 本质上是不是一个 Bird 实例, 再来转换

Animal animal = new Cat("小猫"); 
if (animal instanceof Bird) { 
 Bird bird = (Bird)animal; 
 bird.fly(); 
}

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。

4.5 super 关键字

前面的代码中由于使用了重写机制, 调用到的是子类的方法. 如果需要在子类内部调用父类方法怎么办? 可以使用super 关键字。
super 表示获取到父类实例的引用。 涉及到两种常见用法：
1、使用了 super 来调用父类的构造方法(这个代码在前面已经写过了)

public Bird(String name) { 
 super(name); 
}

2、使用 super 来调用父类的普通方法

public class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
    @Override
    //修改代码，让子类修改父类的接口
    public void eat(String food){
        super.eat(food);
        System.out.println("我是一只小鸟");
        System.out.println(this.name+"正在吃"+food);
    }
}