Java [ 基础 ] Java面向对象编程 (OOP) ✨

最新推荐文章于 2024-11-01 14:48:20 发布

lenyan~

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量315

点赞数 4

分类专栏：笔记 JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/jgk666666/article/details/140215092

版权

笔记同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

JavaSE

15 篇文章 0 订阅

订阅专栏

✨探索Java基础 Java面向对象编程 (OOP) ✨

✨探索Java基础 Java面向对象编程 (OOP) ✨

引言

Java是一门以面向对象编程（OOP）为基础的编程语言。OOP的核心概念包括类和对象、封装、继承、多态和抽象。

1. 类和对象

在Java中，类是创建对象的蓝图，而对象是类的实例。类定义了对象的属性和行为。

示例：

class Person {
    // 属性
    String name;  // 姓名
    int age;      // 年龄

    // 方法
    void introduce() {
        System.out.println("我的名字是 " + name + "，我今年 " + age + " 岁。");
        // 输出介绍信息
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Person person = new Person();
        person.name = "张三";  // 设置姓名
        person.age = 30;       // 设置年龄
        person.introduce();    // 调用介绍方法
    }
}

2. 封装

封装是将对象的属性和方法私有化，并通过公共的方法（getter和setter）来访问和修改这些属性。这样可以保护数据不被随意修改。

示例：

class Person {
    // 私有属性
    private String name;  // 姓名
    private int age;      // 年龄

    // getter 方法
    public String getName() {
        return name;
    }

    // setter 方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 介绍方法
    void introduce() {
        System.out.println("我的名字是 " + name + "，我今年 " + age + " 岁。");
        // 输出介绍信息
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("李四");  // 设置姓名
        person.setAge(25);       // 设置年龄
        person.introduce();      // 调用介绍方法
    }
}

3. 继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码重用和扩展。

示例：

// 父类
class Animal {
    void eat() {
        System.out.println("动物正在吃东西。");
        // 动物吃食物
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println("狗在叫。");
        // 狗叫
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 调用父类的方法
        dog.bark(); // 调用子类的方法
    }
}

4. 多态

多态允许对象以多种形式出现，主要通过方法重载和方法重写实现。多态使得一个接口可以有不同的实现。

方法重载：同一个类中，方法名相同但参数不同。

方法重写：子类重新定义父类的方法。

示例：

// 方法重载
class MathOperations {
    // 整数相加
    int add(int a, int b) {
        return a + b;
    }

    // 浮点数相加
    double add(double a, double b) {
        return a + b;
    }
}

// 方法重写
class Animal {
    void sound() {
        System.out.println("动物发出声音。");
        // 动物发出声音
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("狗在叫。");
        // 狗叫
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperations math = new MathOperations();
        System.out.println(math.add(5, 3));      // 调用第一个 add 方法
        System.out.println(math.add(5.5, 3.5));  // 调用第二个 add 方法

        Animal animal = new Dog();
        animal.sound(); // 调用 Dog 类的 sound 方法
    }
}

5. 抽象

抽象通过定义抽象类和接口来提供一个框架，而具体的实现由子类完成。抽象类可以包含抽象方法和具体方法，接口只能包含抽象方法（Java 8 之后可以包含默认方法和静态方法）。

示例：

// 抽象类
abstract class Animal {
    abstract void sound(); // 抽象方法

    void eat() {
        System.out.println("动物正在吃东西。");
        // 动物吃食物
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("狗在叫。");
        // 狗叫
    }
}

// 接口
interface AnimalBehavior {
    void move(); // 移动方法
}

class Cat implements AnimalBehavior {
    @Override
    public void move() {
        System.out.println("猫静静地移动。");
        // 猫静静地移动
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.sound(); // 调用 Dog 类的 sound 方法
        dog.eat();   // 调用 Animal 类的 eat 方法

        AnimalBehavior cat = new Cat();
        cat.move(); // 调用 Cat 类的 move 方法
    }
}