Java中的static和public关键字使用

最新推荐文章于 2024-04-27 17:30:34 发布

自闭小田

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量2.6k

点赞数 5

分类专栏： 2021spring_cs61b 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/weixin_43716412/article/details/130321727

版权

2021spring_cs61b 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

static关键字

在Java中，static关键字可以用来修饰类的成员变量、方法和代码块，它的作用是将这些成员标记为静态的，即与类相关而不是与类的实例相关。使用static关键字可以在不创建类的实例的情况下访问类的成员变量和方法。

以下是static关键字的用法：

静态变量

静态变量也称为类变量，它们属于类而不是属于任何特定的实例。使用static关键字声明的变量只有一个副本，无论创建多少个类的实例，它们都共享这个变量。静态变量可以通过类名直接访问，例如：

public class MyClass {
    public static int myStaticVariable = 10;
}

可以通过MyClass.myStaticVariable来访问myStaticVariable变量。

静态方法

静态方法属于类而不属于任何特定的实例。使用static关键字声明的方法可以在不创建类的实例的情况下调用。==静态方法只能访问静态变量和静态方法。==例如：

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

可以通过MyClass.myStaticMethod()来调用myStaticMethod方法。

静态代码块

静态代码块是在类被加载时执行的一段代码。它们只会被执行一次，并且在类的所有实例创建之前执行。静态代码块通常用于初始化静态变量或执行其他一次性的初始化任务。例如：

public class MyClass {
    static {
        System.out.println("This is a static code block.");
    }
}

在MyClass类加载时，静态代码块会被执行。

需要注意的是，静态成员变量、方法和代码块可以被类名直接访问，而不需要创建类的实例。因此，它们通常用于实现一些通用的功能，例如工具类中的静态方法，或者用于在整个应用程序中共享数据的静态变量。

非静态方法

非静态方法可以使用静态成员也可以使用非静态成员，因为静态成员属于类级别，而非静态方法是实例方法，可以访问类级别的静态成员。

在非静态方法中，可以直接访问类级别的静态成员变量和静态方法，不需要创建类的实例。例如：

public class MyClass {
    private int nonStaticVariable = 10;
    private static int staticVariable = 20;

    public void printVariables() {
        System.out.println("nonStaticVariable = " + nonStaticVariable);
        System.out.println("staticVariable = " + staticVariable);
    }
}

在上面的例子中，printVariables()是一个非静态方法，可以直接访问类级别的静态成员变量staticVariable。

需要注意的是，静态方法不能访问非静态成员，因为静态方法是在类级别上执行的，没有与任何实例相关联。如果需要访问非静态成员，可以通过将非静态成员作为参数传递给静态方法来实现。

静态内部类

在Java中，没有静态类的概念。静态关键字只能用于修饰类的成员变量、方法和代码块，而不能用于修饰整个类。一个类的定义始终是动态的，即使它没有任何实例，它也是一个动态的实体，可以被加载、实例化和调用。

但是，Java中有一种叫做静态内部类的概念。静态内部类是指在一个类中定义的嵌套类，它被声明为static时表示该嵌套类与其外部类的实例无关，可以在没有外部类实例的情况下直接创建。静态内部类与外部类的实例无关，因此静态内部类的实例可以在外部类实例化之前被创建。

以下是一个静态内部类的示例：

public class OuterClass {
    private static int outerStaticVariable = 10;

    public static class InnerClass {
        public void printOuterStaticVariable() {
            System.out.println("outerStaticVariable = " + outerStaticVariable);
        }
    }
}

在上面的示例中，InnerClass是一个静态内部类，它可以访问OuterClass中的静态变量outerStaticVariable，即使没有创建OuterClass的实例。可以使用以下代码创建InnerClass的实例：

public static void main(String[] args)  {
    OuterClass.InnerClass innerObj = new OuterClass.InnerClass();
    innerObj.printOuterStaticVariable(); // 输出 outerStaticVariable = 10}

需要注意的是，静态内部类与普通内部类有所不同，普通内部类不能声明为静态的，它们的实例必须与外部类的实例关联，并且只能通过外部类的实例来创建。

静态内部类可以使用外部类的静态成员，但不能使用外部类的非静态成员。

在静态内部类中，可以访问外部类中的静态成员变量和静态方法，因为静态成员属于类级别，而不是实例级别，所以它们与外部类的对象无关。例如：

public class OuterClass {
    private static int outerStaticVariable = 10;

    public static class InnerClass {
        public void printOuterStaticVariable() {
            System.out.println("outerStaticVariable = " + outerStaticVariable);
        }
    }
}

在上面的例子中，静态内部类InnerClass可以访问外部类OuterClass中的静态变量outerStaticVariable。

但是，静态内部类不能直接访问外部类的非静态成员变量和非静态方法。如果需要访问外部类的非静态成员，可以通过创建外部类的实例来访问。例如：

public class OuterClass {
    private int outerVariable = 10;

    public static class InnerClass {
        public void printOuterVariable(OuterClass outerObj) {
            System.out.println("outerVariable = " + outerObj.outerVariable);
        }
    }
}

在上面的例子中，静态内部类InnerClass可以通过传递OuterClass实例来访问外部类的非静态成员变量outerVariable。

非静态内部类（普通内部类，没有static关键字）

在Java中，普通内部类也称为成员内部类，它是定义在另一个类内部的类。与静态内部类不同，普通内部类的实例必须依赖于外部类的实例。

以下是一个普通内部类的示例：

public class OuterClass {
    private int outerVariable = 10;

    public class InnerClass {
        public void printOuterVariable() {
            System.out.println("outerVariable = " + outerVariable);
        }
    }
}

在上面的示例中，InnerClass是一个普通内部类，它可以访问OuterClass中的实例变量outerVariable，并且只能通过OuterClass的实例来创建。可以使用以下代码创建InnerClass的实例：

public static void main(String[] args)  {
    OuterClass outerObj = new OuterClass();
    OuterClass.InnerClass innerObj = outerObj.new InnerClass();
    innerObj.printOuterVariable(); // 输出 outerVariable = 10}

需要注意的是，普通内部类可以访问外部类的所有成员，包括私有成员。但是，外部类不能直接访问内部类的成员，必须通过内部类的实例来访问。InnerClass innerObj = outerObj.new InnerClass();内部类的实例化必须通过外部类对象

在Java中，OuterClass.this是内部类中引用外部类当前实例的一种方式。

当你在外部类中定义一个内部类时，内部类会隐式地引用外部类的实例。这个引用通常称为“外部this”或“封闭实例”。

为了在内部类中明确地引用外部实例，你可以使用OuterClass.this。例如，如果你在内部类中有一个方法需要访问外部类的字段或方法，你可以使用OuterClass.this.fieldName或OuterClass.this.methodName()来引用它们。

普通内部类的主要用途是在外部类中封装一些辅助功能，这些功能只在外部类中使用，并且不需要暴露给外部类的用户。普通内部类还可以实现一些接口，从而使外部类具有多态性。

普通内部类可以访问外部类的静态成员和非静态成员，包括静态变量、静态方法、非静态变量和非静态方法。

在普通内部类中，可以直接访问外部类的静态成员变量和静态方法，也可以通过外部类的实例访问非静态成员变量和非静态方法。例如：

public class OuterClass {
    private static int outerStaticVariable = 10;
    private int outerVariable = 20;

    public class InnerClass {
        public void printOuterVariables() {
            System.out.println("outerStaticVariable = " + outerStaticVariable);
            System.out.println("outerVariable = " + outerVariable);
        }
    }
}

在上面的例子中，普通内部类InnerClass可以直接访问外部类OuterClass中的静态变量outerStaticVariable，也可以通过访问OuterClass实例来访问非静态变量outerVariable。

需要注意的是，在普通内部类中，可以使用this关键字来引用当前内部类的实例，而通过OuterClass.this关键字可以引用外部类的实例。例如：

public class OuterClass {
    private static int outerStaticVariable = 10;
    private int outerVariable = 20;

    public class InnerClass {
        private int innerVariable = 30;

        public void printVariables() {
            System.out.println("outerStaticVariable = " + outerStaticVariable);
            System.out.println("outerVariable = " + outerVariable);
            System.out.println("innerVariable = " + innerVariable);
            System.out.println("this.innerVariable = " + this.innerVariable);
            System.out.println("OuterClass.this.outerVariable = " + OuterClass.this.outerVariable);
        }
    }
}

在上面的例子中，InnerClass中可以直接访问outerStaticVariable和outerVariable，也可以访问内部类中的成员变量innerVariable和this.innerVariable。同时，通过OuterClass.this.outerVariable可以访问外部类OuterClass中的非静态变量outerVariable。

另外：

Java中的main方法是静态方法。

在Java程序中，main方法是程序的入口点。它是一个特殊的静态方法，用于启动Java应用程序。因为main方法是静态的，所以它可以在程序启动时直接通过类名调用，而不需要创建类的实例。

main方法的定义通常如下所示：

public static void main(String[] args) {
    // 主程序逻辑
}

public关键字

Java中的public是一个访问修饰符，用来控制类、变量、方法和构造函数的访问范围。

使用public关键字修饰的类、变量、方法和构造函数可以被任何其他类访问，无论这些类是否在同一个包中。具体来说，public关键字表示以下内容：

public类：可以被其他任何类访问，无论这些类是否在同一个包中。如果一个类没有指定访问修饰符，则默认为包级别访问，只能被同一包中的其他类访问。
public变量：可以被其他任何类访问，无论这些类是否在同一个包中。如果一个变量没有指定访问修饰符，则默认为包级别访问，只能被同一包中的其他类访问。
public方法：可以被其他任何类访问，无论这些类是否在同一个包中。如果一个方法没有指定访问修饰符，则默认为包级别访问，只能被同一包中的其他类访问。
public构造函数：可以被其他任何类使用，无论这些类是否在同一个包中。如果一个构造函数没有指定访问修饰符，则默认为包级别访问，只能被同一包中的其他类使用。

需要注意的是，public关键字表示最大的访问权限，因此应该谨慎使用。在设计类和接口时，应该考虑最小化公共接口的数量，以便更好地控制类的使用和维护。

如果要在一个Java源文件中使用其他包中的public类、方法或变量，需要使用import语句将其导入当前文件中。

例如，假设有一个名为MyClass的类位于com.example包中，并且该类有一个public方法publicMethod()，如果要在另一个名为MainClass的类中使用该方法，可以使用以下import语句：

import com.example.MyClass;

public class MainClass {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.publicMethod();
    }
}

在这个例子中，我们通过import语句将com.example包中的MyClass类导入到MainClass类中。然后，在main()方法中创建一个MyClass对象，并调用其publicMethod()方法。

需要注意的是，只有public修饰的类、方法或变量才能从其它包中访问，并且在访问时需要指定完整的包名或使用import语句导入。如果类、方法或变量没有使用public修饰，则只能在同一个包中被访问。

如何在一个java源文件中用另一个包中的类：

使用public方法：如果另一个包中的类中的某个方法被声明为public，那么它就可以被其他包中的类访问。在访问该方法时，需要使用完整的包名来指定该类，例如：

com.example.package1.MyClass obj = new com.example.package1.MyClass();
obj.publicMethod();
```

在上面的代码中，我们创建了一个MyClass类的对象obj，并调用了其publicMethod方法。需要注意的是，如果要访问该方法，需要先将该方法的访问修饰符设置为public。

1中的方式需要每次使用完整的类名来指定类，比较繁琐，不太方便。import语句也可以用于在一个Java文件中访问另一个包中的类的方法。

在使用import语句时，需要在Java文件的开头添加import语句，指定要访问的类所在的包和类名。例如，如果要访问com.example.package1包中的MyClass类，可以使用以下语法：
```
import com.example.package1.MyClass;
```
在上面的语句中，我们使用import关键字导入了com.example.package1包中的MyClass类。这样，就可以在当前Java文件中直接使用MyClass类，而不需要每次都使用完整的包名来指定该类。

import com.example.package1.*;

在上面的代码中，我们使用通配符*来导入com.example.package1包下的所有类。这样，我们就可以在代码中直接使用这些类，而不需要每次都使用完整的类名来指定它们所在的包。需要注意的是，这种方式需要避免导入过多的类，以免导致代码不易维护。

在使用IntelliJ IDEA这样的Java IDE（集成开发环境）中，可以通过创建package来创建Java包。创建一个新的package实际上就是在文件系统中创建一个新的文件夹，用于存储Java源文件和类文件。

在IntelliJ IDEA中创建package可以通过以下步骤：

打开项目，选择一个Java源代码目录（例如src/main/java）。
在该目录上右键单击，选择“New” > “Package”。
在“Create New Package”对话框中，输入包名并选择父包（如果需要），然后单击“OK”按钮。

在创建package时，IntelliJ IDEA会自动在文件系统中创建一个对应的文件夹，并在其中添加一个空的package-info.java文件作为包的描述文件。在该包中创建的Java类将默认属于该包。

需要注意的是，包名应该使用小写字母，并使用点号（.）分隔各个级别。例如，com.example.myapp是一个有效的包名，而Com.Example.MyApp不是一个有效的包名。

在创建包后，可以在其中创建Java类、接口、枚举等，并使用import语句在其它类中引用该包中的类。这样，就可以更好地组织和管理Java代码，避免类名冲突，并提供访问控制。

其他访问修饰符

Java中，访问修饰符（Access Modifier）是用来控制类、变量、方法以及构造函数的访问范围和可见性的关键字。Java中有四种访问修饰符：

public：表示公共的，可以被任何类访问。
private：表示私有的，只能在本类中访问。
protected：表示受保护的，可以被本类、子类和同一包中的其他类访问。
默认访问修饰符（即不使用任何修饰符）：表示包访问权限，可以被本类和同一包中的其他类访问。

下面是访问修饰符的使用示例：

public class MyClass {
    public int publicVar; // 公共变量
    private int privateVar; // 私有变量
    protected int protectedVar; // 受保护变量
    int defaultVar; // 默认访问修饰符变量

    public void publicMethod() {
        // 公共方法
    }

    private void privateMethod() {
        // 私有方法
    }

    protected void protectedMethod() {
        // 受保护方法
    }

    void defaultMethod() {
        // 默认访问修饰符方法
    }
}

在上面的示例中，我们定义了一个名为MyClass的类，并使用了不同的访问修饰符来修饰类中的成员变量和成员方法。其中，public成员可以被任何类访问，private成员只能在本类中访问，protected成员可以被本类、子类和同一包中的其他类访问，default成员只能被本类和同一包中的其他类访问。

需要注意的是，访问修饰符可以用来控制类中的成员的访问范围和可见性，但也需要根据实际需求来合理使用，以提高代码的可读性和可维护性。

对于 private

在同一个Java源文件中，即使是不同的类，它们之间的访问权限仍然受到Java的访问控制规则的限制，私有成员只能在声明它们的类中访问，不能在其他类中直接访问。对于内部类和外部类之间的访问权限，如果内部类中有私有成员，那么外部类不能直接访问内部类中的私有成员，包括嵌套类中的私有成员。如果外部类需要访问内部类或嵌套类中的私有成员，可以通过内部类或嵌套类提供的公共方法或者访问器方法来间接地访问它们。

对于嵌套类来说，如果一个类是嵌套类，那么它可以访问它的外部类的私有成员，但是外部类不能直接访问嵌套类的私有成员。这是因为嵌套类在语法上是外部类的成员，因此具有访问外部类私有成员的权限，但是嵌套类的私有成员仍然不能被外部类直接访问。

在同一个Java文件中，如果有两个独立的类，它们可以互相访问对方的公共成员和受保护成员，但不能访问对方的私有成员。例如，如果有两个独立的类ClassA和ClassB，它们定义在同一个Java文件中，那么ClassA可以访问ClassB中的公共成员和受保护成员，但不能访问ClassB中的私有成员，反之亦然。

下面是一个例子，展示如何在同一个Java文件中定义两个独立的类，它们之间的访问权限：

// MyFile.java
public class ClassA {
    public int publicVar;
    protected int protectedVar;
    private int privateVar;

    // 构造函数、方法等
}

class ClassB {
    public int publicVar;
    protected int protectedVar;
    private int privateVar;

    // 构造函数、方法等
}

在上面的例子中，ClassA和ClassB是独立的类，它们之间没有任何嵌套关系。ClassA和ClassB中的成员变量publicVar和protectedVar是公共成员和受保护成员，可以在另一个类中访问。但是ClassA和ClassB中的成员变量privateVar是私有成员，不能在另一个类中直接访问。

自闭小田

关注

5
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
Java中的static和public关键字使用

在Java中，static关键字可以用来修饰类的成员变量、方法和代码块，它的作用是将这些成员标记为静态的，即与类相关而不是与类的实例相关。使用static关键字可以在不创建类的实例的情况下访问类的成员变量和方法。以下是static关键字的用法：静态变量也称为类变量，它们属于类而不是属于任何特定的实例。使用static关键字声明的变量只有一个副本，无论创建多少个类的实例，它们都共享这个变量。静态变量可以通过类名直接访问，例如：可以通过来访问变量。静态方法属于类而不属于任何特定的实例。使用static关键字声
复制链接

扫一扫