位置：首页-资讯-后端开发

Java面向对象编程之继承和多态以及包的解析与使用范例

2024-04-02 19:55

短信预约 -IT技能 免费直播动态提醒

1.继承

为什么要有继承？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那个类即可。

此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”

1.1继承的基本使用

类继承语法规则:

class 子类 extends 父类{ }

继承的作用：

降低代码的冗余度，提高代码复用率
继承的出现,更有利于功能的扩展。
继承的出现让类与类之间产生了关系，提供了多态的前提

注意：

子类不能直接访问父类中私有的(private)的成员变量和方法
Java只支持单继承和多层继承，不允许多重继承
一个子类只能有一个父类一个父类可以派生出多个子类

如下代码示例：


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

1.2 protected 关键字

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

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

四种权限修饰符：

四种权限修饰

1.3 final 关键字

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


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

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


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

final 关键字的功能是限制类被继承。我们平时使用的String字符串类，就是被final修饰的，不能被继承。

2.多态

2.1向上转型

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


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

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


Bird bird = new Bird("圆圆"); 
Animal bird2 = bird; 
// 或者写成下面的方式
Animal bird2 = new Bird("圆圆");

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

向上转型是子类对象转成父类对象

向上转型发生的时机:

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

直接赋值的方式我们已经演示了. 另外两种方式和直接赋值没有本质区别

方法传参

代码示例：


public class Test { 
    public static void main(String[] args) { 
    Bird bird = new Bird("圆圆"); 
    feed(bird); 
    } 
    public static void feed(Animal animal) { 
    animal.eat("谷子"); 
    } 
} 
// 执行结果
圆圆正在吃谷子

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

方法返回

代码示例


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

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

2.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 Test { 
 public static void main(String[] args) { 
 Animal animal1 = new Animal("圆圆"); 
 animal1.eat("谷子"); 
 Animal animal2 = new Bird("扁扁"); 
 animal2.eat("谷子"); 
 } 
}

// 执行结果
我是一只小动物
圆圆正在吃谷子
我是一只小鸟
扁扁正在吃谷子

此时, 我们发现:

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

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

2.3方法重写

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称
为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限，子类不能重写父类中声明为private权限的方法
子类方法抛出的异常不能大于父类被重写方法的异常

注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法

方法重写举例1：


public class Person {
    public String name;
    public int age;
    public String getInfo() {
    return "Name: "+ name + "\n" +"age: "+ age;
    } 
}
public class Student extends Person {
    public String school;
    public String getInfo() { //重写方法
    return "Name: "+ name + "\nage: "+ age 
    + "\nschool: "+ school;
}
public static void main(String args[]){
    Student s1=new Student();
    s1.name="Bob";
    s1.age=20;
    s1.school="school2";
    System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
    } 
}

方法重写举例2：


class Parent {
    public void method1() {}
}
class Child extends Parent {
    //非法，子类中的method1()的访问权限private比被覆盖方法的访问权限public小
    private void method1() {} 
}
public class UseBoth {
    public static void main(String[] args) {
    Parent p1 = new Parent();
    Child c1 = new Child();
    p1.method1();
    c1.method1();
    }
}

2.4向下转型

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

从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现
无继承关系的引用类型间的转换是非法的
在造型前可以使用instanceof操作符测试一个对象的类型

对于 Animal animal = new Bird(“圆圆”) 这样的代码：

编译器检查有哪些方法存在, 看的是 Animal 这个类型

执行时究竟执行父类的方法还是子类的方法, 看的是 Bird 这个类型.

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


// (Bird) 表示强制类型转换
Bird bird = (Bird)animal; 
bird.fly(); 
// 执行结果
圆圆正在飞

为了让向下转型更安全, 我们可以先判定一下看看 animal 本质上是不是一个 Bird 实例, 再来转换


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

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

2.5super 关键字

2.5.1 super 关键字的基本用法

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员 super的追溯不仅限于直接父类
super和this的用法相像，this代表本类对象的引用，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); 
 } 
}

2.5.2 this和super的区别

this 和 super 的区别

3.包的使用

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性.
例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过

3.1导入包中的类

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性
代码示例：


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.*

注意：Java是用到包中的那个类就导入那个类

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
例如：


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 static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些.但不推荐
        // 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);
   }
}