本文共 3859 字，大约阅读时间需要 12 分钟。

Java面向对象编程基础

面向对象

面向对象编程（Object Oriented Programming, OOP）是将现实世界中的对象建模为代码中的类，并利用这些类开发程序。每个对象在程序中都有自己的属性和行为，可以通过方法来操作。类是在程序中组织对象的一种高效方式。

类的概念

一个类可以看作是一个模子，它决定对象将拥有什么样的属性（特征）和行为（方法）。具体而言，类包含了对象的状态和行为的定义。类是类的组织单位，通过类可以避免重复代码，使程序更易维护和扩展。

类的特点

类的定义

类的语法格式如下：

class 类名 {
    属性定义；
    方法定义；
}

类名应与文件名一致，类内只能定义属性和方法。类名需要遵循Java命名规范。

属性与方法

属性

属性（Properties）定义了对象的属性，例如颜色、年龄等。属性可以在类中定义，且可以是基本数据类型或引用数据类型。

方法

方法（Methods）描述了对象可以执行的操作。方法的语法格式如下：

public static void 方法名(参数类型 参数名, 参数类型 参数名…){
    // 方法体
}

方法可以指定返回类型，通过return语句返回值。

类实例化

类实例化的目的是创建对象。语法格式如下：

数据类型 变量名 = new 数据类型();

实例：

Cat cat = new Cat();

访问对象属性：

cat.color; // 访问属性
cat.eat(); // 调用方法

类与对象的关系

局部变量与构造器的结构

局部变量

局部变量是方法或语句块内定义的变量，存储在栈内存中。局部变量的作用域有限，只能在定义的大括号内使用。

特点：

示例：

class Demo1 {
    public static void main(String[] args) {
        int x = 0;
        if (x > 10) {
            System.out.println(x);
        }
    }
    public static void add() {
        {
            int x = 0;
        }
        // x 在方法体内无法访问，会报错
    }
    public static void add(int a) {
    }
}

构造器

构造器是一个特殊的方法，用于初始化对象。类的构造器没有返回值，也没有void。方法名必须与类名一致。

默认构造器

如果没有显式定义构造器，类会自动提供一个默认构造器。默认构造器没有参数。

有参数的构造器

可以通过定义参数来初始化对象的属性。如果类有多个构造器，必须显示定义默认构造器。

示例：

public class Person {
    public Person() {
        System.out.println("默认构造器调用");
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class TestPerson {
    public static void main(String[] args) {
        Person p = new Person("张三三", 20);
        p.info();
    }
}

通过this关键字可以调用本类的构造器，必须放在构造器的第一行。

单例模式

单例模式通过私有化构造器和静态方法实现类只有一个对象的创建。例如，懒汉模式在第一次访问时创建对象。

示例：

class Singleton {
    private static Singleton instance;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
public class TestSingleton {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        System.out.println(instance);
    }
}

面向对象的三大特征

封装性实现

封装的实现步骤包括：

实例：

public class Test {
    public static void test(String str) {
        System.out.println(str);
    }
    public static void main(String[] args) {
        Test.test("封装");
    }
}

继承性实现

继承性的实现通过extends关键字实现。例如：

public class Father {}
public class Son extends Father {
}

多态性实现

多态性的实现通常体现在方法的多态性。例如：

class Parents {
    public void print() {
        System.out.println("父类");
    }
}
class Child extends Parents {
    public void print() {
        System.out.println("子类");
    }
}
public class Test {
    public void find(Parents obj) {
        obj.print();
    }
    public static void main(String[] args) {
        Child child = new Child();
        find(child);
        child.print();
    }
}

This关键字

this关键字表示当前对象。在复合属性和方法调用中用到。

public class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}
public class TestPerson {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("张三三");
        p.setAge(20);
        System.out.println(p.getName() + "," + p.getAge());
    }
}

总结

通过了解面向对象编程的基础知识，我们可以更好地理解和使用Java语言。类是对象的组织单位，属性和方法定义了对象的行为，构造器初始化对象的状态，封装性和多态性增加了程序的灵活性。面向对象编程使程序更具可扩展性和维护性，是现代编程的核心思想之一。