Java面向对象与多态详解

Java面向对象

面向对象编程是Java的核心概念之一，强调以对象为中心的开发思想。对象的本质是封装数据与方法，通过封装的方式实现代码的复用与扩展。

Final关键字

final 关键字在Java中具有多种用途，主要用于限制类、方法和变量的修改：

1. 修饰方法

作用：被修饰的方法不能被重写。

特点：final 方法的定义在继承时不允许覆盖。

2. 修饰变量

作用：被修饰的变量（基本类型）不可被重新赋值。

特点：final 变量的值在初始化后保持不变。

3. 修饰类

作用：被修饰的类不能被继承。

特点：final 类不允许子类继承该类。

代码示例

public class Demo01 {
    public static void main(String[] args) {
        ClassA a = new ClassA();
        a.num = 20; // 修改成员变量
        a.num = 30; // 成功修改，因为num不是final变量
        System.out.println(a.num); // 输出30
    }
}
class ClassA {
    int num; // 初始化为0，但无效
    public void fun() {
        System.out.println("ClassA的fun方法");
    }
    public void fun1() {
        System.out.println("打开手机 银行 取钱");
    }
}
class ClassB extends ClassA {
    @Override
    public void fun1() {
        super.fun1();
    }
}

Final修饰成员变量

被修饰的成员变量必须初始化。

初始化时可以是常量、字面常量或计算表达式。

常量命名规范：全大写，多个单词用下划线分隔。

代码示例

public class Demo02 {
}
class ClassC {
    public static final int MAX_VALUE = 10;
    public void fun(final int i) {
        System.out.println(MAX_VALUE);
    }
}

多态

多态是面向对象编程中的核心概念，指同一事物表现出不同形式或特征。

前提

类与类之间产生继承关系。

方法有重写（否则多态意义不大）。

父类引用指向子类对象。

代码示例

public class Demo03 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal animal = new Cat();
        animal.speak(); // 调用Cat的speak方法
        Animal animal2 = new Dog();
        animal2.speak(); // 调用Dog的speak方法
    }
}
class Animal {
    private String name;
    private int kind;
    public Animal() {}
    public Animal(String name, String kind) {
        this.name = name;
        this.kind = kind;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getKind() {
        return kind;
    }
    public void setKind(String kind) {
        this.kind = kind;
    }
    public void speak() {
        System.out.println("动物会发出叫声");
    }
    public String toString() {
        return "姓名" + name + "种类:" + kind;
    }
}
class Cat extends Animal {
    public Cat(String name, String kind) {
        this.name = name;
        this.kind = name;
    }
    public void speak() {
        System.out.println("猫会喵喵叫");
    }
    public String toString() {
        return super.toString();
    }
}
class Dog extends Animal {
    public Dog(String name, String kind) {
        this.name = name;
        this.kind = kind;
    }
    public void speak() {
        System.out.println("狗会汪汪汪地叫");
    }
    public String toString() {
        return super.toString();
    }
}

多态内存分析

多态在内存中表现为：

子类对象包含父类部分和子类部分。

父类引用指向子类对象时，会访问父类的成员变量。

调用方法时，动态决定使用子类重写的方法或父类原方法。

代码示例

public class Demo04 {
    public static void main(String[] args) {
        Father father = new Son();
        System.out.println(father.num); // 输出10
        father.print(); // 输出子类print方法
    }
}
class Father {
    int num = 10;
    System.out.println("我是父类中的print方法");
}
class Son extends Father {
    int num = 20;
    System.out.println("我是子类中的print方法");
}

多态的好处与弊端

优点

代码维护性强：统一的接口，多种实现方式。

代码扩展性强：支持新的功能通过继承和多态实现。

弊端

向上转型时无法直接调用子类方法。

多态声明需要强制类型转换，增加代码复杂度。

代码示例

public class Demo05 {
    public static void main(String[] args) {
        Person person = new PZ();
        person.speak(); // 输出洗脑 掏钱
        PZ pz = (PZ) person;
        pz.hit(); // 调用PZ特有方法
    }
}
class Person {
    public void speak() {
        System.out.println("人类会说话");
    }
}
class PZ extends Person {
    @Override
    public void speak() {
        System.out.println("洗脑  掏钱");
    }
    public void hit() {
        System.out.println("打到死为止, 不能轻易放弃");
    }
}

多态举例

多态举例1

需求：创建一个统一的武器创建接口。

public class Demo06 {
    public void fun(WuQi wuqi) {
        wuqi.play();
    }
    public static void main(String[] args) {
        fun(new Dao()); // 输出挥舞刀 - 砍人
        fun(new Gun()); // 输出挥棍 -- 敲人
        WuQi wq = new Dao();
        if (wq instanceof Dao) {
            Dao dao = (Dao) wq;
            dao.practise(); // 输出练刀
        }
    }
}
class WuQi {
    public void play() {
        System.out.println("挥舞武器");
    }
}
class Dao extends WuQi {
    public void play() {
        System.out.println("挥舞刀 - 砍人");
    }
    public void practise() {
        System.out.println("练刀");
    }
}
class Gun extends WuQi {
    public void play() {
        System.out.println("挥棍 -- 敲人");
    }
    public void parct() {
        System.out.println("刷棍");
    }
}

多态举例2

需求：创建统一的僵尸打法接口。

public class Demo07 {
    public void practise(Zombie z) {
        z.play();
    }
    public static void main(String[] args) {
        practise(new TtZombie(40));
        practise(new mZZombie(60));
    }
}
class Zombie {
    private int blood;
    public int getBlood() {
        return blood;
    }
    public void setBlood(int blood) {
        this.blood = blood;
    }
    public void play() {
        System.out.println("打僵尸,被打一次要掉血,直到被打死");
    }
}
class TtZombie extends Zombie {
    public TtZombie() {}
    public TtZombie(int blood) {
        super(blood);
    }
    public void play() {
        while (true) {
            if (this.getBlood() <= 0) {
                System.out.println("铁通僵尸被打死了");
                break;
            }
            this.setBlood(this.getBlood() - 2);
            System.out.println("铁通僵尸剩余血量为:" + this.getBlood);
        }
    }
}
class MzZombie extends Zombie {
    public MzZombie() {}
    public MzZombie(int blood) {
        this.blood = blood;
    }
    public void play() {
        if (this.getBlood() <= 0) {
            System.out.println("帽子僵尸被打死了");
            return;
        }
        this.setBlood(this.getBlood() - 5);
        System.out.println("帽子僵尸的血量为:" + this.getBlood());
        play();
    }
}

多态举例3

需求：创建统一的主板接口。

public class Demo08 {
    public static void main() {
        MainBoard mainboard = new MainBoard();
        mainboard.run(); // 电脑已启动
        mainboard.insertCard(new MusicCard()); // 音乐已播放  音乐已暂停
        mainboard.insertCard(new NetCard()); // 网络已连接 网络已断开
    }
}
class MainBoard {
    public void run() {
        System.out.println("电脑已经启动");
    }
    public void insertCard(Card card) {
        card.start();
        card.stop();
    }
}
class Card {
    public void start() {
        System.out.println("卡已经插入");
    }
    public void stop() {
        System.out.println("卡已经拔出");
    }
}
class MusicCard extends Card {
    public void start() {
        System.out.println("音乐已播放");
    }
    public void stop() {
        System.out.println("音乐已暂停");
    }
}
class NetCard extends Card {
    public void start() {
        System.out.println("网络已连接");
    }
    public void stop() {
        System.out.println("网络已断开");
    }
}