Java之static关键字

最新推荐文章于 2023-12-05 16:49:09 发布

LvLuffy

最新推荐文章于 2023-12-05 16:49:09 发布

阅读量278

点赞数 1

分类专栏： IT沉淀文章标签： java class

本文链接：https://blog.csdn.net/LvLuffy/article/details/77894575

版权

IT沉淀专栏收录该内容

21 篇文章 0 订阅

订阅专栏

Java开发之static关键字的讲解，废话不多说，直接上代码

一、模板类，里面包括：成员变量、静态变量、普通代码块、静态代码块、普通方法、静态方法、构造函数、静态内部类（包括：成员变量、静态变量、普通代码块、静态代码块、普通方法、静态方法、构造函数）。

package com.example;

public class Test1 {

    static int a = 10;
    static int b;
    int c = 50;
    int d;

    /**
     * 代码块
     */
    {
        System.out.println("{}:a = " + a);
        System.out.println("{}:b = " + b);
        System.out.println("{}:c = " + c);
        System.out.println("{}:d = " + d);
        a = 20;
        b = a + 10;
        c = b + 10;
        d = c + 10;
        System.out.println("{}:a = " + a);
        System.out.println("{}:b = " + b);
        System.out.println("{}:c = " + c);
        System.out.println("{}:d = " + d);
    }

    /**
     *静态代码块只能赋值和调用静态变量和静态方法
     */
    static {
        System.out.println("static{}:a = " + a);
        System.out.println("static{}:b = " + b);
        a = 60;
        b = a + 10;
        System.out.println("static{}:a = " + a);
        System.out.println("static{}:b = " + b);

        metherdStatic();
    }

    /**
     * 构造函数
     */
    public Test1() {
        System.out.println("Test1():a = " + a);
        System.out.println("Test1():b = " + b);
        System.out.println("Test1():c = " + c);
        System.out.println("Test1():d = " + d);
        a = 100;
        b = a + 10;
        c = b + 10;
        d = c + 10;
        System.out.println("Test1():a = " + a);
        System.out.println("Test1():b = " + b);
        System.out.println("Test1():c = " + c);
        System.out.println("Test1():d = " + d);
    }

    /**
     * 静态方法：只能赋值和调用静态变量和静态方法
     */
    static void metherdStatic() {
        System.out.println("metherdStatic():a = " + a);
        System.out.println("metherdStatic():b = " + b);
        a = 100;
        b = a + 10;
        System.out.println("metherdStatic():a = " + a);
        System.out.println("metherdStatic():b = " + b);
    }

    /**
     * 普通方法
     */
    void metherd() {
        System.out.println("metherd():a = " + a);
        System.out.println("metherd():b = " + b);
        System.out.println("metherd():c = " + c);
        System.out.println("metherd():d = " + d);
        a = 100;
        b = a + 10;
        c = b + 10;
        d = c + 10;
        System.out.println("metherd():a = " + a);
        System.out.println("metherd():b = " + b);
        System.out.println("metherd():c = " + c);
        System.out.println("metherd():d = " + d);
    }

    public static void main(String[] strings) {
        System.out.println("main():Test1");
    }

    public static class ClassStatic {
        static int e;
        int f = 10;

        /**
         * 代码块
         */
        {
            System.out.println("{}:e = " + e);
            System.out.println("{}:f = " + f);
            e = 20;
            f = e + 10;
            System.out.println("{}:e = " + e);
            System.out.println("{}:f = " + f);
        }

        /**
         * 静态代码块
         */
        static {
            System.out.println("static{}:e = " + e);
            e = 20;
            System.out.println("static{}:e = " + e);
        }

        /**
         * 静态方法
         */
        static void metherdStatic() {
            System.out.println("metherdStatic():e = " + e);
            e = 100;
            System.out.println("metherdStatic():e = " + e);
        }

        /**
         * 普通方法
         */
        void metherd() {
            System.out.println("metherd():e = " + e);
            System.out.println("metherd():f = " + f);
            e = 100;
            f = e + 10;
            System.out.println("metherd():e = " + e);
            System.out.println("metherd():f = " + f);
        }
    }
}

二、调用类

package com.example;

/**
 * Created by DELL on 2017/9/8.
 */

public class Test2 {

    public static void main(String[] strings) {
        /*---------------普通类---------------*/
        /*静态方法*/
        Test1.metherdStatic();

        /*静态变量*/
        System.out.println("Test1:a = " + Test1.a);
        System.out.println("Test1:b = " + Test1.b);

        /*创建实例*/
        Test1 test1 = new Test1();

        /*成员变量*/
        System.out.println("Test1:c = " + test1.c);
        System.out.println("Test1:d = " + test1.d);

        /*普通方法*/
        test1.metherd();

        /*---------------内部类---------------*/
        /*静态方法*/
        Test1.ClassStatic.metherdStatic();

        /*静态变量*/
        System.out.println("Test1.ClassStatic.e = " +        Test1.ClassStatic.e);

        /*创建实例*/
        Test1.ClassStatic classStatic = new Test1.ClassStatic();

        /*成员变量*/
        System.out.println("Test1.ClassStatic:f = " + classStatic.f);

        /*普通方法*/
        classStatic.metherd();
    }
}

三、打印结果

//静态代码块
static{}:a = 10
static{}:b = 0
static{}:a = 60
static{}:b = 70
//静态方法
metherdStatic():a = 60
metherdStatic():b = 70
metherdStatic():a = 100
metherdStatic():b = 110
//其他地方调用的静态方法
metherdStatic():a = 100
metherdStatic():b = 110
metherdStatic():a = 100
metherdStatic():b = 110
//其他地方调用的静态变量
Test1:a = 100
Test1:b = 110
//创建实例时，运行普通代码块
{}:a = 100
{}:b = 110
{}:c = 50
{}:d = 0
{}:a = 20
{}:b = 30
{}:c = 40
{}:d = 50
//创建实例时，运行构造函数
Test1():a = 20
Test1():b = 30
Test1():c = 40
Test1():d = 50
Test1():a = 100
Test1():b = 110
Test1():c = 120
Test1():d = 130
//其他地方调用的成员变量
Test1:c = 120
Test1:d = 130
//其他地方调用的普通方法
metherd():a = 100
metherd():b = 110
metherd():c = 120
metherd():d = 130
metherd():a = 100
metherd():b = 110
metherd():c = 120
metherd():d = 130
//内部类的静态代码块
static{}:e = 0
static{}:e = 20
//其他地方调用内部类的静态方法
metherdStatic():e = 20
metherdStatic():e = 100
//其他地方调用静态内部类的静态变量
Test1.ClassStatic.e = 100
//创建静态内部类实例时，运行普通代码块
{}:e = 100
{}:f = 10
{}:e = 20
{}:f = 30
//其他地方调用静态内部类的成员变量
Test1.ClassStatic:f = 30
//其他地方调用静态内部类的普通方法
metherd():e = 20
metherd():f = 30
metherd():e = 100
metherd():f = 110

四、总结

1，static修饰变量

按照是否静态的对类成员变量进行分类可分两种：
<1>被static修饰的变量，叫静态变量或类变量；
<2>没有被static修饰的变量，叫实例变量。

两者的区别：
<1>静态变量在内存中只有一个拷贝（节省内存），JVM之为静态分配一次内存，在类加载的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但这不是推荐的）。
<2>实例变量每创建一个实例，就会为实例变量分配一次内存，实例变量在内存有多个拷贝，互不影响（灵活）。

总结：一般在实现以下两个功能的时候可以使用静态变量
<1>在对象直接共享值时；
<2>方便访问变量时。

2、static修饰方法

按照是否静态的对类方法进行分类可分两种：
<1>被static修饰的方法，叫静态方法；
<2>没有被static修饰的变量，叫实例方法。

两者的区别：
<1>静态方法可以之间通过类名调用，任何实例对象也都可以调用；
<2>静态方法中不能有this和super关键字，也就意味着不能被覆盖重写；
<3>静态方法不能直接访问所属类的实例变量和实例方法，只能访问所属类的静态成员变量和静态方法；
<4>静态方法独立于任何实例，因此静态方法必须被实现，而不能是抽象的abstract。

3、static修饰代码块

按照是否静态的对类代码块进行分类可分两种：
<1>被static修饰的方法，叫静态代码块；
<2>没有被static修饰的变量，叫普通代码块。

两者的区别：
<1>静态代码块在类中独立于类成员的static语句体，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果静态代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
<2>静态代码块中只对静态变量赋值，或者调用，只能调用静态方法。

4、static修饰类

注意：static只能修饰内部类，不能修饰普通类；

按照是否静态的对类进行分类可分两种：
<1>被static修饰的方法，叫静态内部类；
<2>没有被static修饰的变量，叫内部类或普通类。

两者的区别：
<1>静态内部类中，可以有静态变量，和静态方法，当然也可有实例变量和实例方法；
<2>非静态的内部类中，不可以存在静态变量和静态方法。

下载地址：

https://download.csdn.net/download/lvluffy/10311236

LvLuffy

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java之static关键字

Java开发之static关键字的讲解，废话不多说，直接上代码一、模板类，里面包括：成员变量、静态变量、普通代码块、静态代码块、普通方法、静态方法、构造函数、静态内部类（包括：成员变量、静态变量、普通代码块、静态代码块、普通方法、静态方法、构造函数）。package com.example;public class Test1 { static int a = 10; static i
复制链接

扫一扫

专栏目录