当前位置：首页 > news >正文

【Java面向对象编程入门：接口、继承与多态】

news 2025/11/7 10:45:47

java接口，继承与多态

Java面向对象编程入门：接口、继承与多态
- 前言
- 第一站：继承（Inheritance）——“我爸的家产，我来继承”
- 第二站：多态（Polymorphism）——“一人千面，我变身给你看”
- 第三站：接口（Interface）——“合同约定，大家都签字”
- 终极组合：继承 + 多态 + 接口 = 超级英雄代码
- 结语：

Java面向对象编程入门：接口、继承与多态

前言

大家好！我是你的编程小伙伴，今天我们来聊聊Java中三个超级实用的概念：继承、多态和接口。这些家伙是面向对象编程（OOP）的核心，让你的代码像乐高积木一样，灵活又可复用。
如果你是Java新手，别担心，我会用最接地气的语言解释，就像在咖啡馆闲聊一样。代码会保持超级简单，只用基本语法，不会搞复杂的东西。咱们一步步来，看完你就能上手写代码了！

第一站：继承（Inheritance）——“我爸的家产，我来继承”

想象一下，你家有辆自行车（父类），你继承了它，但可以加个篮子（子类）。继承就是让一个类（子类）从另一个类（父类）“抄”属性和方法，减少重复代码。
为什么用继承？

代码复用：不用从零写，节省时间。
扩展性：子类可以加新功能，但保持父类的核心。

简单代码示例
咱们来定义一个Animal（动物）父类，然后让Dog（狗）和Cat（猫）继承它。
java// 父类：Animal
下面展示一些 内联代码片。

class Animal {String name;  // 属性：名字public Animal(String name) {this.name = name;}// 方法：吃东西（所有动物都会）public void eat() {System.out.println(name + " 在吃东西！");}
}// 子类：Dog，继承Animal
class Dog extends Animal {public Dog(String name) {super(name);  // 调用父类的构造函数}// 新方法：狗特有的叫声public void bark() {System.out.println(name + " 在汪汪叫！");}
}// 子类：Cat，继承Animal
class Cat extends Animal {public Cat(String name) {super(name);}// 新方法：猫特有的叫声public void meow() {System.out.println(name + " 在喵喵叫！");}
}// 测试类
public class InheritanceDemo {public static void main(String[] args) {Dog dog = new Dog("小黑");Cat cat = new Cat("小花");dog.eat();  // 输出：小黑 在吃东西！dog.bark(); // 输出：小黑 在汪汪叫！cat.eat();  // 输出：小花 在吃东西！cat.meow(); // 输出：小花 在喵喵叫！}
}

运行结果：
text小黑在吃东西！
小黑在汪汪叫！
小花在吃东西！
小花在喵喵叫！
看到没？Dog和Cat都继承了eat()方法，还加了自己的“绝活”。这就是继承的魅力！

第二站：多态（Polymorphism）——“一人千面，我变身给你看”

多态的意思是“多种形态”。简单说，就是同一个方法，在不同对象上调用，能表现出不同行为。继承是多态的基础，通常通过方法重写（override）实现。
为什么多态牛？
灵活：不用管对象具体是谁，就能统一调用。
扩展友好：新子类加进来，不用改老代码。
简单代码示例
继续用动物主题。我们让子类重写父类的makeSound()方法（父类有个默认的）。
java// 父类：Animal（加个makeSound方法）

下面展示一些 内联代码片。

class Animal {String name;public Animal(String name) {this.name = name;}public void eat() {System.out.println(name + " 在吃东西！");}// 默认叫声方法（子类可以重写）public void makeSound() {System.out.println(name + " 发出奇怪的声音...");}
}// 子类：Dog，重写makeSound
class Dog extends Animal {public Dog(String name) {super(name);}@Override  // 重写注解，确保没错public void makeSound() {System.out.println(name + " 汪汪！");}
}// 子类：Cat，重写makeSound
class Cat extends Animal {public Cat(String name) {super(name);}@Overridepublic void makeSound() {System.out.println(name + " 喵喵！");}
}// 测试多态
public class PolymorphismDemo {public static void main(String[] args) {// 父类引用指向子类对象（多态的核心！）Animal myPet1 = new Dog("小黑");  // 看起来是Animal，其实是DogAnimal myPet2 = new Cat("小花");  // 看起来是Animal，其实是CatmyPet1.makeSound();  // 输出：小黑 汪汪！（Dog的行为）myPet2.makeSound();  // 输出：小花 喵喵！（Cat的行为）// 还能调用eat()myPet1.eat();  // 输出：小黑 在吃东西！}
}

运行结果：
text小黑汪汪！
小花喵喵！
小黑在吃东西！
哇！Animal类型的变量调用makeSound()，却根据实际对象（Dog或Cat）变身不同叫声。这就是多态的魔法——统一接口，不同实现。

第三站：接口（Interface）——“合同约定，大家都签字”

接口就像一份“合同”：定义了方法，但不实现。它强制实现类必须提供具体功能。接口支持多实现（一个类可以实现多个接口），比继承更灵活。
为什么用接口？
抽象：只管“做什么”，不管“怎么做”。
多态升级：接口引用也能玩多态。
解耦：让代码更松散，不依赖具体类。
简单代码示例
咱们定义一个Flyable接口（会飞的合同），让Bird（鸟）实现它。鸟还能继承Animal。

java// 接口：Flyable（会飞的约定）
interface Flyable {// 默认方法（Java 8+支持）default void takeOff() {System.out.println("起飞准备！");}// 抽象方法，必须实现void fly();
}// 父类：Animal（保持不变）
class Animal {String name;public Animal(String name) {this.name = name;}public void eat() {System.out.println(name + " 在吃东西！");}
}// 子类：Bird，继承Animal + 实现Flyable
class Bird extends Animal implements Flyable {public Bird(String name) {super(name);}// 实现接口的抽象方法@Overridepublic void fly() {System.out.println(name + " 在天空翱翔！");}
}// 测试接口多态
public class InterfaceDemo {public static void main(String[] args) {Bird bird = new Bird("小燕子");// 继承的部分bird.eat();  // 输出：小燕子 在吃东西！// 接口的部分bird.takeOff();  // 输出：起飞准备！（默认方法）bird.fly();      // 输出：小燕子 在天空翱翔！// 接口引用多态Flyable flyer = bird;  // 用接口引用flyer.fly();           // 还是小燕子的行为}
}