Java基础之static关键字

最新推荐文章于 2024-09-10 10:21:38 发布

dudu5666

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量479

点赞数 19

文章标签： java 开发语言

本文链接：https://blog.csdn.net/dudu5666/article/details/141415462

版权

定义

static表示静态，是Java中的一个修饰符，可以修饰成员方法、成员变量。

Static修饰的代码属于类。

为什么设置【共享】

让类可以直接去调用某些方法、某些程序，因此方便类去使用自己的方法和变量。

static修饰代码块：在main方法运行之前运行，其目的是优化程序

如果方法和变量属于非静态的方法，他们只有在对象当中才会被分配空间，那么也就是只有对象才能调用。

因此可以用类名直接调用，比如A.run,A.flay，可以不用创建对象就使用。

当然也可以被对象调用，被对象共享

Static修饰成员变量【静态变量】

特点：

被该类所有对象共享

调用方式：

类名调用（推荐）

对象名调用

静态变量出现顺序

随着类的加载而加载，先于对象出现

package exercise1;

public class Person {
    public String name = "张三";

    public static String address = "保定";

    public String toString() {
        return name+" "+address;

    }
}

package exercise1;

public class Persontest {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.name="didi";
        p1.address="beijing";

        p2.name="dada";
        p2.address="shanghai";

        System.out.println(p1.toString());
        System.out.println(p2.toString());
    }
}

为所有对象所共享，也会被后面的覆盖。

Static修饰成员方法【静态方法】

特点

多用在测试类和工具类中
Javabean类中很少会用

调用方式

类名调用（推荐）

对象名调用

静态方法的可与不可

静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中没有this关键字

总而言之：

静态方法中，只能访问静态。
非静态方法可以访问所有。
静态方法中没有this关键字

如何让方法被main方法调用

在非静态方法上加入static关键字
在main方法当中创建对象，让对象调用该非静态方法

静态方法能够直接被main方法使用。非静态方法不能被被main方法使用

package exercise1;

public class Person {
    public String name = "张三";

    public static String address = "保定";

    public String toString() {
        return name+" "+address;

    }
}

修饰代码块

执行顺序练习1

static修饰的代码块在main方法运行之前运行，目的是优化程序执行

package exercise1;

public class Test extends Base {
    static {
        System.out.println("test static");
    }

    public Test() {
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new Test();
    }
}
class Base {
    static {
        System.out.println("base static");
    }
    public Base() {
                        System.out.println("base constructor");


                    }
                }

输出：

base static
test static
base constructor
test constructor

Process finished with exit code 0

执行顺序

程序执行先找main方法启动程序
首先先去扫描test类，发现TEst类有父类Base，发现base类没有父类。
将base.class加载进方法区，此时base类当中的static代码块执行
将Test.class加载进方法区，此时Test类在static代码块执行
main方法入栈---->执行new Test():去创建Test类的对象

创建子类对象之前先创建父类对象，所以先执行Base()构造器，在执行Test()构造器：

执行顺序2

package exercise1;

public class Demo {
    public Demo(String aa) {
        System.out.println("====" + aa);
    }

    static {
        System.out.println("11");
    }

    public static Demo demo =new Demo("+++");
    static {
        System.out.println("22");
    }
}

class Test {
        public static void main(String[] args) {
            Demo demo = new Demo("---");

        }
    }

输出

11
====+++
22
====---

*扫描--------->加载（编译）----------->运行

main方法在哪里我们就先去扫描那个类----》首先去扫描Test类，发现没有父类，也没有Static修饰的代码，那么编译Test类，并且将main方法入栈
执行new Demo(”----")；在执行之前扫描Dem类，发现没有父类，所以编译Demo类，在编译的过程中static代码块按顺序优先执行
首先输出的是11
执行public static Demo dem0=new Demo("+++")；此时会涉及到调用Demo构造方法，所以输出====+++
输出22
编译完毕，回到main方法当中继续执行new Dem0("----"):现在可以创建对象了！！也就是进行到了运行阶段
通过调佣构造器创建对象：===---

Java只有值的传递

局部变量和静态常量

package exercise1;

public class A {
    private static int a;

    public static void main(String[] args) {

        modify(a);
        System.out.println(a);
        System.out.println(a);
    }
        public static void modify ( int a){
            a=a++;
        }
}

package exercise1;

public class A {
    private int a;

    public static void main(String[] args) {
        A a1 = new A();
        modify(a1.a);
        System.out.println(a1.a);
    }

        public static int modify ( int a){
            return a++;
        }
}

输出：0