java基础教程第4篇（类和对象）-CSDN博客

本文链接：https://blog.csdn.net/bianenhui91/article/details/144207342

什么是类和对象

类（Class）是一种抽象的概念，它用于描述对象的属性和行为。类是定义对象的模板，它包含了对象所具有的属性（成员变量）和行为（方法）。类是Java中的基本组织单位，所有的Java程序都由类组成。
对象（Object）则是类的实例化结果，是真正具体存在的实体。对象具有类所定义的属性和行为。通过创建对象，可以使用和操作类中定义的属性和方法。

如何定义JAVA中的类

在Java中，类是一种数据结构，用于定义对象的属性和行为。一个类可以看作是对象的模板或蓝图，它定义了一个对象的属性和方法。
在Java中，使用关键字"class"来定义一个类，然后在类中定义属性和方法。类一般包含以下几个部分：

访问修饰符：可以是"public"，“protected”，"private"等，用于控制类的访问权限。
类名：类的名称，首字母通常大写。
父类：可以通过关键字"extends"指定一个类作为父类，继承父类的属性和方法。
实现的接口：可以通过关键字"implements"实现一个或多个接口。
类体：包含了类的属性和方法。

以下是一个简单的类的定义示例：

public class MyClass {
    // 类的属性
    private String name;
    private int age;

    // 类的构造方法
    public MyClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 类的方法
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

在上面的例子中，我们定义了一个名为"MyClass"的类。该类有两个私有属性"name"和"age"，一个构造方法用于初始化这两个属性，还有一个方法"displayInfo"用于显示属性的值。

通过定义类，我们可以创建对象并访问其属性和方法。例如：

public class Main {
    public static void main(String[] args) {
        // 创建一个MyClass对象
        MyClass myObj = new MyClass("John", 25);

        // 调用对象的方法
        myObj.displayInfo();
    }
}

上述示例中，我们创建了一个名为"myObj"的MyClass对象，并通过调用"displayInfo"方法来显示对象的属性值。

这就是如何在Java中定义一个类。类是面向对象编程的核心概念，通过定义类和对象，我们可以实现代码的封装、重用和扩展。

如何使用JAVA中的对象

在Java中，使用对象的步骤如下：

创建对象：使用关键字new和构造器来创建一个新的对象。例如，可以使用以下代码创建一个Person对象：

Person person = new Person();

访问对象的属性：通过对象名称和点操作符.来访问对象的属性。例如，可以使用以下代码设置Person对象的姓名属性：

person.setName("John");

调用对象的方法：通过对象名称、点操作符和方法名来调用对象的方法。例如，可以使用以下代码调用Person对象的sayHello方法：

person.sayHello();

使用对象作为参数：可以将对象作为参数传递给方法或构造器。例如，可以使用以下代码将Person对象作为参数传递给printPersonInfo方法：

printPersonInfo(person);

比较对象：可以使用equals方法来比较两个对象是否相等。例如，可以使用以下代码比较两个Person对象是否相等：

if (person1.equals(person2)) {
    // 两个对象相等
} else {
    // 两个对象不相等
}

通过上述步骤，您可以在Java中使用对象

JAVA中的成员变量和局部变量

在Java中，成员变量（也称为实例变量）是定义在类中的变量，它们属于类的实例，每个实例都有自己的一份成员变量副本。成员变量在类的任何方法、构造函数和代码块中都可以访问。
成员变量可以使用访问修饰符（public、protected、private）进行修饰，具有不同的访问权限。如果没有使用访问修饰符，默认为包级私有。
局部变量是定义在方法、构造函数、代码块或者参数列表中的变量，它们只在所定义的作用域内可见。局部变量在声明时需要初始化，并且不会被自动初始化。
局部变量不可以使用访问修饰符进行修饰，因为它们只在所定义的作用域内可见，无法被其他代码访问。
成员变量和局部变量的主要区别在于作用域和生命周期。成员变量的作用域是整个类，它们的生命周期与类的实例相关。而局部变量的作用域只限于所定义的代码块，它们的生命周期在代码块执行完毕后结束。

JAVA中的构造方法

在Java中，构造方法是一个特殊的方法，用于创建和初始化对象。构造方法与类的名称相同，没有返回类型，并且在创建对象时被自动调用。
构造方法的主要用途是在创建对象时为对象的成员变量赋初始值。当创建一个类的实例时，构造方法会被自动调用，以便为该实例的成员变量分配内存空间，并将初始值赋给它们。
构造方法有以下特点：

构造方法的名称必须与类的名称完全相同。
构造方法没有返回类型，包括void类型也不可以。
构造方法可以有参数，也可以没有参数。
如果没有提供任何构造方法，Java编译器会自动提供一个无参数的默认构造方法。
如果提供了带参数的构造方法，则需要使用该构造方法来创建对象。

以下是一个示例代码，展示了一个具有参数的构造方法的用法：

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public static void main(String[] args) {
        Person person = new Person("John", 25);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

在上面的示例中，构造方法Person(String name, int age)接收一个name和age参数，并将它们赋值给对象的成员变量。在main方法中，我们使用这个构造方法创建了一个Person对象，并通过调用对象的方法获取对象的属性值并打印出来。

JAVA中static使用之静态变量

在Java中，static关键字可以用来修饰类的成员——静态成员，其中之一就是静态变量。
静态变量是在类的所有对象中共享的变量。它属于类而不属于任何特定的对象。无论创建了多少个类的对象，静态变量只有一个副本。
静态变量可以通过类名直接访问，无需创建对象。其访问格式为：类名.静态变量名。
静态变量的声明和普通变量一样，在变量声明前加上static关键字即可。例如：

public class Example {
    static int count;
    // 其他代码
}

在类的其他方法中，可以直接通过类名.静态变量名的方式使用静态变量，无需创建对象。例如：

public class Example {
    static int count;
    public static void increment() {
        count++;
    }

    public static void main(String[] args) {
        increment();
        System.out.println(Example.count);
    }
}

上述代码中，静态变量count在increment()方法中被自增操作，然后通过Example.count打印出来。
需要注意的是，静态变量在类加载时就被初始化，可以在声明时直接赋初值，也可以在静态代码块中赋值。例如：

public class Example {
    static int count = 0;

    static {
        count = 10;
    }

    public static void main(String[] args) {
        System.out.println(Example.count);
    }
}

上述代码中，在静态代码块中给静态变量count赋值为10，然后通过Example.count打印出来。

static使用之静态方法

静态方法是指不需要实例化类对象就可以直接调用的方法。在Java中，可以使用static关键字来定义静态方法。
静态方法与实例方法最大的区别在于静态方法不依赖于类的实例化，也不能访问非静态的实例变量和实例方法。静态方法的调用方式是通过类名直接调用，不需要创建类的实例对象。
静态方法的定义格式如下：

修饰符 static 返回类型 方法名(参数列表) {
   // 方法体
}

静态方法可以直接通过类名调用，例如：

public class MyClass {
    public static void myStaticMethod() {
        System.out.println("This is a static method.");
    }

    public void myInstanceMethod() {
        System.out.println("This is an instance method.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass.myStaticMethod();  // 调用静态方法
        MyClass obj = new MyClass();
        obj.myInstanceMethod();    // 调用实例方法
    }
}

输出结果：

This is a static method.
This is an instance method.

需要注意的是，静态方法不能直接访问非静态的成员变量和方法。如果想在静态方法中使用非静态的成员变量或方法，可以通过创建类的实例来调用。

JAVA中static使用之静态初始化块

静态初始化块是在类加载时执行的代码块，用来初始化静态变量或执行其他静态操作。静态初始化块使用关键字static来修饰，并使用大括号{}包裹代码块。

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

public class MyClass {
    private static int count;
    
    static {
        // 静态初始化块
        count = 10;
        System.out.println("静态初始化块执行");
    }
}

在上述示例中，MyClass类定义了一个静态变量count，并在静态初始化块中将其初始化为10。静态初始化块也会输出一条信息。
当类加载时，静态初始化块会被执行一次，且在类首次被使用之前。在整个程序运行期间，静态初始化块只会被执行一次。
静态初始化块的作用是在类加载时执行一些必要的静态操作，例如初始化静态变量，加载静态资源等。它与静态变量或静态方法的声明顺序无关，总是在它们之前执行。
需要注意的是，静态初始化块不能访问非静态的成员变量或方法，因为它们只能访问静态成员。如果需要在静态初始化块中执行操作，可以考虑将相关的成员变量或方法声明为静态。