一文搞懂Java类和对象

简介

Java类是Java编程语言的基本构建块。Java类是用于创建对象以及定义数据类型和方法的模板。Java类对象应该具有基本的类属性。本文将通过代码示例解释Java类的工作原理。

什么是Java类？

Java类是面向对象编程语言的基本概念。Java类是用户定义的模板或蓝图，其中定义了对象、数据成员和方法，以及构建特定对象类型的一组指令。同一Java类的变量和方法对于所有类对象都是通用的。

在Java中，class关键字用于定义Java类。

如何定义Java类？

语法：

class <class-name>
{
    [data members]
    [method];
}

代码示例：

class MyClass {
    int x = 5;         //数据成员
    void fun() {
        System.out.println("This is method");
    }
}

Java类的三个主要组成部分是什么？

1) Java中的类变量是什么？

变量是用于存储值的保留内存位置。换句话说，当我们想要存储任何值并给它命名时，该值在内存中占据了一个保留空间，这称为变量。

变量具有任何位于内存中的值。

语法：

<access specifier> <data type> <variable name> = <value>;

如何声明变量？

代码示例：

int x;     (int 是数据类型，x 是变量名)
int y;
int x , y;
int x = 4 , y = 5;
byte p = 65;
double pi = 3.1415;
char q = 's';

Java中不同类型的变量是什么？

1. Java中的局部变量

在方法、构造函数和块中声明的变量称为局部变量。它在方法、构造函数、块创建后创建，类看不到局部变量，也无法访问它。它的作用范围有限，因为它仅在方法内部使用。

例如，我们首先创建一个类和一个方法，然后在方法内部声明两个局部变量。

public class LocalVariableExm {
    void message() {     //这是一个方法
        int p;                     //局部变量的声明
        int x = 10;      //局部变量的声明与初始化
    }
}

Java中的静态变量

静态变量是一种非常重要的变量类型。我们使用 static 关键字与变量一起使用，因此称为静态变量。静态变量在类内部、方法、构造函数和块外部声明。静态变量属于类而不是对象，存储在静态内存中。其默认值为0，我们可以通过类名调用静态变量，因此无需为静态变量创建对象。

例如，首先我们创建一个类，并在方法外部声明了三个变量，其中两个是静态变量。

public class StaticVariableExm {
    int p;
    static int q = 10;     // 静态变量并初始化
    static int r;          // 静态变量声明
    void message() {
    }
}

Java中的实例变量

实例变量在类中声明，但在方法、构造函数或块外部。它的作用范围最广，因为它在类中全局可见。当对象创建时，实例变量也被创建。在实例变量被创建时，它在堆内存中占据空间，并通过对象调用，默认值为0。

例如，首先我们创建一个类，并在方法外部声明了两个实例变量。

public class InstanceVariableExm {
    int a;      // 实例变量的声明
    int b = 10;  // 实例变量的声明与初始化
    void message() {
    }
}

2) 什么是Java中的构造函数？

构造函数就像Java中的一个特殊方法，用于初始化Java类的对象。构造函数对于每个Java类都非常重要。如果我们不声明构造函数，编译器会创建一个Java类的默认构造函数。

构造函数必须与Java类同名。它没有返回类型。

Java中的不同类型的构造函数是什么？

默认构造函数

默认构造函数没有参数，如果我们不声明构造函数，编译器会自动创建该Java类的默认构造函数。

语法：

<class-name>() {}

以下程序创建了一个默认构造函数并输出消息。完整程序如下：

public class DefaultConstructor {
    DefaultConstructor() {
        System.out.println("This is default constructor example");
    }
    public static void main(String args[]) {
        DefaultConstructor d = new DefaultConstructor();
    }
}

什么是 Java 类中的数据成员？

数据成员是在每次创建对象时分配内存空间的那些成员。数据成员通常用于存储特定的值。

语法

数据类型 v1,v2,v3,……vn;

class DataMember
{
   int v1,v2,v3;
   float f1,f2;
}

什么是 Java 类中的访问修饰符？

访问修饰符用于确定 Java 类、数据成员、方法或构造函数的可访问性（作用域）。通过访问修饰符，我们可以设置 Java 类、变量和方法的访问级别。

有哪些不同类型的访问修饰符？

Java 中有四种访问修饰符：

• public
• private
• protected
• default（默认）

下表列出了访问修饰符：

1) 公共访问修饰符

公共访问修饰符在所有地方都可以访问。它具有所有修饰符中最广泛的作用域。在公共类中声明的变量、方法和构造函数对 Java 程序中的任何类都是可见的，无论这些类是在同一个包中还是在不同包中。

完整程序如下所示：

步骤 1. 首先，我们创建一个 Java 类 PublicExample，其中我们声明方法 show()：

public class PublicExample {
    public void show() {
        System.out.println("Public access modifier example");
    }
}

步骤 2. 接着，我们创建一个名为 PublicAccess 的类，在其中调用 PublicExample 类的方法：

public class PublicAccess {
    public static void main(String args[]) {
        PublicExample obj = new PublicExample();
        obj.show();
    }
}

2) 私有访问修饰符

私有访问修饰符只能在类内访问，不能在类外访问。声明为私有的数据成员、方法或构造函数受到严格控制。私有访问修饰符不能在类外部访问。

除了嵌套类外，Java 类不能被声明为私有。

完整程序如下所示：

步骤 1. 首先，我们创建一个 Java 类 PrivateExample，在其中声明私有方法 run()：

public class PrivateExample{
    private void run() {
        System.out.println("Scooter is running");
    }
}

步骤 2. 接着，我们创建一个 PrivateAccess 类，在其中调用 PrivateExample 类的方法：

public class PrivateAccess{
    public static void main(String args[]) {
        PrivateExample s = new PrivateExample();
        s.run();  // 编译时错误
    }
}

注意： 在这个例子中，我们创建了两个 Java 类 PrivateExample 和 PrivateAccess。PrivateExample 包含私有方法 run()。如果我们尝试在类外部访问私有方法，将会产生编译时错误。

3) 受保护的访问修饰符

受保护的访问修饰符可在包内和包外通过继承访问。

受保护的访问修饰符可以应用于变量、方法和构造函数，但不能应用于 Java 类。父类中的变量、方法和构造函数被声明为受保护，可以在其他包中的子类中访问。

完整程序如下所示：

步骤 1. 首先，我们在 pack1 包中创建一个公有的 Java 类 ProtectedExample，其中声明一个受保护的方法 display()：

package pack1;
public class ProtectedExample{
    protected void display() {
        System.out.println("Protected access modifier example");
    }
}

步骤 2. 接着，我们在 pack2 包中创建一个公有的 Java 类 ProtectedAccess，并调用 ProtectedExample 类的方法：

package pack2;
import pack1.*;
public class ProtectedAccess extends ProtectedExample{
    public static void main(String args[]) {
        ProtectedAccess p = new ProtectedAccess();
        p.display();
    }
}

4) 默认访问修饰符

当我们不使用任何修饰符时，它被视为 Java 中的默认访问修饰符。默认访问修饰符仅在包内可访问。

任何 Java 类、变量、方法和构造函数的默认访问修饰符，仅在同一包中的类可以访问。默认访问修饰符不用于接口中的变量和方法。

完整程序如下所示。

package pack1;
 class DefaultExample {
    void msg() {
        System.out.println("默认访问修饰符示例");
    }
}

步骤 1：首先，我们在包 pack1 中创建一个名为 DefaultExample 的默认 Java 类，并声明一个方法 msg()：

步骤 2：其次，我们在包 pack2 中创建一个名为 DefaultAccess 的默认 Java 类，其中调用 DefaultClass 类的方法：

package pack2;
import pack1.*;
 class DefaultAccess{
        public static void main(String args[]) {
            DefaultClass d = new DefaultClass(); // 编译时错误
            r.msg(); // 编译时错误
        }
}

注意：在这个示例中，我们创建了两个 Java 类 DefaultClass 和 DefaultAccess。 DefaultClass 是一个默认的 Java 类，无法在包外访问。因此，它会产生编译时错误。

Java 中有多少种类型的类？

Java 中有三种主要类型的类：

• 抽象 Java 类
• 嵌套 Java 类
• 最终 Java 类
• 单例 Java 类

1) 什么是 Java 中的抽象类？

在了解抽象 Java 类之前，我们应该了解 Java 中的抽象。

抽象

在 Java 中，抽象是一种向用户隐藏实现细节的过程，并仅向用户提供功能。例如，当我们想在计算器中计算一些数据时，我们使用其按键，但不知道它是如何在内部工作的。

因此，当我们在任何类中使用抽象关键字时，该类称为抽象 Java 类。它仅向用户提供必要的内容，并隐藏内部过程。

抽象 Java 类可以有抽象方法和非抽象方法。如果一个类有一个抽象方法，则该类必须是抽象 Java 类。如果我们想使用抽象类，它必须被扩展并实现其方法。如果我们扩展一个抽象 Java 类，我们必须为其中的所有抽象方法提供实现。

完整程序如下所示。

abstract class AbstractClass {
    abstract void work();
}

步骤 1：首先，我们创建一个名为 Employee 的抽象 Java 类，其中声明一个名为 work() 的抽象方法。

步骤 2：其次，我们创建一个名为 WomanEmployee 的公共 Java 类，在其中访问方法 work()，其实现由 WomanEmployee 类给出。

public class AbstractClass2 extends AbstractClass{
    void work() {
            System.out.println("抽象类示例");
        }
        public static void main(String args[]) {
            AbstractClass p = new AbstractClass2();
            p.work();
        }
}

2) 什么是嵌套 Java 类？

Java 编程语言允许您在一个类内定义另一个类。我们使用嵌套类来将类和接口在一个地方进行逻辑分组。这可以提高可读性和可维护性，并且可以访问外部类的所有成员（公共、私有、受保护）。

语法

class OuterClass{
    ......
    class InnerClass{
        // 嵌套 Java 类
    }
}

嵌套类在 Java 中的优点

1. 嵌套 Java 类显示一种特殊类型的关系；它可以访问外部类的所有成员，包括私有成员。
2. 嵌套 Java 类主要用于使我们的程序更具可读性和可维护性，因为它将类和接口在一个地方进行逻辑分组。
3. 嵌套类需要写的代码更少。

嵌套类的类型

1. 非静态嵌套类
2. 静态嵌套类

非静态嵌套类在 Java 中也称为内部类。

Java 中的成员内部类

成员内部类是在类内部但在方法外部创建的。它是一个非静态内部类。在 Java 中创建内部成员类很简单。我们只需在类内编写一个类。内部类可以是私有的，一旦我们将内部类声明为私有，就无法从外部类的对象访问它。

语法

class Outer{
    class Inner {
        // 成员内部类
    }
}

完整程序如下所示。

public class MemberClassExample {
    private int data = 30;
    class MemberClassInner {
        void msg() {
            System.out.println("data is " + data);
        }
    }
    public static void main(String args[]) {
        MemberClassExample obj = new MemberClassExample();
        MemberClassExample.MemberClassInner in = obj.new MemberClassInner();
        in.msg();
    }
}

注意：在示例中，我们在内部成员类中创建了一个 display() 方法，它访问外部类的私有数据成员。

Java 中的匿名内部类

没有名称的类称为 Java 中的匿名内部类。它必须在我们需要覆盖类和接口的方法时使用。

我们可以同时声明和初始化它们。完整程序如下所示。

public class AnonoymousClassExample {
    public static void main(String[] args) {
        AnonoymousDemo a = new AnonoymousDemo() {
            public void message() {
                System.out.println("匿名内部类示例");
            }
        }; // 匿名类体在此关闭
        // a 包含匿名子类 AnonoymousClassExample 的对象。
        a.message();
    }
}
class AnonoymousDemo {
    public void message() {
        System.out.println("消息");
    }
}

Java 中的局部内部类

在方法内部创建的 Java 类称为局部内部类 Java；如果我们想调用局部内部类的方法，那么我们必须在方法内部初始化这个类。

完整程序如下所示。

public class LocalInnerClassExample {
    private int data = 30;
    void display() {
        class Local {
            void msg() {
                System.out.println(data);
            }
        }
        Local l = new Local();
        l.msg();
    }
    public static void main(String args[]) {
        LocalInnerClassExample obj = new LocalInnerClassExample();
        obj.display();
    }
}

Java 中的静态嵌套类

静态类不能访问非静态数据成员和方法。它可以访问外部类的静态成员，无论是私有、公共还是受保护的，并且只能通过外部类名称访问。当在另一个 Java 类内部创建静态类时，它称为静态嵌套类。

语法

class Outer{
    static NestedClass {
        // 静态嵌套类
    }
}

完整程序如下所示。

public class StaticNestedClassExample {
    static int age = 30;
    static class StaticClassAccess {
        void display() {
            System.out.println("员工年龄是 " + age);
        }
    }
    public static void main(String args[]) {
        StaticNestedClassExample.StaticClassAccess obj = new StaticNestedClassExample.StaticClassAccess();
        obj.display();
    }
}

3) 什么是最终类？

最终类在 Java 中是一个不可更改的类。它不能被扩展，也不能作为基类。使用最终类的主要目的是为了不让其他类继承它。

当我们不希望其他类继承时，我们将类声明为最终类；这是定义常量的好方法。完整程序如下所示。

final class FinalClassExample {
    void display() {
        System.out.println("最终类示例");
    }
}
// 编译时错误
class NewClass extends FinalClassExample { } // 无法扩展最终类

上面的代码会导致编译时错误，表示无法扩展最终类。

4) 什么是单例类？

单例类是设计模式中的一种模式，它确保一个类仅有一个实例，并提供全局访问。它主要用于控制对共享资源的访问。

完整程序如下所示。

class Singleton {
    private static Singleton instance = new Singleton(); // 唯一实例
    private Singleton() { } // 私有构造函数
    public static Singleton getInstance() {
        return instance;
    }
    public void display() {
        System.out.println("单例类示例");
    }
}
public class SingletonExample {
    public static void main(String args[]) {
        Singleton s = Singleton.getInstance();
        s.display();
    }
}

3) 最终 Java 类

当我们在任何类前使用 final 时，它被称为最终 Java 类。最终类不能被继承。如果任何类被声明为最终的，那么它的所有方法也隐式地被声明为最终的。

语法

final class <类名> {
    // 代码
}

完整程序如下：

final class FinalClassExample {
}
class Manager extends FinalClassExample {  // 编译时错误
    void work() {
        System.out.println("努力工作");
    }
    public static void main(String args[]) {
        Manager m1 = new Manager();
        m1.work();
    }
}

注意

在这个例子中，我们创建了一个名为 FinalClassExample 的最终 Java 类和另一个名为 Manager 的 Java 类。我们尝试继承这个最终类，但程序在编译时出现错误。

4) 单例 Java 类

在面向对象编程中，单例类是指在任何时候只能有一个对象的类。单例通常控制对资源的访问，例如数据库连接或套接字。其目的是创建一个对象的单一实例，这些对象在运行时创建成本高昂，并尽量重用同一个对象。这些对象主要是不可变的。

实现单例类需要遵循一些基本规则。

1. 构造函数应该是私有的。
2. 声明一个该类的静态变量对象。
3. 声明一个静态方法以返回实例。

完整程序如下。

步骤 1

首先，我们创建一个名为 SingletonClassExample 的单例类。

public class SingletonClassExample {
    private static SingletonClassExample singleton = new SingletonClassExample();
    public static SingletonClassExample getInstance() {
        return singleton;
    }
    protected static void demoMethod() {
        System.out.println("单例的 demoMethod");
    }
}

步骤 2

其次，我们创建一个名为 SingletonDemo 的公共类以访问单例类。

public class SingletonDemo {
    public static void main(String[] args) {
        SingletonClassExample tmp = SingletonClassExample.getInstance();
        tmp.demoMethod();
    }
}

总结

在本教程中，我们学习了各种 Java 类以及如何在 Java 程序中使用它们。

若你想提升Java技能，可关注我们的Java培训课程。