成都创新互联网站制作重庆分公司

JavaSE语法（7）——【static关键字、代码块】-创新互联

目录

专注于为中小企业提供网站建设、网站制作服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业高阳免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了超过千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

前言

✏️static关键字

1.static修饰成员变量

1.1 调用static修饰的成员变量

2. static修饰成员方法

3.static修饰的成员在内存中的位置

✏️代码块

1.普通代码块

2.构造代码块

3.静态代码块

前言

 我的JavaSE语法专栏地址👇，可以看看哦，可能你会有不一样的收获。​​​​​​​JavaSE_会飞的阿喵的博客-博客https://blog.csdn.net/che__dan/category_11970438.html?spm=1001.2014.3001.5482​​​​​​​​​​​​​​

JavaSE语法（6）——【类和对象（类的内存模型、访问限定符public、private等、包的导入……）】_虾料的博客-博客https://blog.csdn.net/Che__dan/article/details/127669373?spm=1001.2014.3001.5501      👆上一篇文章中static关键字还没有介绍，不过放心，本篇给大家介绍清楚。

✏️static关键字

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

1.static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量大的特性：不属于某个具体的对象，是所有对象所共享的。

  咱们先来看看案例：假如你是2022年级5班的一名同学。现在你有班级、姓名、性别、年龄这四种属性，同时你的同学也有这四种属性。我们是否就可以定义一个这样的类：

public class Student {
    String s_class;
    String name;
    String sex;
    int age;

    public Student(){

    }
    public Student(String s_class, String name, String sex, int age) {
        this.s_class = s_class;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public void print(){
        System.out.println("s_class: " + s_class + "name: " + name + " sex: " + sex + " age: " + age);
    }
}

  每一个同学的信息都可以实例化一个对象来表示。但是如果5班有60位同学，那么我们就需要对s_class赋值50次，且每次都是同一个值。那么我们这么解决这个问题？

我们可以把s_class变为一个静态的s_class：

public class Student {
    static String s_class;
    String name;
    String sex;
    int age;

    public Student(){

    }
    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    public void print(){
        System.out.println("s_class: " + s_class + "  name: " + name + "  sex: " + sex + "  age: " + age);
    }
}

  我们实例化几个对象，并对s_class进行赋值：

public class Main{
    public static void main(String[] args) {
        
        Student.s_class = "5班";
        Student s = new Student("小明","男",19);
        Student s2 = new Student("小花","男",20);
        Student s3 = new Student("李四","男",21);
        Student s4 = new Student("张三","男",20);

        s.print();
        s2.print();
        s3.print();
        s4.print();
    }
}

结果：

s_class: 5班  name: 小明  sex: 男  age: 19
s_class: 5班  name: 小花  sex: 男  age: 20
s_class: 5班  name: 李四  sex: 男  age: 21
s_class: 5班  name: 张三  sex: 男  age: 20

  这里的5班是这个类的属性，是每个实例对象所共有的，当s_class被修改了一次，那么对所有该类的对象都生效。

  上面的“Student.s_class”是什么意思呢？其实就是调用这个变量，具体的在👇。

1.1 调用static修饰的成员变量

static变量可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。

  • 通过类名访问
pubic class Main{
    public static void main(String[] args) {

        //通过类名访问并修改
        Student.s_class = "5班";

        Student s = new Student("小明","男",19);
        Student s2 = new Student("小花","男",20);
        Student s3 = new Student("李四","男",21);
        Student s4 = new Student("张三","男",20);
        s.print();
        s2.print();
        s3.print();
        s4.print();
    }
}
  • 通过对象访问
class Main{
    public static void main(String[] args) {

        //通过对象访问并修改
        Student s = new Student("小明","男",19);
        s.s_class = "5班";

        Student s2 = new Student("小花","男",20);
        Student s3 = new Student("李四","男",21);
        Student s4 = new Student("张三","男",20);
        s.print();
        s2.print();
        s3.print();
        s4.print();
    }
}

以上都是同一个结果。

s_class: 5班  name: 小明  sex: 男  age: 19
s_class: 5班  name: 小花  sex: 男  age: 20
s_class: 5班  name: 李四  sex: 男  age: 21
s_class: 5班  name: 张三  sex: 男  age: 20

总结：

  • 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
  • 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。
  • 类变量存储在方法区当中（具体的在文章后面）。

  • 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁）。
public class Student {
    static String s_class = "5班";
    //........
    //.......
    //.....
}

class Main{
    

    public static void main(String[] args) {
    //生命周期开始
        System.out.println(Student.s_class);

    }
    //生命周期结束
}

结果：5班

2. static修饰成员方法

  同样的道理，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的，其调用方法也是通过类名来调用（当然也可以用具体的对象来调用）。
  比如：

public class MyMath {
    public static int add(int a,int b){
        return a + b;
    }
}

///
public class Main3{
    public static void main(String[] args) {
        int c = 10;
        int d = 50;
        
        //用类名访问
        int sum = MyMath.add(c,d);
        System.out.println(sum);

        //用对象访问
        MyMath math = new MyMath();
        int sum2 = math.add(c,d);
        System.out.println(sum2);
    }
}


结果:
60
60

总结：

  • static方法不属于某一个具体的对象，而是类方法，是类本身所拥有的。
  • 可以通过对象调用，也可以通过 类名调用，更推荐使用后者。

  • 不能在静态方法中调用任何的非静态成员变量。

  原因很好理解：静态方法是属于整个类的，当class文件加载后就已经存在了；非静态变量要在进行实例化的时候才会创建，已经创建的方法引用未创建的变量，这当然不行。

  • 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用。

JavaSE语法（6）——【类和对象（类的内存模型、访问限定符public、private等、包的导入……）】_会飞的阿喵的博客-博客https://blog.csdn.net/Che__dan/article/details/127669373?spm=1001.2014.3001.5502        在上面的文章中提过在非静态方法中有一个隐藏的参数，即this引用，它是方法的第一个参数。

在静态方法中调用非静态方法时候，对于非静态方法我们肯定得要传入相应的this参数（非静态方法的第一个参数），然而事实是静态方法中无法传入this引用，所以我们无法对非静态方法进行传参。

 static方法还有一种用法：我们知道对类的属性进行封装时需要用private修饰符，并且需要相应的get与set方法来修改被封装的属性的值，如下：

public class Student {
    private static String s_class;
    private String name;
    private String sex;
    private int age;
    
    //获取s_class
    public static String getS_class() {
        return s_class;
    }
    //修改 s_class
    public static void setS_class(String s_class) {
        Student.s_class = s_class;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }


    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

}

  对于s_class字段我们不能用普通方法来对其操作，要用static方法才行。

3.static修饰的成员在内存中的位置

  类信息是装在方法区里，类信息又分为静态与非静态区。具体如下：

public class Cat{
    public String name;
    public String color;
    //猫的叫声
    public void meow() {
        System.out.println(color + "的" + name + ":喵喵喵~");
    }
    //.......

    
    //特征
    public static String trait = "有四条腿";
    //习性
    public static void habits(){
        System.out.println("喜欢吃鱼");
    }
}

///
public class Main{
    public static void main(String[] args) {
        Cat c = new Cat();
        c.name = "小白";
        c.color = "白色";
        c.meow();

        System.out.println(Cat.trait);
        Cat.habits();
    }
}

  这个例子在上一篇文章（JavaSE语法（6））中详细介绍过，我们这里只是加了一个静态区。

  static成员随着字节码文件的加载而被加载，当JVM将 Cat.class 加载进内存时静态成员变量就存在了，和字节码一样，位于一块叫做方法区的内存空间中，类成员变量被该类的所有对象所共享。

（ps：注意这里的内存图是jdk1.8之前版本的，之后的版本（包括1.8）静态成员在堆里（静态区在堆里））

                                                         （jdk1.8之前）

✏️代码块

  使用{}定义的一段代码称为代码块。代码块有四种：普通代码块、构造块、静态块、同步代码块，同步代码块是一种多线程保护机制。（ps：由于这个知识点涉及到多线程，这儿就不介绍了，留到多线程介绍。）

1.普通代码块

  定义在方法中的代码块叫普通代码块。

public class Main {
    public static void main(String[] args) {

        //普通代码块（在main方法中）
        {
            int x = 250;
            System.out.println("执行普通代码块！x = " + x);
        }
        int x = 100;
        System.out.println("我在普通代码块外面！x = " + x);
    }
}

结果：

执行普通代码块！x = 250
我在普通代码块外面！x = 100

普通代码块里的变量，只要出了代码块，其生命周期就结束了，所以这里重复定义x没有报错。

2.构造代码块

  在类中定义的代码块叫构造代码块，也叫实例代码块。它作用一般用于初始化类里的成员变量（静态的变量也能初始化，但不推荐）。

public class Student {
    private String name;
    private int age;
    private static String s_class;

    public Student (){
        System.out.println("我是Student的构造方法！！！");

    }

    //构造代码块（实例代码块）
    {
        
        this.name = "张三";
        this.age = 20;
        s_class = "5班";
        System.out.println("我是构造代码块（实例代码块）！！！");
    }

    public void print(){
        System.out.println("name:"+name+"age:" + age + "s_class:" + s_class);
    }
}

/

public class Main2{
    public static void main(String[] args) {
        Student student = new Student();
        student.print();
    }
}

结果：

我是构造代码块（实例代码块）！！！
我是Student的构造方法！！！
name:张三age:20s_class:5班

注意这里的执行顺序！这里的执行顺序是实例代码块先于构造方法 执行。

3.静态代码块

使用static定义的代码块称为静态代码块，一般用于初始化静态成员变量。

public class Student {
    private String name;
    private int age;
    public static String s_class;

    public Student (){
        System.out.println("我是Student的构造方法！！！");
    }

    //静态代码块
    static {
        s_class = "5班";
        System.out.println("我是静态代码块！！！");
    }

    //实例代码块
    {
        this.name = "张三";
        this.age = 20;
        System.out.println("我是构造代码块（实例代码块）！！！");
    }

    public void print(){
        System.out.println("name:"+name+"age:" + age + "s_class:" + s_class);
    }
}

/

public class Main2{
    public static void main(String[] args) {
        String str = Student.s_class;
        System.out.println(str);
    }
}

结果：

我是静态代码块！！！
5班
  • 可以看到，静态代码块在没有实例化对象时候也可以运行；而实例代码块只有在创建对象时才会执行。

那我new一个实例的时候呢？

public class Student {
    private String name;
    private int age;
    public static String s_class;
    
    //构造方法
    public Student (){
        System.out.println("我是Student的构造方法！！！");
    }

    //构造代码块（实例代码块）
    {
        this.name = "张三";
        this.age = 20;
        System.out.println("我是构造代码块（实例代码块）！！！");
    }

    //静态代码块
    static {
        s_class = "5班";
        System.out.println("我是静态代码块！！！");
    }

    public void print(){
        System.out.println("name:"+name+"age:" + age + "s_class:" + s_class);
    }
}

/
public class Main2{
    public static void main(String[] args) {
        Student student = new Student();
        student.print();
        System.out.println("#################################");
        Student student2 = new Student();
        student2.print();
    }
}

结果：

我是静态代码块！！！
我是构造代码块（实例代码块）！！！
我是Student的构造方法！！！
name:张三age:20s_class:5班
#################################
我是构造代码块（实例代码块）！！！
我是Student的构造方法！！！
name:张三age:20s_class:5班
  • 这里有一个很重要的点，即静态代码块在一个程序运行的时候只会执行一次！！！（不管生成多少个对象，静态代码块只会执行一次）
  • 在同一个类中，各种代码块之间的执行顺序是：静态代码块->实例代码块->构造方法。
  • 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)。 
public class Student {
    private String name;
    private int age;
    public static String s_class;

    //构造方法
    public Student (){
        System.out.println("我是Student的构造方法！！！");
    }

    //构造代码块（实例代码块）
    {
        this.name = "张三";
        this.age = 20;
        System.out.println("我是构造代码块（实例代码块）！！！");
    }

    //静态代码块
    static {
        System.out.println("我是静态代码块A！！！");
    }

    static {
        System.out.println("我是静态代码块B！！！");
    }

    static {
        System.out.println("我是静态代码块C！！！");
    }
    
}

/
class Main2{
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println("#################################");
        Student student2 = new Student();

    }
}

结果：

我是静态代码块A！！！
我是静态代码块B！！！
我是静态代码块C！！！
我是构造代码块（实例代码块）！！！
我是Student的构造方法！！！
#################################
我是构造代码块（实例代码块）！！！
我是Student的构造方法！！！

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧


网页题目：JavaSE语法（7）——【static关键字、代码块】-创新互联
文章来源：http://cxhlcq.com/article/dgoohd.html

其他资讯

全国免费咨询:

400-028-6601

业务咨询：028-86922220 / 13518219792

节假值班：18980820575 / 13518219792

联系地址：成都市太升南路288号锦天国际A幢1002号

Copyright © 成都创新互联科技有限公司重庆分公司 渝ICP备2021005571号
友情链接:： 成都网站建设 重庆网站建设 四川网站建设 重庆建设网站 移动服务器托管 成都服务器托管 云服务器 广告设计制作 重庆网页设计 重庆做网站 重庆网站制作 重庆网站建设 重庆网站公司 渝中网站制作 重庆网站设计

在线咨询

微信咨询

电话咨询

028-86922220（工作日）

18980820575（7×24）

提交需求

返回顶部