【Java】基础入门（十）--- 面向对象的基本概念

一、抽象数据类型

1.面向对象基本概念

1. 1面向对象

面向对象程序设计（OOP）是一种基于对象概念的软件开发方法，是目前软件开发的主流方式。

常见面向对象的语言：C++ 、Python 、Java
常见面向过程的语言：C

面向对象的三大特征：封装、继承、多态。

封装（Encapsulation）：封装是面向对象编程的核心概念之一。它指的是将数据和操作封装在类中，并限制对数据的直接访问。通过封装，可以隐藏实现细节，提高代码的安全性和可维护性。

继承（Inheritance）：继承是面向对象编程中实现代码重用的机制之一。通过继承，一个类可以继承另一个类的属性和方法，并且可以添加新的属性和方法。这样可以实现代码的层次化组织，提高代码的可复用性。

多态（Polymorphism）：多态是面向对象编程中的一个特性，它允许使用统一的接口处理不同的对象类型。多态可以通过继承和接口实现，通过动态绑定在运行时确定要调用的方法。这种灵活性有助于编写可扩展的代码。

1.2 对象

在面向对象的世界中认为万事万物皆对象。对象就是具体的某一事物。

1.3 类

类是具有相同的状态和相同的行为的一组对象的集合。

---

类是多个对象进行综合抽象的结果，是实体对象的概念模型，而一个对象是一个类的实例。

---

2. 定义类

2.1定义类

类的定义由关键字 class 开始，后面跟着类名。以下是一个简单的类的定义示例：

public class Car {
    // 类的成员变量
    String model;
    int year;

    // 类的方法
    public void start() {
        // 方法体
        System.out.println("Car started");
    }
}

2.2 类的成员

类的成员包括成员变量和方法。成员变量是类的属性，用于存储对象的状态。方法是类的行为，用于定义对象的操作。

在上面的示例中，model 和 year 是类的成员变量，而 start() 是类的方法。

2.3 静态初始化

静态初始化是指在类加载时对静态成员变量进行初始化，在整个程序生命周期内只执行一次。可以使用静态代码块来实现静态初始化。

以下是一个静态初始化的示例：

public class MyClass {
    static int myStaticVariable;

    static {
        myStaticVariable = 10;
        System.out.println("Static initialization block executed");
    }
}

2.4 实例初始化

实例初始化是指在每次创建对象时对实例成员变量进行初始化。可以使用构造函数或实例初始化块来实现实例初始化。

以下是一个实例初始化的示例：

public class MyClass {
    int myInstanceVariable;

    {
        myInstanceVariable = 20;
        System.out.println("Instance initialization block executed");
    }

    public MyClass() {
        System.out.println("Constructor executed");
    }
}

2.5 构造函数

构造函数是一种特殊类型的方法，用于创建和初始化对象。它具有与类相同的名称，并且没有返回类型。

以下是一个具有构造函数的示例：

public class Person {
    String name;

    public Person(String n) {
        name = n;
        System.out.println("Person object created with name: " + name);
    }
}

3. static 作用

static 关键字表示静态成员，它可以应用于成员变量、方法和代码块。静态成员属于类本身，而不是对象实例。它们在类加载时被初始化，并且可以通过类名直接访问。

以下是静态成员的示例：

public class MyClass {
    static int myStaticVariable = 5;

    static void myStaticMethod() {
        System.out.println("Static method");
    }
}

实例（非静态/实例）

实例或非静态成员属于对象实例，每个对象都拥有自己的一份实例成员变量。只有通过创建对象的实例才能访问实例成员。

以下是实例成员的示例：

public class MyClass {
    int myInstanceVariable = 10;

    void myInstanceMethod() {
        System.out.println("Instance method");
    }
}

4. 构造重载

构造重载是指在同一个类中定义多个具有不同参数列表的构造函数。这样可以根据参数的不同创建不同的对象。

以下是构造重载的示例：

public class DemoPerson {
    public String name;
    public String gender;
    public int age;

    // 第一种构造方法重载：定义无参构造方法
    public DemoPerson() {
        this.name = "小羊呆呆";
        System.out.println(name);
    }

    // 第二种构造方法重载：定义带参构造方法
    public DemoPerson(String name) {
        System.out.println("你好！" + name);
        this.name = name;
    }

    // 第一种work() 方法重载，无参的 work() 方法
    public void work() {
        System.out.println(this.name + "的工作理念是：工作让生活更美好！");
    }

    // 第二种work() 方法重载，带参的 work() 方法
    public void work(String content) {
        System.out.println(this.name + "," + this.gender + "," + this.age + "岁的工作理念是：" + content);
    }


    public static void main(String[] args) {
        DemoPerson p1 = new DemoPerson("犯困桃子");

        DemoPerson p2 = new DemoPerson();
        p2.name = "康盛科技人才";
        p2.gender = "男";
        p2.age = 20;

        p1.work();
        p2.work("冒泡、摸鱼、打游戏。");
    }
}

输出：

你好！犯困桃子
小羊呆呆
犯困桃子的工作理念是：工作让生活更美好！
康盛科技人才,男,20岁的工作理念是：冒泡、摸鱼、打游戏。

5. 实例化的过程

实例化是指创建对象的过程。在实例化过程中，首先会进行静态初始化（只执行一次），然后进行实例初始化，最后执行构造函数。

以下是实例化过程的示例：

public class MyClass {
    static int myStaticVariable = 5;
    int myInstanceVariable;

    static {
        System.out.println("Static initialization block executed");
    }

    {
        System.out.println("Instance initialization block executed");
    }

    public MyClass() {
        System.out.println("Constructor executed");
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();
    }
}

输出：

Static initialization block executed
Instance initialization block executed
Constructor executed

6. 遮蔽（shadowing）

遮蔽是指在子类或局部作用域中使用与父类或外部作用域中同名的变量，从而隐藏了原有的变量。

以下是遮蔽的示例：

public class ParentClass {
    int x = 10;

    public void printX() {
        int x = 20;  // 局部变量 x 遮蔽了成员变量 x
        System.out.println("Local x: " + x);
        System.out.println("Instance x: " + this.x);
    }
}

public class ParentClass {
    int x = 10;
    // 遮蔽（shadowing）
    public void printX(int x) {
        System.out.println("Local x: " + x);
        System.out.println("例子 x: " + this.x);
    }

    public static void main(String[] args) {
        ParentClass p = new ParentClass();
        p.x = 200;
        p.printX(20);
    }
}
/*
Local x: 20
例子 x: 200
*/

public class ChildClass extends ParentClass {
    int x = 30;

    public void printX() {
        int x = 40;  // 局部变量 x 遮蔽了父类的成员变量 x
        System.out.println("Local x: " + x);
        System.out.println("Instance x: " + this.x);
        System.out.println("Parent x: " + super.x);
    }
}

6.1 this 解决遮蔽问题

this 关键字可以用于引用当前对象，通过 this 可以访问当前对象的成员变量。

以下是使用 this 解决遮蔽问题的示例：

public class ParentClass {
    int x = 10;

    public void printX() {
        int x = 20;
        System.out.println("Local x: " + x);
        System.out.println("Instance x: " + this.x);  // 使用 this 引用成员变量 x
    }
}

6.2 className.staticField 解决遮蔽问题

通过使用类名限定的方式，可以访问被遮蔽的成员变量。

以下是使用类名限定解决遮蔽问题的示例：

public class ParentClass {
    static int x = 10;

    public void printX() {
        int x = 20;
        System.out.println("Local x: " + x);
        System.out.println("Static x: " + ParentClass.x);  // 使用类名限定访问静态变量 x
    }
}