Java教程15—Java的static关键字静态变量静态块静态方法静态类

朴灿烈づ我的快乐病毒、 2022-05-14 11:41 198阅读 0赞

static关键字可以与类，变量， 方法，语句块一起使用。  
静态成员属于该类而不是特定实例，这意味着如果您将成员设为静态，则可以在不使用对象的情况下访问它。  
我们举一个例子来理解这个：

class SimpleStaticExample
    {
        // 这是个静态方法
        static void myMethod()
        {
            System.out.println("myMethod");
        }
    
        public static void main(String[] args)
        {
              /* 不用创建就可以调用该方法         
               */
               myMethod();
        }
    }

程序输出：

myMethod

这里我们有一个静态方法myMethod()，我们可以在没有任何对象的情况下调用它。  
如果我们删除static关键字并使其成为非静态关键字，那么我们必须创建一个类的对象实例才能调用它。

静态成员对于类的所有实例（对象）是公用的，但非静态成员对于每个类实例是独立的。

--------------------

## 静态块 ##

静态块用于初始化静态变量。  
当在内存中加载类时，将执行此块。  
一个类可以有多个静态块，它们将按照它们代码的写入程序的相同顺序执行。

示例1：单个静态块  
正如您所看到的，在我们在main方法中访问它们之前，两个静态变量都是初始化的。

class JavaExample{
        static int num;
        static String mystr;
        static{
        num = 97;
        mystr = "Static keyword in Java";
       }
        public static void main(String args[])
        {
            System.out.println("Value of num: "+num);
            System.out.println("Value of mystr: "+mystr);
        }
    }

程序输出：

Value of num: 97
    Value of mystr: Static keyword in Java

--------------------

示例2：多个静态块  
让我们看看多个静态块如何在Java中工作。  
它们以给定的顺序执行，这意味着第一个静态块在第二个静态块之前执行。  
这就是第一个块初始化的值被第二个块覆盖的原因。

class JavaExample2{
        static int num;
        static String mystr;
        //第一个静态块
        static{
            System.out.println("Static Block 1");
            num = 68;
            mystr = "Block1";
        }
        //第二个静态块
        static{
            System.out.println("Static Block 2");
            num = 98;
            mystr = "Block2";
        }
        public static void main(String args[])
        {
            System.out.println("Value of num: "+num);
            System.out.println("Value of mystr: "+mystr);
        }
    }

程序输出：

Static Block 1
        Static Block 2
        Value of num: 98
        Value of mystr: Block2

--------------------

## Java静态变量 ##

静态变量对于类的所有实例（或对象）是通用的，因为它是类级变量。  
换句话说，您可以说只创建了一个静态变量副本，并在该类的所有实例之间共享。  
这些变量的内存分配仅在类加载到内存中时才会发生一次。

几点重点：

*  静态变量也称为类变量。
 *  与非静态变量不同，可以在静态和非静态方法中直接访问此类变量。

示例1：可以在Static方法中直接访问静态变量  
在这里，我们有一个静态方法disp()和两个静态变量var1和var2。两个变量都可以在静态方法中直接访问：

class JavaExample3{
        static int var1;
        static String var2;
        //这是一个静态方法
        static void disp(){
            System.out.println("Var1 is: "+var1);
            System.out.println("Var2 is: "+var2);
        }
        public static void main(String args[])
        {
            disp();
        }
    }

程序输出：

Var1 is: 0
            Var2 is: null

--------------------

示例2：静态变量在类的所有实例之间共享  
在此示例中，String变量是非静态的，整数变量是静态的。  
正如您在输出中看到的那样，两个对象的非静态变量不同，但静态变量在它们之间共享。  
这就是对象对静态变量ob2所做的更改同时影响两个对象的原因。

class JavaExample{
        //静态整型变量
        static int var1=77;
        //非静态成员变量
        String var2;
    
        public static void main(String args[])
        {
            JavaExample ob1 = new JavaExample();
            JavaExample ob2 = new JavaExample();
            /* 静态变量可以不用任何类实例直接访问。
             * 为了演示静态变量是共享的，我正在使用对象访问它们
             * 我们可以通过一个对象检查对静态变量所做的更改，看是否用别的对象访问时有所变化。
             */
            //使用对象ob1将值分配给静态变量
            ob1.var1=88;
            ob1.var2="I'm Object1";
            /* 这将覆盖var1的值，
             * 因为var1在两个对象之间共享一个副本
             */
            ob2.var1=99;
            ob2.var2="I'm Object2";
            System.out.println("ob1 integer:"+ob1.var1);
            System.out.println("ob1 String:"+ob1.var2);
            System.out.println("ob2 integer:"+ob2.var1);
            System.out.println("ob2 STring:"+ob2.var2);
        }
    }

程序输出：

ob1 integer:99
    ob1 String:I'm Object1
    ob2 integer:99
    ob2 STring:I'm Object2

--------------------

## Java静态方法 ##

静态方法可以在不使用类的对象（实例）的情况下访问类变量（静态变量），但是只能使用对象访问非静态方法和非静态变量。  
可以在静态和非静态方法中直接访问静态方法。  
语法：  
static关键字后跟返回类型，后跟方法名称。

static return_type method_name();

示例1：静态方法main不用对象就可以访问静态变量

class JavaExample{
        static int i = 10;
        static String s = "Beginnersbook";
        // 静态方法
        public static void main(String args[])
        {
            System.out.println("i:"+i);
            System.out.println("s:"+s);
        }
    }

程序输出：

i:10
            s:Beginnersbook

--------------------

示例2：直接在静态和非静态方法中访问的静态方法

class JavaExample{
        static int i = 100;
        static String s = "Beginnersbook";
        //静态方法
        static void display()
        {
            System.out.println("i:"+i);
            System.out.println("i:"+s);
        }
    
        //非静态方法
        void funcn()
        {
            //调用静态方法
            display();
        }
        //静态方法
        public static void main(String args[])
        {
            JavaExample obj = new JavaExample();
            //需要一个对象才能调用非静态方法
            obj.funcn();
    
            //静态方法调用另一个静态方法
            display();
        }
    }

程序输出：

i:100
            i:Beginnersbook
            i:100
            i:Beginnersbook

--------------------

## 静态类 ##

只有当类是嵌套类时，才能使类成为静态类。

1、嵌套的静态类不需要引用外类  
2、静态类无法访问外部类的非静态成员  
我们将在一个例子的帮助下看到这两点：  
静态类例子

class JavaExample{
        private static String str = "BeginnersBook";
    
        //静态类
        static class MyNestedClass{
            //非静态类
            public void disp() {
            /*
             *如果你用了外部类的非静态str变量
             *然后你会得到编译错误
             *因为：嵌套的静态类无法访问外部类的非静态成员。
             */
                System.out.println(str);
            }
    
        }
        public static void main(String args[])
        {
            // 要创建静态嵌套类的实例，我们不需要外部类实例，但对于您需要的常规嵌套类还是要首先创建外部类的实例
            JavaExample.MyNestedClass obj = new JavaExample.MyNestedClass();
            obj.disp();
        }
    }

程序输出：

BeginnersBook

--------------------

原文地址：

https://beginnersbook.com/2013/04/java-static-class-block-methods-variables/