JAVA入坑之类和对象

封装

面向对象编程核心思想之一就是将数据和对数据的操作封装在一起。通过抽象从具体的实例中抽取共同的性质形成一般的概念，比如类的概念。

继承

继承体现了一种先进的承接历史的编程模式。子类可以继承父类的属性和功能，即继承了父类所具有的数据和对数据的操作，同时又可以增添子类独有的数据和对数据的操作。

多态

多态是面向对象编程的又一重要特征。
有两种意义的多态。
一种是操作名称的多态，即有多个操作具有相同的名字，但这些操作所接收的参数类型必须不同。
另一种多态是和继承有关的多态，是指同一个操作被不同类型对象调用时可能产生不同的行为。

1.3类的语法格式

类修饰符 class 类名 [extends 父类名 implements 接口名]{

属性（变量）声明;

方法声明;

}

说明：类修饰符定义了类间的访问特性
extends：表示所声明的类继承的父类。
若没有extends声明部分，表示所声明的类是从java的根类Object进行继承(默认情况)。

类的正文要用{ }括起来

方法又包括一般方法和构造方法。

一般方法：实现功能行为，一般是对类中的数据成员进行操作。

构造方法：一般用于初始化某个类的对象。

定义类（考虑修饰符、类名）

编写类的属性（考虑修饰符、属性类型、属性名、初始化值）

编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

1.3.1类的分类

顶级类

顶级类（Top-Level Class）是指在.java文件中，处于最外层的类。它不是嵌套类，也就是说它不包含在另一个类或接口的主体内，即只有类/接口/枚举/注解/record(Java 17)

成员级

在Java中，成员级别（member level）指的是访问级别修饰符，它决定了其他类是否可以使用特定的字段或调用特定的方法。对于成员变量和方法，有四种不同的访问级别：private（私有），protected（受保护），public（公共）和package-private（无显式修饰符）。声明在类型内部的，可以是，类/接口/变量/常量/方法等

方法

在Java中，方法（Method）是定义在类或接口内部的一段代码，它可以执行特定的操作并返回结果。方法必须定义在类或接口内部，不能单独存在。

1.3.2类修饰符

访问级别修饰符，决定了其修饰的类型/变量/方法的作用范围(可访问范围，可见范围)

在这里插入图片描述

Package级

允许源文件名与类型名称不同

Public级别则不允许

1.4变量

1.4.1变量格式

语法格式： [修饰符] 类型属性名 [=初值 ];

①成员变量的类型可以是Java中的任何一种数据类型，包括基本类型：整型、浮点型、字符型、逻辑类型；引用类型：数组、对象和接口。

②成员变量在整个类内的所有方法里都有效，其有效性与它在类体中出现的位置无关。

③声明成员变量时如果没有指定初始值，Java编译器会为其指定默认值。数0。

④声明成员变量1指定的初始值和成员变量2的值有关，那么声明成员变量2的位置要在声明成员变量1的前面。

public修饰的成员变量，公有成员变量，变量可以被全局访问 private修饰的成员变量，

私有成员变量，变量仅能在类中被访问

注意：

成员变量必须通过对象操作访问，不要通过公有成员变量暴露对象中数据。

封装

在Java中，封装（Encapsulation）是指将类的实现细节隐藏起来，只向外界暴露必要的接口。这样可以保护类的内部数据，防止外部对其进行不合法的访问和修改。

封装通常通过定义私有（private）成员变量和公共（public）方法来实现。私有成员变量只能在类的内部访问，而公共方法则可以被外部调用。通过公共方法，外部可以安全地访问和修改类的内部数据。

1.4.2成员变量

在Java中，成员变量（Member Variable）是指定义在类或接口中的变量。它们可以是实例变量或类变量。

实例变量

实例变量（Instance Variable）是指定义在类中，但不带有static修饰符的变量。实例变量属于类的实例，每个实例都有自己的一份实例变量。

实例变量通常用于存储与对象相关的数据。它们可以在类的所有方法中访问。

类变量

类变量（Class Variable）是指带有static修饰符的变量。它们属于类本身，所有实例共享一份类变量。

类变量可以在类的所有方法中访问，包括实例方法和类方法。它们通常用于存储与类相关的数据。

1.4.3区分实例变量和类变量

实例变量和类变量都是成员变量。它们都是成员变量，因为它们都与特定类相关联。但是，实例变量和类变量之间存在差异。

实例变量属于类的实例。换句话说，实例变量属于对象，因为对象是类的实例.

类变量是属于所有对象的，用static修饰，实例变量是属于某个对象的。类变量也叫静态变量，不需要通过创建实例就可以调用。

简而言之，实例变量和类变量的区别不同对象的实例变量互不相同所有对象共享类变量通过类名直接访问类变量

1.4.4局部变量

局部变量（local variable）是定义在方法、构造函数或块内部的变量。它们只能在定义它们的方法、构造函数或块内部访问。局部变量通常用于临时存储数据。

1.4.5区分成员变量和局部变量

1.如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即该成员变量在这个方法内暂时失效。

2.如果想在该方法中使用被隐藏的成员变量，必须使用关键字this

3.成员变量有默认值，但局部变量没有默认值，因此在使用局部变量之前，必须保证局部变量有具体的值。

需要注意的问题

1.5final关键字

final关键字表示对象是最终形态的，对象是不可改变的意思。1 final关键字可用于变量声明，一旦该变量被设定，就不可以再改变该变量的值。

1.5.1常量

final修饰的成员变量只可以被赋值一次，只可以被赋初值，并且在定义的时候必须要赋初值，否则报错，其语法如下所示：final dataType variableName = value。其中，final是定义常量的关键字，dataType指明常量的数据类型，variableName是变量的名称，value是初始值。例如，以下语句使用final关键字声明常量：public static final double PI = 3.14;

1.6方法

1.6.1一般方法的组成

在Java中，方法（Method）由以下几部分组成：

访问修饰符（Access Modifier）：定义方法的访问级别，如public、private、protected或默认（无修饰符）。
返回类型（Return Type）：定义方法返回值的数据类型。
方法名（Method Name）：定义方法的名称。
参数列表（Parameter List）：定义方法接收的参数及其类型，参数是声明在()圆括号，`,`逗号分隔输入的参数列表，声明方法需要的参数数据类型及参数名称。如果没有参数，也必须使用空的括号
方法体（Method Body）：定义方法执行的具体操作

1.6.2方法签名

方法签名（Method Signature）是指方法的名称和参数列表(方法参数数量，相应位置的参数类型)。它用于唯一标识一个方法。方法签名不包括方法的返回类型和访问修饰符。

1.6.3方法重载

方法重载（Method Overloading）是指在同一个类中定义多个同名但参数列表不同的方法。重载方法可以根据传入的参数类型和数量来调用不同的方法实现，解决了方法功能相同，但必须使用不同命名的缺陷

1.6.4方法封装

为什么封装，因为为了保护类中的属性不被改变。

封装的步骤：
1.所有属性私有化（使用private关键字进行修饰，private表示私有的），私有化的属性只能在本类中进行访问。
2.对外提供简单的操作入口，也就是以后外部程序访问类的属性的时候只能通过这些入口才能访问。
- 对外提供两个公开的方法，分别是set方法和get方法。
- 想修改类的属性的值用set方法。
- 想得到类的属性的值用get方法。

1.6.5构造方法

构造方法的作用是在创建对象时使用，主要是用来初始化各个成员变量，以便给类所创建的对象一个合理的初始状态

在Java中，构造方法（Constructor）是一种特殊的方法，用于在创建对象时初始化对象的状态。构造函数无返回值名称与类名完全相同包括首字母大写

可以通过new操作符，调用构造函数，创建一个类的对象

当使用new关键字创建一个类的实例时，会自动调用类的构造方法。如果类中没有定义构造方法，编译器会自动为其生成一个默认的无参构造方法。

类可以声明多个构造函数，但不能具有相同的参数列表。即，类中不能存在方法签名相同的构造函数,也就是构造方法可以重载

当类显式声明了有参构造函数，编译器将不再自动创建无参构造函数

1.6.6成员方法

在Java中，成员方法（Member Method）是指定义在类或接口中的方法。它们可以是实例方法或类方法。

实例方法

在Java中，实例方法（Instance Method）是指定义在类中，但不带有static修饰符的方法。实例方法属于类的实例，只能通过类的实例来调用。

实例方法可以访问类的实例变量和实例方法，也可以访问类变量和类方法。它们通常用于执行与对象相关的操作。

类方法

在Java中，类方法（Class Method）是指带有static修饰符的方法。它们属于类本身，可以通过类名直接调用。

类方法可以访问类变量和类方法，但不能访问实例变量和实例方法。它们通常用于执行与类相关的操作。

类中，实例级方法单向访问方法静态成员(方法/变量/常量) 类中，静态方法无法访问实例级成员(方法/变量/this等)，静态方法中只能直接调用同类中其他的静态成员（包括方法和变量），而不能直接访问类中的非静态成员。

实例方法和类方法的区别

1.6.7可变参数

在Java中，可变参数是指函数可以接受不定数量的参数。可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数。由于可变参数必须是最后一个参数，所以一个函数最多只能有一个可变参数。Java的可变参数，会被编译器转型为一个数组

可变参数使用“…”表示若干个参数，这些参数的类型必须相同. “参数代表”必须是参数列表中的最后一个例如： public void f(double item, int … x) public void g(int … x)

调用方法时，使用逗号“,”分隔传入的参数

1.6.8getter/setter方法

在Java中，getter和setter是两种常规方法，用于检索和更新变量的值。为了实现封装，即确保“敏感”数据对用户隐藏，必须将类变量/属性声明为私有，并提供公共的get和set方法来访问和更新私有变量的值。

命名规范

方法基于驼峰式命名，get/set首字母小写，属性名称首字母大写；boolean类型属性的getter方法以is为前缀，因此，boolean类型属性禁止使用is字母开头；

getter/setter方法名称必须与属性名称一致，第三方库基于此命名规范反射

1.6.9方法重载与多态

方法重载（Overloading）和多态（Polymorphism）是Java中两个重要的概念。

方法重载是指在同一个类中，允许存在多个同名方法，只要它们的参数列表不同即可。这样，当我们调用这个方法时，Java会根据传递的参数自动选择合适的方法。

多态是指允许不同类的对象对同一消息做出响应。简单来说，多态就是同一个行为具有多个不同表现形式或形态。在Java中，多态的实现主要依赖于继承、接口和重写。

1.7`this`关键字

this关键字是一个引用变量，指向当前对象。它可以用来访问当前对象的成员变量和方法。

this关键字通常用于以下几种情况：

在构造方法或方法中，当成员变量和局部变量重名时，可以使用this关键字来区分它们。
在构造方法中，可以使用this关键字调用当前类的其他构造方法。

在方法中，可以使用this关键字将当前对象作为参数传递给其他方法。

二、对象

在Java中，对象是根据类创建的。使用关键字new来创建一个新的对象。创建对象需要以下三步：声明，实例化和初始化。

2.1声明对象

声明一个对象，包括对象名称和对象类型。使用关键字new来创建一个对象。使用new创建对象时，会调用构造方法初始化对象

2.2实例化和初始化

在Java中，实例化一个对象时，JVM首先会检查相关类型是否已经加载并初始化，如果没有，则JVM立即进行加载并调用类构造器完成类的初始化。实例化是使用关键字new来创建一个对象。使用new创建对象时，会调用构造方法初始化对象

2.3 使用对象

对象创建成功后，可以操作类中的变量和方法：

1．对象操作自己的变量（体现对象的属性）通过使用运算符“.” 对象操作自己的变量（对象的属性）。

2．对象调用类中的方法（体现对象的行为）对象创建之后，可以使用点运算符“.”调用创建它的类中的方法，从而产生一定的行为（功能）。

★强调：当对象调用变量时，是指调用分配给该对象自己的变量。在讲述类的时候讲过：类中的方法可以操作成员变量；当对象调用方法时，方法中出现的成员变量就是指分配给该对象的那个变量

2.4对象引用和实体

在Java中，对象引用就是一个变量，有名字，我们可以直接访问，它存储的是一个地址，这个地址指向堆内存中某一个该类型的对象实体；而对象实体没有名字

2.5传值机制

在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的拷贝。

1）对于基本数据类型的参数，向该参数“传值”，传递的是值的拷贝. 例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递的值的拷贝。

2）对于参数是引用类型时，“传值”传递的是变量的引用而不是变量所引用的实体。Java的引用型数据包括对象、数组和接口。

2.6包成员（package members.）

包成员是指构成包的类型。要从包外部使用公共包成员，必须执行以下操作之一：通过其完全限定名称引用成员，导入包成员，或导入成员的整个包

预使用其他包中的public类型(类/接口等)，必须通过以下任一方式：
1.通过包含，包名以及类型名称的，全限定性名称(fully qualified names)，使用该成员
2.导入包成员，通过其简单名称(simple name) 使用
3.导入成员的整个包

导入成员的整个包，通过*号通配符，导入特定包中的所有类型

2.7垃圾收集器（The Garbage Collector）

java内存的使用
1.栈内存：用于存放在函数中定义的一些基本类型的变量和对象的引用变量。当超过该变量的作用域时，java会自动释放为该变量分配的内存空间，该内存空间将被另作他用。

2.堆内存：用于存放由new创建的对象和数组。在堆中由new创建的对象和数组是由栈中定义的引用变量来指向的，引用变量的取值为该数组或对象在堆内存中的首地址。引用变量在程序运行到其作用域外后被释放，此时堆中的数组和对象在没有引用变量指向它时，进而变成垃圾。

垃圾收集器是一种自动内存管理的形式。垃圾收集器试图回收程序分配但不再引用的内存，这种内存称为垃圾。垃圾收集器的优化引擎根据分配情况确定执行收集的最佳时间。当垃圾收集器执行收集时，它检查托管堆中不再被应用程序使用的对象，并执行必要的操作以回收它们的内存

当变量超出作用范围，变量引用会被删除，一个没有任何引用的对象将被垃圾回收器回收可以通过置变量引用为null，来显式的声明删除对象的引用，但仅是声明，并不会立即释放内存同一对象可能有多个引用

finalize
在一个对象得到垃圾回收之前（无论是显式回收还是自动回收），垃圾收集器给对象一个机会来调用自己的finalize方法，这个过程称为对象的撤销方法。
finalize方法是Object类的一个方法，任何一个对象可以自动通过类的继承使用该方法，在当成垃圾对象被回收之前都会调用这个方法。

2.8static代码块

静态代码块是Java类中的 static { } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。它在类加载JVM时初始化，且只被执行一次；常用来执行类属性的初始化；静态块优先于各种代码块以及构造函数；此外静态代码块不能访问普通变量

补充类的，加载/构造/静态方法/静态代码块/实例级成员变量初始化的执行顺序

在Java中，子类继承父类，子类创建对象时，执行顺序如下： ①父类静态代码块>>②子类静态代码块>>③父类非静态代码块>>④父类构造函数>>⑤子类非静态代码块>>⑥子类构造函数。总结: 父类早于子类，静态早于非静态，非静态早于构造函数，父类非静态和构造函数早于子类非静态和构造函数

构造代码块

构造代码块是在类的成员位置，用 {} 括起来的代码。每实例化一次对象，执行一次里面的代码，且多个构造代码块，按照顺序执行构造代码块。构造代码块在创建对象时被调用，每次创建对象都会被调用，并且构造代码块的执行次序优先于类构造函
这是一个构造代码块的例子：
```java
public class Test {
    // 构造代码块
    {
        System.out.println("构造代码块");
    }

    // 构造函数
    public Test() {
        System.out.println("构造函数");
    }

    public static void main(String[] args) {
        new Test();
    }
}
```
运行结果：
```
构造代码块
构造函数
```
在这个例子中，当我们创建一个Test类的实例时，构造代码块会在构造函数之前被调用。

执行静态代码块、执行构造代码块、执行构造函数

对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是（静态变量、静态初始化块）>（变量、构造代码块）>构造函数。

2.9组合与复用

对象组合指的是在一个类中的对象可以将其他类的对象作为自己的组成部分，这个过程就是对象的组合。完成对象的组合后，通过所组合的对象调用其类中的方法，这就是方法复用

嵌套类

在Java中，嵌套类（Nested Class）是指定义在另一个类中的类。根据嵌套类是否被声明为静态，嵌套类分为静态嵌套类（Static Nested Class）和非静态嵌套类（Inner Class）。

静态嵌套类是被声明为静态的嵌套类。它可以访问外部类的所有静态成员和方法，包括私有的。静态嵌套类对象不依赖于外部类对象，可以直接创建。

非静态嵌套类也称为内部类。它可以访问外部类的所有成员和方法，包括静态和非静态的，也包括私有的。内部类对象依赖于外部类对象，只有在外部类对象存在的情况下才能创建内部类对象。

静态内部类，不持有外部类的引用。因此，无法调用外部类的任何实例级成员即，静态内部类与外部类，仅是代码上的嵌套，即使在外部类内部也无法调用private变量

2.10枚举类型

2.10.1枚举类

枚举（enum ）类型，是一种特殊的数据类型，定义了一组预定义的枚举常量列表
使用普通键值对常量，可以限制结果，但无法限制输入变量的范围
而枚举通过预定义的枚举常量，可以限制变量的使用范围

枚举类型中的值均代表常量，因此字母全部大写

枚举类型的定义使用关键字 enum，其语法类似于类的定义。枚举常量之间用逗号隔开，可以像类一样为枚举类型添加构造函数、方法和字段。

枚举类型具有一些内置方法，例如 values() 方法返回枚举类型的所有值，valueOf(String name) 方法根据给定的名称返回对应的枚举常量。

2.10.2枚举方法

ordinal()方法 ordinal()方法返回枚举常量的位置。

compareTo()方法 compareTo()方法根据序数值比较枚举常量。

toString()方法 toString()方法返回枚举常量的字符串表示形式。

name()方法 name()方法以字符串形式返回枚举常量的定义名称。name()方法返回的值为final。

valueOf()方法 valueOf()方法采用字符串，并返回具有相同字符串名称的枚举常量。

values()方法 values()方法返回包含所有枚举常量的枚举类型数组。

public class Main {
    enum Color {
        RED, GREEN, BLUE
    }

    public static void main(String[] args) {
        Color color = Color.RED;

        // 使用ordinal()方法
        System.out.println("color.ordinal(): " + color.ordinal());

        // 使用compareTo()方法
        System.out.println("color.compareTo(Color.GREEN): " + color.compareTo(Color.GREEN));

        // 使用toString()方法
        System.out.println("color.toString(): " + color.toString());

        // 使用name()方法
        System.out.println("color.name(): " + color.name());

        // 使用valueOf()方法
        Color color2 = Color.valueOf("BLUE");
        System.out.println("color2: " + color2);

        // 使用values()方法
        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println(c);
        }
    }
}

2.10.3枚举构造函数

枚举类可以包含构造函数，用于初始化枚举常量。当定义枚举常量时，可以为其传递参数，这些参数将被传递给枚举构造函数。枚举构造函数必须是私有的，因此无法从外部调用。

public class EnumConstructorExample {
    enum Color {
        RED("红色"), GREEN("绿色"), BLUE("蓝色");

        private String name;

        // 构造函数
        private Color(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

    public static void main(String[] args) {
        Color color = Color.RED;
        System.out.println(color.getName());
    }
}

2.10.4Java枚举字符串

在Java中，可以使用枚举类的valueOf()方法将字符串转换为枚举常量。valueOf()方法接受一个字符串参数，该参数表示要转换的枚举常量的名称。如果该字符串与枚举类中定义的任何枚举常量的名称匹配，则valueOf()方法将返回相应的枚举常量。如果没有匹配项，则valueOf()方法将抛出IllegalArgumentException异常。

public class EnumValueOfExample2 {
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    public static void main(String[] args) {
        String dayString = "WEDNESDAY";
        Day day = Day.valueOf(dayString);
        System.out.println(day);
    }
}

上述代码中，我们定义了一个名为Day的枚举类，其中包含七个枚举常量，分别表示一周的七天。在main方法中，我们定义了一个名为dayString的字符串变量，并将其初始化为"WEDNESDAY"。然后，我们调用了Day.valueOf()方法，将该字符串转换为相应的枚举常量。

烟雨平生9527

关注

5
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
2
评论
JAVA入坑之类和对象

在堆中由new创建的对象和数组是由栈中定义的引用变量来指向的，引用变量的取值为该数组或对象在堆内存中的首地址。当变量超出作用范围，变量引用会被删除，一个没有任何引用的对象将被垃圾回收器回收可以通过置变量引用为null，来显式的声明删除对象的引用，但仅是声明，并不会立即释放内存同一对象可能有多个引用。对象组合指的是在一个类中的对象可以将其他类的对象作为自己的组成部分，这个过程就是对象的组合。子类可以继承父类的属性和功能，即继承了父类所具有的数据和对数据的操作，同时又可以增添子类独有的数据和对数据的操作。
复制链接

扫一扫