关键字--static

2301_80464285

已于 2023-11-18 09:54:19 修改

阅读量29

点赞数

文章标签： java 开发语言

于 2023-11-18 09:52:55 首次发布

本文链接：https://blog.csdn.net/2301_80464285/article/details/134320008

版权

一、static修饰成员变量

*叫静态，可以修饰成员变量，成员方法。
成员变量按照有无static修饰，分为两种：
1、类变量：有static修饰，属于类，在计算机中只有一份，会被类的全部对象共享。
2、实例变量（对象的变量）：无static修饰，属于每个对象的。

public class Student{
//类变量
static String name;

//实例变量（对象的变量）
int age;
}

*类变量可以用类名访问，也可以用对象访问
（1）、类名.类变量【推荐】
（2）、对象.类变量【不推荐】
*实例变量只能用对象访问
对象.实例变量


```java
package staticdemo1;

public class Test {
    public static void main(String[] args) {
        //目标：掌握有无static修饰成员变量的方法，特点
        //1、类变量的用法
        //类名.类变量（推荐）
        Student.name="小阮";
        System.out.println(Student.name);

        //对象名.类变量（不推荐）
        Student s1=new Student();
        s1.name="阮新宇";

        Student  s2=new Student();
        s2.name="刘林";

        System.out.println(s1.name);//刘林
        System.out.println(s2.name);//刘林

        //2、实用变量的用法，属于每个对象的变量
        //对象，实例变量（对象变量）
        s1.age=23;
        s2.age=18;
        System.out.println(s1.age);

        //System.out.println(Student.age);//报错

    }

}

package staticdemo1;

public class Student {
    //类变量
    static String name;
    //实例的变量
    int age;
}

二、类变量的应用场景

*在开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义成类变量来记住。
案例导学：
*系统启动后，要求用户类可以记住自己创建了多少个用户对象了。
在这里插入图片描述

package staticdemo1;

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


        //目标：通过案例理解类变量的应用场景
        User u1 = new User();
        User u2 = new User();
        User u3 = new User();
        User u4 = new User();
        System.out.println(User.number);

    }
}

package staticdemo1;

public class User {
    public static int number;
    public User(){
        //User.number++;
        //注意：在同一个类中访问自己类的类变量才可以省略类名不写
        number++;
    }
}

总结：
1、成员变量有几种？各自在什么情况下定义？
*类变量：数据只需要一份，且需要被共享（访问、修改）
*实例变量：每个对象都要有一份，数据个不同（如：name、score、age）
2、访问自己在类中的类变量，是否可以省略不写？
*可以
*注意：在某个类中访问其他类的类变量，必须带类名访问

三、static修饰成员方法

在这里插入图片描述

package staticmethod2;

public class Test {
    public static void main(String[] args) {
        //目标:掌握有无static修饰方法的用法
        //1、类方法的用法
        //类名.类方法（推荐）
       Student.printHelloWorld();

       //对象.类方法（不推荐）
        Student s=new Student();
        s.printHelloWorld();

        //2、实例方法的用法
        //对象.实例方法
        s.printPass();
        //Student.printPass();//报错

    }
}

package staticmethod2;

public class Student {

    double score;
    //类方法
    public static void printHelloWorld(){

        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
    }
    //实例方法
    public void printPass(){
        System.out.println("成绩："+(score>=60?"及格":"不及格"));

    }
}

在这里插入图片描述

四、static修饰成员方法的应用场景

类方法的常见应用场景
*类方法最常见的应用场景是做工具类。
工具类是什么？
*工具类中的方法都是一些类方法，每个类方法都是用来完成一个功能的，工具类是给开发人员公用使用的
使用类方法来设计工具类有啥好处？
*提高代码复用，调用方便，提高了开发效率

public class XxxxUtil{
	public Static void xxx(){
		...
	}
	public static boolean xxxx(String email){
		...
	}
	public static String xxxxx(int n){
		...
	}
	...
}

原先需要写两份或多份相同的代码现在只需要写一份类方法

package util3;

import java.util.Random;

public class myutil {
    public static String createCode(int n){
        //定义2个变量，一个是记住最终产生的随机验证码，一个是记住可能记住的字符
        String code="";
        String data="abcdefghigklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        Random r=new Random();
        //开始定义一个循环产生每位随机字符
        for (int i = 0; i <n; i++) {
            //随机一个字符范围内的索引
            int index=r.nextInt(data.length());
            //根据索引去全部字符中提取该字符
            code +=data.charAt(index);
        }
      return code;
    }
}

package util3;

import java.util.Random;

public class LoginDemo {
    public static void main(String[] args) {
        System.out.println(myutil.createCode(6));
    }
}

在这里插入图片描述

五、static的注意事项

1、类方法中可以直接访问类的成员，不可以直接访问实例成员
2、实例变量中既可以直接访问类成员，也可以直接访问实例成员
3、实例方法中可以出现this关键字，类方法中不可以出现this关键字

ackage attention4;

public class Student {
    static String schoolName;//类变量
    double score;//实例变量

    //1、类方法中可以直接访问类的成员，不可以直接访问实例成员
    public static void printHelloWorld(String[] args) {
        //注意：同一个类中，访问类成员，可以省略类名不写
        schoolName="钟离";
        printHelloWorld2();
        //不可以直接访问实例成员
        //System.out.println(score);//报错
        //printPass();//报错
        //System.out.println(this);//报错
    }
    //类方法
    public static void printHelloWorld2(){
    }
    //2、实例变量中既可以直接访问类成员，也可以直接访问实例成员
    //实例方法
    //3、实例方法中可以出现this关键字，类方法中不可以出现this关键字

    public void printPass(){
        schoolName="钟离2";
        printHelloWorld2();
        //也可以直接访问实例成员
        System.out.println(score);
        printPass2();
        System.out.println(this);
    }
    //实例方法
    public void printPass2(){
    }
}

六、static的应用知识：代码块

*代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类）。
代码块分为两种：
静态代码块：
格式：static{}
特点：类加载时自动执行也执行一次，所以静态代码块也执行一次。
作用：完成类的初始化，例如：对类变量的初始化赋值
实例代码块：
格式：{}
特点：每次创建对象时，执行实例代码块，并在构造器前执行
作用：和构造器一样，都是用来完成对象初始化的，例如：对实例变量进行初始化复制

package block;

import java.net.Socket;

public class Test {
    public static void main(String[] args) {
        //目标：认识两种代码块，了解他们的特点和基本作用
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);

        System.out.println(Student.schoolName);//凌华


        System.out.println("--------------------------------");
        Student s1=new Student();
        Student s2=new Student("张三");
    }
}

package block;

public class Student {
    static int number = 80;
    static String schoolName = "凌华";

    //静态代码块
    static {
        System.out.println("静态代码块执行了");
        //schoolName="凌华";
    }
    //实例代码块
    {
        System.out.println("实例代码块执行了");

        System.out.println("有人创建了对象：" + this);
    }
    public Student() {
        System.out.println("无参数构造器执行了");
    }
    public Student(String name) {
        System.out.println("有参数构造器执行了");
    }
}

七、static的应用知识：单例设计模式

什么是设计模式？
*一个问题通常有n种解法，其中肯定有一种是最优的，这个最优的解法被人总结出来了，称之为设计模式。
*设计模式有20多种，对应20多种软件开发中遇到的问题
关于设计模式的学习，主要学什么？
1、解决什么问题
2、怎么写
-----单例设计模式-----
（1）饿汉式单例模式
*确保一个类只有一个对象。
写法
*把类的构造器私有。
*定义一个类变量记住类的一个对象。
*定义一个类方法，返回对象

package singlelnstance;

public class A {
    //2、定义一个类变量记住类的一个对象
    private static A a=new A();
    //1、必须私有类的构造器`在这里插入代码片`
    private A(){
    }
    //3、定义一个类方法返回类的对象
    public static A getObject(){
        return a;
    }
}

package singlelnstance;

public class Test1 {
    public static void main(String[] args) {
        //目标：掌握单例设计模式的写法。
        A a1 = A.getObject();
        A a2 = A.getObject();
        System.out.println(a1);
        System.out.println(a2);

    }
}
//发现两次输出的地址相同

在这里插入图片描述
（2）懒汉式单例设计模式
*拿对象时，才开始创建对象
写法
*把类的构造器私有。
*定义一个类变量用于储存对象。
*提供一个类方法，保证返回的是同一对象。

package singlelnstance;

public class B {
    //2、定义一个类变量，用于存储这个类的一个对象。
    private static B b;
    //1、把类的构造器私有
    private B(){
    }
    //3、定义一个类方法，这个方法要保证第一次调用时才创建一个对象，后面调用时都会用这同一个对象返回。
    public static B getInstance() {
if (b==null){
    System.out.println("第一次创建对象~~");
    b=new B();
}

    return b;
    }
}

package singlelnstance;

public class Test2 {
    public static void main(String[] args) {
        B b1=B.getInstance();//第一次拿对象
        B b2=B.getInstance();
        B b3=B.getInstance();
        System.out.println(b1==b2);
    }
}