java基础（4）类和对象-CSDN博客

类名：使用class关键字后跟类名来声明一个类。类名应该是一个有效的标识符，并且习惯上首字母大写，采用驼峰命名法。

成员变量（也称为属性）：在类中声明的变量，用于描述对象的特征或状态。成员变量可以是任何类型，包括基本数据类型和引用数据类型。

方法：类中定义的方法描述了对象的行为。方法包含方法声明和方法体。方法声明包括方法名、返回类型（如果方法不返回任何值，则为void）、以及参数列表（如果方法不接受任何参数，则为空）。方法体包含执行特定操作的语句。

构造方法：一种特殊类型的方法，用于初始化新创建的对象。构造器的名称必须与类名完全相同，并且没有返回类型（连void也没有）。

下面为大家附上一段代码来让大家更加清楚的知晓类的组成部分：

public class Book {
    public String bookNo;
    public String bookTitle;
    public String author;
    public int yearPublished;

    public Book(String bookNo,String bookTitle,String author,int yearPublished){
        this.bookNo = bookNo;
        this.bookTitle = bookTitle;
        this.author = author;
        this.yearPublished = yearPublished;
    }
    
    public void showBookTitle() {
        System.out.println(bookTitle);
    }
    
}

接下来详细分析以上这段代码：

类名

Book：这是类的名称，代表了一个书籍的抽象表示。

成员变量

public String bookNo;：类型为String，用于存储书籍的编号。

public String bookTitle;：类型为String，用于存储书籍的标题。

public String author;：类型为String，用于存储书籍的作者。

public int yearPublished;：类型为int，用于存储书籍的出版年份。

以上四个都为公开的成员变量，置于何为公开下文会讲。

方法

public void showBookTitle() { ... }：这是一个公开的方法，没有返回值（void类型），用于打印书籍的标题。方法体内通过System.out.println(bookTitle);语句实现了这一功能。

构造方法

public Book(String bookNo,String bookTitle,String author,int yearPublished){ ... }：这是一个公开的构造方法，用于创建Book类的实例。它接收四个参数，分别对应于书籍的编号、标题、作者和出版年份，并将这些参数的值分别赋给类的成员变量。构造方法没有返回值，并且其名称必须与类名完全相同。

2.1.2类的实例化

类的实例化离不开new关键字，接下来是详细描述当new关键字出现时，计算机内部的操作，记住，下文只需了解，不需要严格掌握：

当new关键字被调用时，JVM（Java虚拟机）会在堆内存中为新的对象实例分配足够的内存空间。这个空间的大小取决于对象的类型以及它所包含的数据类型的大小。
接下来，JVM会调用类的构造方法来初始化对象的状态。如果提供了参数，这些参数会被传递给构造方法。构造方法中的代码会执行，用于设置对象的初始状态。
构造方法执行完毕后，JVM会将新创建的对象实例的引用（即对象的内存地址）返回给调用者。这个引用可以被存储在变量中，以便后续对对象进行操作。

附上一段实际的代码：

public class Main {  
    public static void main(String[] args) {  
        // 类的实例化  
        Book book1 = new Book("12345", "Java Programming", "John Doe", 2023);  
  
        // 使用对象  
        book1.showBookTitle(); 
  
        // 另一个实例  
        Book book2 = new Book("67890", "Python Basics", "Jane Smith", 2022);  
  
    }  
}

2.1.3this引用

介绍完了通过new关键字来实例化对象，接下来我们来介绍this关键字引用。

2.1.3.1 访问当前对象的成员变量

例如这里我们有这样一段代码：

public class Person {  
    String name; // 成员变量  
  
    public Person(String name) {  
        this.name = name; // 使用this引用成员变量name，并将其值设置为参数name的值  
    }  
  
    public void sayHello() {  
        System.out.println("Hello, my name is " + this.name); // 使用this引用成员变量name  
    }  
}

在这个例子中，this.name 指的是 Person 类的成员变量 name，而构造方法参数 name 是一个局部变量。通过使用 this.name，我们能够明确指出我们想要访问的是成员变量 name 而不是参数 name。

2.1.3.2调用当前对象的成员方法

虽然调用当前对象的成员方法时通常不需要显式地使用 this 关键字（除非存在方法重载并且需要区分调用哪个方法），但在某些情况下，使用 this 可以使代码更加清晰，例如下文：

public class Calculator {  
    public int add(int a, int b) {  
        return a + b;  
    }  
  
    public int addThreeNumbers(int a, int b, int c) {  
        // 调用另一个成员方法  
        return this.add(a, b) + c;  
    }  
}

这个this并不刚需，但有的时候加上去可以是我们为后面浏览代码的时候，看着更加流畅。

2.1.3.3构造函数中的 `this`

在构造函数中，this 关键字可以用于调用同一类的另一个构造函数。但是，这种调用必须是构造函数中的第一条语句。

public class Rectangle {  
    int width, height;  
  
    // 构造函数1  
    public Rectangle(int width, int height) {  
        this.width = width;  
        this.height = height;  
    }  
  
    // 构造函数2，使用另一个构造函数初始化  
    public Rectangle(int size) {  
        this(size, size); // 调用具有两个参数的构造函数  
    }  
}

2.1.3.4归纳this

那么应用场景讲了这么多，那它到底本质是什么呢。

this 实际上是一个指向当前对象的引用。在对象的方法内部，this 引用总是可用的，并且它指向调用该方法的对象。因此，你可以使用 this 来访问类的成员变量和方法，尽管无关紧要是加上也是良好代码习惯的体现。

2.2封装

接下来就让我们来引入一个非常重要的环节——封装。

2.2.1封装的定义

封装是一种信息隐藏技术，它通过将对象的内部状态（属性）和对这些状态的操作（方法）封装在一个类中，使得外界只能通过类的接口（即公开的方法）来访问和操作对象的状态，而无法直接访问对象的内部实现细节。这样做的好处包括提高代码的安全性、可维护性和可复用性。

2.2.2访问修饰符

封装主要通过访问修饰符（如public、private、protected和默认的包访问级别）来实现。这些访问修饰符用于控制类、成员变量和成员方法的访问权限。

public：表示公开的，可以被任何其他类访问。
private：表示私有的，只能被当前类访问，不能被子类或其他类访问。
protected：表示受保护的，可以被当前类、同一个包中的其他类以及子类访问。
默认（无修饰符）：也称为包访问级别，表示该成员只能被同一个包中的类访问。

通过将类的成员变量设置为private，并提供公共的getter和setter方法来访问和修改这些变量，可以实现封装。这样，外部代码就只能通过这些公共的方法来与对象交互，而无法直接访问或修改对象的内部状态。

public class BookPrivate {  
    // private成员变量，只能在BookPrivate类内部被访问  
    // public成员变量，可以在任何地方被访问 
    private String title;  
    public int num;
  
    // public构造方法  
    public BookPrivate(String title) {  
        this.title = title;  
    }  
  
    // public getter方法，用于外部访问private成员变量  
    public String getTitle() {  
        return title;  
    }  
  
    // public方法，可以在任何地方被调用  
    public void displayTitle() {  
        System.out.println("Book Title: " + title);  
    }  
}

2.3static

static修饰符用于声明类变量和类方法。使用static修饰的成员属于类本身，而不是类的某个特定对象。因此，它们可以在没有创建类实例的情况下被访问和修改。

2.3.1static修饰成员变量

当成员变量被声明为static时，该变量不再是某个对象的实例变量，而是成为类的变量。这意味着无论创建了多少个类的对象，皆被所有对象共享。

2.3.2static修饰成员方法

当成员方法被声明为static时，该方法属于类而不是类的某个特定对象。因此，它可以在没有创建类实例的情况下被调用。静态方法不能直接访问类的非静态成员（变量和方法），因为非静态成员属于类的特定实例，而静态方法不依赖于任何特定实例。

2.3.3具体代码

public class count {
        // 静态变量 
        private static int counter = 0;

        // 静态方法，用于增加计数器的值并返回新的值
        public static int moreGetCounter() {
            return ++counter;
        }

        // 只获取计数器的值
        public static int getCounter() {
            return counter;
        }

        // 主方法，用于演示静态变量和静态方法的使用  
        public static void main(String[] args) {
            // 直接通过类名调用静态方法  
            System.out.println(count.moreGetCounter());  

            // 再次增加计数器的值并获取  
            System.out.println(count.moreGetCounter()); // 输出是2  

            // 单独获取计数器的值  
            System.out.println(count.getCounter()); // 输出也是2  

            // 注意：我们仍然没有创建count类的实例，但静态变量和方法依然可以访问和修改  
        }
    }