深入理解Java中的类与对象:封装、继承与多态

简介: 深入理解Java中的类与对象:封装、继承与多态

深入理解Java中的类与对象:封装、继承与多态


在Java编程中,类与对象是核心概念。类是对象的模板,定义了对象的属性和行为;对象是类的实例,通过类创建的具体实体。本文将深入探讨Java中的类与对象,重点介绍面向对象编程的三大特性:封装、继承与多态。


一、封装

封装(Encapsulation)是将对象的状态(属性)和行为(方法)封装在一起,隐藏对象的内部实现细节,只暴露必要的接口给外界。通过封装,可以提高代码的安全性和可维护性。

代码示例:封装
package cn.juwatech.encapsulation;
public class Person {
    private String name;
    private int age;
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // Getter 和 Setter 方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("年龄必须大于0");
        }
    }
    // 显示信息的方法
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

在上面的示例中,Person类通过私有属性(nameage)和公有方法(gettersetter)实现了封装。

二、继承

继承(Inheritance)是面向对象编程的一种机制,允许我们创建一个新类,这个新类可以继承一个已经存在的类的属性和方法。继承使代码重用成为可能,并提供了一个自然的层次结构。

代码示例:继承
package cn.juwatech.inheritance;
// 父类
public class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat() {
        System.out.println(name + " 正在吃东西。");
    }
    public String getName() {
        return name;
    }
}
// 子类
package cn.juwatech.inheritance;
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    public void bark() {
        System.out.println(getName() + " 正在汪汪叫。");
    }
}

在上面的示例中,Dog类继承了Animal类,Dog类不仅可以访问Animal类的方法,还可以添加自己特有的方法(bark)。

三、多态

多态(Polymorphism)是指同一个行为在不同对象中的不同表现形式。多态可以通过方法重载(编译时多态)和方法重写(运行时多态)来实现。

代码示例:多态
package cn.juwatech.polymorphism;
// 父类
public class Shape {
    public void draw() {
        System.out.println("绘制形状");
    }
}
// 子类
package cn.juwatech.polymorphism;
public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
package cn.juwatech.polymorphism;
public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
// 测试多态
package cn.juwatech.polymorphism;
public class TestPolymorphism {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.draw(); // 输出:绘制圆形
        shape2.draw(); // 输出:绘制矩形
    }
}

在上面的示例中,Shape类的draw方法被子类CircleRectangle重写,通过多态机制,可以使用父类引用调用子类的方法。

四、封装、继承与多态的综合应用

在实际开发中,封装、继承和多态通常是结合使用的。以下是一个综合应用的示例,展示了如何在一个简单的银行账户系统中应用这些概念。

代码示例:综合应用
package cn.juwatech.bank;
// 父类:银行账户
public class BankAccount {
    private String accountNumber;
    private double balance;
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("取款金额无效");
        }
    }
    public double getBalance() {
        return balance;
    }
    public String getAccountNumber() {
        return accountNumber;
    }
}
// 子类:储蓄账户
package cn.juwatech.bank;
public class SavingsAccount extends BankAccount {
    private double interestRate;
    public SavingsAccount(String accountNumber, double balance, double interestRate) {
        super(accountNumber, balance);
        this.interestRate = interestRate;
    }
    public void addInterest() {
        double interest = getBalance() * interestRate / 100;
        deposit(interest);
    }
}
// 测试类
package cn.juwatech.bank;
public class TestBank {
    public static void main(String[] args) {
        SavingsAccount sa = new SavingsAccount("123456", 1000.0, 5.0);
        sa.deposit(500);
        sa.withdraw(200);
        sa.addInterest();
        System.out.println("余额: " + sa.getBalance()); // 输出:余额: 1365.0
    }
}

在这个银行账户系统中,我们使用了封装(BankAccount类的私有属性和公有方法)、继承(SavingsAccount继承BankAccount)和多态(通过父类引用调用子类方法)。

结论

通过本文的介绍,我们详细探讨了Java中的类与对象,重点介绍了面向对象编程的三大特性:封装、继承与多态。这些特性是Java编程的基础,可以帮助我们编写更加模块化、易于维护和扩展的代码。在实际开发中,灵活运用这些特性,可以提高代码质量和开发效率。

目录
打赏
0
0
0
0
120
分享
相关文章
JAVA泛型类的使用(二)
接上一篇继续介绍Java泛型的高级特性。3. **编译时类型检查**:尽管运行时发生类型擦除,编译器会在编译阶段进行严格类型检查,并允许通过`extends`关键字对类型参数进行约束,确保类型安全。4. **桥方法**:为保证多态性,编译器会生成桥方法以处理类型擦除带来的问题。5. **运行时获取泛型信息**:虽然泛型信息在运行时被擦除,但可通过反射机制部分恢复这些信息,例如使用`ParameterizedType`来获取泛型参数的实际类型。
JAVA泛型类的使用(一)
Java 泛型类是 JDK 5.0 引入的重要特性,提供编译时类型安全检测,增强代码可读性和可维护性。通过定义泛型类如 `Box&lt;T&gt;`,允许使用类型参数。其核心原理是类型擦除,即编译时将泛型类型替换为边界类型(通常是 Object),确保与旧版本兼容并优化性能。例如,`Box&lt;T&gt;` 编译后变为 `Box&lt;Object&gt;`,从而实现无缝交互和减少内存开销。
Java基础-常用API-Object类
继承是面向对象编程的重要特性,允许从已有类派生新类。Java采用单继承机制,默认所有类继承自Object类。Object类提供了多个常用方法,如`clone()`用于复制对象,`equals()`判断对象是否相等,`hashCode()`计算哈希码,`toString()`返回对象的字符串表示,`wait()`、`notify()`和`notifyAll()`用于线程同步,`finalize()`在对象被垃圾回收时调用。掌握这些方法有助于更好地理解和使用Java中的对象行为。
【Java探索之旅】多态:重写、动静态绑定
【Java探索之旅】多态:重写、动静态绑定
49 0
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(3)
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(3)
223 0
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(3)
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(2)
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(2)
166 0
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(2)
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(1)
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(1)
115 0
java面向对象编程_包_继承_多态_重载和重写_抽象类_接口_this和super(1)
Java社招面试题:一个线程运行时发生异常会怎样?
大家好,我是小米。今天分享一个经典的 Java 面试题:线程运行时发生异常,程序会怎样处理?此问题考察 Java 线程和异常处理机制的理解。线程发生异常,默认会导致线程终止,但可以通过 try-catch 捕获并处理,避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理,不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制,为面试做好准备。如果你觉得有帮助,欢迎收藏、转发!
60 14

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等