目录
引言
在Java这门面向对象的编程语言中，类（Class）和对象（Object）是核心概念。类是对象的蓝图，定义了一组具有相同属性（状态）和行为（方法）的对象集合。对象则是这些类的具体实例。下面，我们将详细探讨Java中的类和对象。
类的定义
简单认识类
类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。
//比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。
//属性：产品品牌，型号，产品重量，外观尺寸，颜色...
//功能：洗衣，烘干、定时....类其实有点类似于C语言中的结构体类型，只不过Java中的类能做的事更多，往往也更加复杂。
类的定义格式
类是对象的模板，它定义了对象的状态和行为。在Java中，类使用class关键字来定义。
具体语法如下：
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
class为定义类的关键字，ClassName为类的名字，{}中为类的主体。
类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。
采用Java语言将类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。
注意事项：
- 类名注意采用大驼峰定义。
- 此处写的方法不带static关键字。
定义一个学生类
public class Student{
public String name;
public String sex;
public int age;
public double score;
public void Class() {
}
public void Homework() {
}
public void Exam() {
}
}注意事项：
- 一般一个文件当中只定义一个类。
- main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)。
- public修饰的类必须要和文件名相同。
- 不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改。
类的实例化
定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：Student类。它们都是类(一种新定义的类型)有了自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。
用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。创建对象的过程通常包括声明、实例化和初始化三个步骤。
例如：
Student student = new Student();
注意事项：
- new 关键字用于创建一个对象的实例。
- 使用'.'来访问对象中的属性和方法。
- 同一个类可以创建对个实例。
- 当类实例化对象时才会类里边的对象才会占用物理空间。
this引用
this引用用来解决两件事：
- 形参名不小心与成员变量名相同。
- 多个对象都在调用同一个方法时为不同对象做区分。
this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
代码示例如下：
public class Main {
public int year;
public int month;
public int day;
public static void main(String[] args) {
Main date = new Main();//实例化
//第一次调用
date.setDay(2024, 3, 14);
date.printDate();
//第二次调用
date.setDay(2008, 4, 1);
date.printDate();
}
public void setDay(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate() {
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}注意：this引用的是调用成员方法的对象。
代码运行结果如下：
注意事项：
- this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型。
- this只能在"成员方法"中使用。
- 在"成员方法"中，this只能引用当前对象，不能再引用其他对象。
- this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收。
构造方法
构造方法是一种特殊的方法，用于在创建对象时初始化对象。如果没有显式定义构造方法，Java编译器会提供一个默认的构造方法。
public class Dog {
public Dog() {
// 这是一个构造方法
}
}
构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。
构造方法特点：
1. 名字必须与类名相同。
2. 没有返回值类型，设置为void也不行。
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次。
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。
代码演示如下：
public class Main {
public int year;
public int month;
public int day;
// 无参构造方法
public Main() {
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 带有三个参数的构造方法
public Main(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public static void main(String[] args) {
Main date1 = new Main();//实例化并调用无参构造
date1.printDate();
Main date2 = new Main(2024, 3, 13);//实例化并调用三个参数的构造方法
date2.printDate();
}
public void setDay(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate() {
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}代码运行结果如下：
上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。
5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的（注意：一旦用户定义，编译器则不再生成）。
6. 构造方法中，可以通过this调用其他构造方法来简化代码。
public class Main {
public int year;
public int month;
public int day;
//无参构造
public Main(){
//System.out.println(year); 注释取消掉，编译会失败
this(1900, 1, 1);
}
//带有三个参数的构造方法
public Main(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}注意：
- this(...)必须是构造方法中第一条语句，否则会编译不通过。
- 不能形成环。
初始化所分配的空间：对象空间被申请好之后，对象中包含的成员已经设置好了初始值。boolean类型是false，引用类型是null，浮点型是0.0，其他的都是0。
就地初始化
在声明成员变量时，就直接给出了初始值。
public class Main {
public int year = 1900;
public int month = 1;
public int day = 1;
public Main() {
}
public static void main(String[] args) {
Main main2 = new Main();
}
}注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。
类变量和方法
类变量（静态变量）和类方法（静态方法）是属于类的，而不是属于任何单个对象的。使用static关键字来声明。
static修饰成员变量
static修饰的成员变量，称为静态成员变量。
静态成员变量的特性：
- 不属于某个具体的对象，是所有对象所共享的。
- 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问（通过对象访问不会报错但是会报警告）。
- 类变量存储在方法区当中。
- 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)。
代码示例如下：
class Test {
static int count;//这是静态成员！
}
public class Main {
public static void main(String[] args) {
System.out.println(Test.count);//第一次打印
Test.count++;
System.out.println(Test.count);//第二次打印
}
}代码运行结果如下：
如果以调试方式运行上述代码，我们会发现静态成员变量并没有存储到某个具体的对象中。
static修饰成员方法
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
代码示例如下：
class Test {
public static void test() {
System.out.println("这是静态方法！");
}
}
public class Main {
public static void main(String[] args) {
Test.test();
}
}代码运行结果如下：
请注意：
- 静态方法不属于某个具体的对象，是类方法。
- 静态方法可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者。
- 不能在静态方法中访问任何非静态成员变量。
- 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用。
- 静态方法无法重写，不能用来实现多态。
静态方法和静态变量的实例化
静态成员方法和静态成员变量均只在内存中存一份，无论你new多少次（实际上，静态的数据根本就不需要用new关键字来实例化）。
下面用静态成员变量来做个演示：
class Test {
static int t = 100;//就地初始化
}
public class Main {
public static void main(String[] args) {
Test data1 = new Test();
System.out.println(++data1.t);
Test data2 = new Test();
System.out.println(++data2.t);
//通过类名来访问
System.out.println(++Test.t);
}
}代码运行结果如下：
运行上述代码我们可以发现：输出的结果并不是我们想要的三个101，这就是因为上面说过的“静态数据只存储一份”，new出来的是同一份并不是新的。
而且，当我们去new一个只有静态成员的类和使用变量名去访问静态成员时，编译器会报警告（奇怪的是，用变量名去.静态成员时会.不出来，手动输入却能正常使用，但至少能看出来编译器并不希望我们通过这种方式去访问静态成员）。
封装
封装的概念
封装是面向对象编程的一个重要特性，它通过将数据（变量）和代码（方法）绑定到一起，并对外界隐藏数据的访问细节来提高安全性。
public class Main {
private String name;
//提供的获取name的方法
public String getName() {
return name;
}
//提供的修改name的方法
public void setName(String newName) {
name = newName;
}
}访问限定符
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。
表格如下：
说明：
- protected主要是用在继承中。
- default权限指：什么都不写时的默认权限。
- 访问权限除了可以限定类中成员的可见性，也可以控制类的可见性。
注意：一般情况下成员变量设置为private，成员方法设置为public。
结语
以上，就是的本次要教大家的Java中的类和对象的全部内容，感谢大家愿意花时间阅读本文！
如有错误，建议，或问题均可在评论区指出！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
