Java开发基础系列(六):类的继承(子类、重写、类型转换)

最新推荐文章于 2023-08-29 19:37:13 发布

一恍过去

最新推荐文章于 2023-08-29 19:37:13 发布

阅读量2.5w

点赞数 1

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/zhuocailing3390/article/details/131752805

版权

Java 专栏收录该内容

95 篇文章 3 订阅

订阅专栏

😊 @ 作者：一恍过去

💖 @ 主页： https://blog.csdn.net/zhuocailing3390

🎊 @ 社区： Java技术栈交流

🎉 @ 主题： Java开发基础系列(六):类的继承(子类、重写、类型转换)

⏱️ @ 创作时间： 2022年03月17日

在这里插入图片描述

前言

在Java中，类继承是一种面向对象编程的基本概念，它允许创建一个新类，该类可以继承（从现有类派生）另一个类的属性和方法。这种继承关系可以帮助实现代码重用、扩展和多态性。

类继承的基本语法如下：

class ChildClass extends ParentClass {
    // 子类的成员变量和方法
}

在上述语法中，ChildClass是子类，ParentClass是父类（也称为超类或基类）。子类通过关键字extends来继承父类。子类可以继承父类的非私有成员变量和方法，包括实例变量、静态变量、实例方法和静态方法。

需要注意的是：

Java中类的继承是单继承的，一个子类只能继承一个父类。但是，一个类可以被多个子类继承。
Java中使用关键字super来引用父类的成员。
父类的私有成员和构造函数无法被子类继承和访问。
子类可以覆盖（重写）父类的方法，通过@Override注解来标识重写的方法。

定义子类

通过继承，子类可以获得父类的特性并添加自己的特性，并且子类还可以定义自己的成员变量和方法。

父类：

class Animal {
	private int age;
	
    void eat() {
        System.out.println("Animal is eating.");
    }
    
    public void setAge(int age){
    	this.age = age
    }
    public int getAge(){
    	return age;
    }
}

子类：

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 继承自父类 Animal
        dog.bark(); // 子类自己的方法
        dog.setAge(5); //继承父类的变量
    }
}

// 执行结果：
Animal is eating.
Dog is barking.

总结：
Animal是父类，Dog是子类。Dog类继承了Animal类的eat()方法，并定义了自己的bark()方法。通过创建Dog类的实例，我们可以调用继承的eat()方法和子类自己的bark()方法。可以在继承体系中实现多态性和动态绑定，提供更加灵活和可扩展的代码结构。

覆盖方法(重写方法)

子类可以重写（覆盖）父类的方法。方法重写允许子类提供自己的实现来替代父类中的方法实现，以满足子类的特定需求。通过方法重写，子类可以改变父类方法的行为。

方法重写的基本规则如下：

子类中的重写方法必须具有与父类方法相同的名称、参数列表和返回类型。
重写方法不能比父类方法具有更低的访问权限。例如，如果父类方法是public，则子类重写方法也必须是public。
子类重写方法的异常类型不能比父类方法的异常类型更广泛。子类重写方法可以抛出父类方法声明的异常或不抛出异常，但不能抛出比父类方法更多的或更宽泛的异常。

@Override注解：

使用@Override注解可以帮助我们验证是否成功重写了父类方法。如果父类中不存在与重写方法相匹配的方法，编译器将产生错误。

super关键字：

在子类的重写方法中，可以使用super关键字来调用父类的方法实现。这对于在子类中增加特定行为但仍需要调用父类方法的情况很有用。

代码示例：

// 父类
class Animal {
    void eat() {
        System.out.println("Animal eating.");
    }
}

// 子类
class Cat extends Animal {
    @Override
    void eat() {
        // 通过super，调用父类方法
		System.out.println("执行 super.");
    	super.eat();
		System.out.println("执行 子类eat.");
        System.out.println("Cat eating.");
    }
}

// 使用实例
public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();

        Cat cat = new Cat();
        cat.eat(); 
    }
}

执行结果：

	// 两次调用`eat()`方法，结果分别为
	Animal eating.

	执行 super.
	Animal eating.
	执行 子类eat.
	Dog is barking.

父子间类型转换

父类和子类之间可以进行类型转换。这种类型转换包括向上转型和向下转型

向上转型：
是将子类对象赋值给父类类型的变量。这种转型是隐式的，不需要显式的类型转换操作符。向上转型可以安全地进行，因为子类对象具有父类对象的所有特性。

示例代码：

	class Animal {
	    void eat() {
	        System.out.println("Animal is eating.");
	    }
	}
	
	class Cat extends Animal {
	 	
	}
	
	public class Main {
	    public static void main(String[] args) {
	        Animal animal = new Cat(); // 向上转型
	        animal.eat();         // 父类方法
	    }
	}

Cat类是Animal类的子类。创建了一个Cat对象，并将其赋值给类型为Animal的变量nimal，这是一种向上转型操作。

向下转型：
是将父类类型的变量转换为子类类型。这种转型需要显式的类型转换操作符，并且在运行时可能会抛出ClassCastException异常，向下转型要求实际的对象类型与目标类型兼容，否则会导致运行时错误。

示例代码：
```
class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println("Cat is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        Cat cat = (Cat) animal;  // 向下转型
        cat.eat();              // 父类方法
        cat.meow();             // 子类方法
    }
}
```
先将一个Cat对象赋值给类型为Animal的变量animal，然后通过显式的向下转型操作将animal转换为Cat类型的变量cat。由于animal引用实际上指向的是一个Cat对象，因此可以安全地进行向下转型。通过cat变量，我们可以访问Animal类和Cat类中定义的方法。

需要注意的是，在进行向下转型之前，应该使用instanceof运算符进行类型检查，以避免ClassCastException异常的发生。例如：
```
if (animal instanceof Cat) {
    Cat cat = (Cat) animal;  // 向下转型
    cat.meow();
}
```