精华内容
下载资源
问答
  • java static
    千次阅读
    2021-12-12 14:03:25

    1、static目的 

    java中的static关键字主要用于内存管理。

    2、static范围

    使用范围:java static关键字可以用在变量、方法、代码块和嵌套类伤。

    作用范围:static关键字属于类,而不是类的实例。

    静态(static)修饰如下:

    1. 变量:称为类变量、静态变量
    2. 方法:称为类方法、静态方法
    3. 代码块:称为静态代码块
    4. 嵌套类:称为静态内部类

    3、静态变量

    类的成员变量可以分为以下两种:

    1. 静态变量(或称为类变量),指被 static 修饰的成员变量。
    2. 实例变量,指没有被 static 修饰的成员变量。

    静态变量与实例变量的区别如下:
    1)静态变量

    1. 运行时,Java 虚拟机只为静态变量分配一次内存,加载类过程中完成静态变量的内存分配。
    2. 在类的内部,可以在任何方法内直接访问静态变量。
    3. 在其他类中,可以通过类名访问该类中的静态变量。

    2)实例变量

    1. 每创建一个实例,Java 虚拟机就会为实例变量分配一次内存。
    2. 在类的内部,可以在非静态方法中直接访问实例变量。
    3. 在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

    静态变量在类中的作用如下:

    1. 静态变量可以被类的所有实例共享,因此静态变量可以作为实例之间的共享数据,增加实例之间的交互性。
    2. 如果类的所有实例都包含一个相同的常量属性,则可以把这个属性定义为静态常量类型,从而节省内存空间。例如,在类中定义一个静态常量 PI。

    静态变量的好处:它能使程序存储器高效(即它节省内存)。

    class Student8 {
        int rollno;
        String name;
        static String college = "ITS";
    
        Student8(int r, String n) {
            rollno = r;
            name = n;
        }
    
        void display() {
            System.out.println(rollno + " " + name + " " + college);
        }
    
        public static void main(String args[]) {
            Student8 s1 = new Student8(111, "Karan");
            Student8 s2 = new Student8(222, "Aryan");
    
            s1.display();
            s2.display();
        }
    }//原文出自【易百教程】,商业转载请联系作者获得授权,非商业请保留原文链接:https://www.yiibai.com/java/static-keyword-in-java.html
    
    

    4、静态方法

    同成员变量,成员方法也可以分为以下两种:

    1. 静态方法(或称为类方法),指被 static 修饰的成员方法。
    2. 实例方法,指没有被 static 修饰的成员方法。

    静态方法与实例方法的区别:

    1. 静态方法,属于类,而不属于类的对象。
      1)它通过类直接被调用,无需创建类的对象。
      2)静态方法中,不能使用 this 关键字,也不能直接访问所属类的实例变量和实例方法;
      3)静态方法中,可以直接访问所属类的静态变量和静态方法。
      4)同this 关键字,super 关键字也与类的实例相关,静态方法中不能使用 super 关键字。
    2. 实例方法,可直接访问所属类的静态变量、静态方法、实例变量和实例方法。

    静态方法与静态变量好处:

    1. 属于类级别,无需创建对象就即可直接使用,使用方便。

    2. 全局唯一,内存中唯一,静态变量可以唯一标识某些状态。

    3. 类加载时候初始化,常驻在内存,调用快捷方便。

    静态方法与静态变量缺点:

    1. 静态方法不能调用非静态的方法和变量。

    2.不能使用this和super关键字。

    静态方法与静态变量适用场景:

    1. 静态方法,最适合工具类中方法的定义;比如文件操作,日期处理方法等。

    2.静态方法,适合入口方法定义;比如单例模式,因从外部拿不到构造函数,所以定义一个静态的方法获取对象非常有必要。

    3.静态变量适合全局变量的定义;举例:用一个布尔型静态成员变量做控制标志。

    5、静态代码块

    定义:静态代码块,是 Java 类中的 static{ } 修饰的代码。

    作用:用于类初始化时,为类的静态变量赋初始值,提升程序性能。
    静态代码块的特点如下:

    1. 静态代码块,有点类似于一个方法,但不可以存在于任何方法体内。
    2. 静态代码块,可以置于类中的任何地方,类中可以有多个静态初始化块。 
    3. Java 虚拟机在加载类时执行,将只需要进行一次初始化的操作放在 static 代码块。
    4. 类中含多个静态代码块,Java虚拟机将按它们在类中出现的顺序依次执行,且都执行一次。
    5. 同静态代码块与静态,不能直接访问类的实例变量和实例方法,需通过类的对象访问。
    public class StaticCode {
        public static int count = 0;
        {
            count++;
            System.out.println("非静态代码块 count=" + count);
        }
        static {
            count++;
            System.out.println("静态代码块1 count=" + count);
        }
        static {
            count++;
            System.out.println("静态代码块2 count=" + count);
        }
    
        public static void main(String[] args) {
            System.out.println("*************** StaticCode1 执行 ***************");
            StaticCode sct1 = new StaticCode();
            System.out.println("*************** StaticCode2 执行 ***************");
            StaticCode sct2 = new StaticCode();
        }
    }

    6、静态类

     java中一个类要被声明为static的,只有一种情况,就是静态内部类(内嵌类)。如在外部类声明为static的,程序会编译都不会通过。

    1、静态内部类,跟静态方法一样,只能访问静态成员变量和方法,不能访问非静态方法和属性。

    2、普通内部类,可以访问任意外部类的成员变量和方法。

    3、静态内部类,可以声明普通成员变量和方法,而普通内部类不能声明static成员变量和方法。

    4、静态内部类,可以单独初始化。

    Inner i = new Outer.Inner();

     普通内部类初始化:

    Outer o = new Outer();
    Inner i = o.new Inner();

    适用场景:当外部类需要使用内部类,而内部类无需外部类资源,并且内部类可以单独创建时,考虑采用静态内部类的设计,在知道如何初始化静态内部类。

    public class Outer {
        private String name;
        private int age;
    
        public static class Builder {
            private String name;
            private int age;
    
            public Builder(int age) {
                this.age = age;
            }
    
            public Builder withName(String name) {
                this.name = name;
                return this;
            }
    
            public Builder withAge(int age) {
                this.age = age;
                return this;
            }
    
            public Outer build() {
                return new Outer(this);
            }
        }
    
        private Outer(Builder b) {
            this.age = b.age;
            this.name = b.name;
        }
    }

    静态内部类,调用外部类的构造函数来构造外部类;静态内部类可被单独初始化,于是在外部就可以有下面的实现:

    public Outer getOuter()
    {
        Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
        return outer;
    }

    静态类总结

    1.如果类的构造器或静态工厂中有多个参数,设计这样类时,最好使用Builder模式,特别是当大多数参数都是可选的时候。

    2.如果现在不能确定参数的个数,最好一开始就使用构建器即Builder模式。

    参考:

    Java static关键字(静态变量和静态方法)

    Java static关键字 -Java教程™

    Java静态类 - Facilitate - 博客园

    更多相关内容
  • Java static关键字详解

    万次阅读 多人点赞 2018-08-07 17:30:21
    static关键字 在类中,用static声明的成员变量为静态成员变量,也成为类变量。类变量的生命周期和类相同,在整个应用程序执行期间都有效。 这里要强调一下: static修饰的成员变量和方法,从属于类 普通变量和...

    static关键字

    在类中,用static声明的成员变量为静态成员变量,也成为类变量。类变量的生命周期和类相同,在整个应用程序执行期间都有效。

    这里要强调一下:

    • static修饰的成员变量和方法,从属于类

    • 普通变量和方法从属于对象

    • 静态方法不能调用非静态成员,编译会报错

    static关键字的用途

    一句话描述就是:方便在没有创建对象的情况下进行调用(方法/变量)。

    显然,被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问。

    static可以用来修饰类的成员方法、类的成员变量,另外也可以编写static代码块来优化程序性能

    static方法

    static方法也成为静态方法,由于静态方法不依赖于任何对象就可以直接访问,因此对于静态方法来说,是没有this的,因为不依附于任何对象,既然都没有对象,就谈不上this了,并且由于此特性,在静态方法中不能访问类的非静态成员变量和非静态方法,因为非静态成员变量和非静态方法都必须依赖于具体的对象才能被调用。

    虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员方法和静态成员变量。

    代码示例:

    这里写图片描述

    从上面代码里看出:

    • 静态方法test2()中调用非静态成员变量address,编译失败。这是因为,在编译期并没有对象生成,address变量根本就不存在。

    • 静态方法test2()中调用非静态方法test1(),编译失败。这是因为,编译器无法预知在非静态成员方法test1()中是否访问了非静态成员变量,所以也禁止在静态方法中调用非静态成员方法

    • 非静态成员方法test1()访问静态成员方法test2()/变量name是没有限制的

    所以,如果想在不创建对象的情况下调用某个方法,就可以将这个方法设置为static。最常见的静态方法就是main方法,这就是为什么main方法是静态方法就一目了然了,因为程序在执行main方法的时候没有创建任何对象,只有通过类名来访问。

    特别说明:static方法是属于类的,非实例对象,在JVM加载类时,就已经存在内存中,不会被虚拟机GC回收掉,这样内存负荷会很大,但是非static方法会在运行完毕后被虚拟机GC掉,减轻内存压力

    static变量

    static变量也称为静态变量,静态变量和非静态变量的区别:

    • 静态变量被所有对象共享,在内存中只有一个副本,在类初次加载的时候才会初始化

    • 非静态变量是对象所拥有的,在创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响

    static成员变量初始化顺序按照定义的顺序来进行初始化

    static块

    构造方法用于对象的初始化。静态初始化块,用于类的初始化操作。

    在静态初始化块中不能直接访问非staic成员。

    static块的作用

    静态初始化块的作用就是:提升程序性能。

    为什么说静态初始化块能提升程序性能,代码示例如下:

    class Person{
        private Date birthDate;
    
        public Person(Date birthDate) {
            this.birthDate = birthDate;
        }
    
        boolean isBornBoomer() {
            Date startDate = Date.valueOf("1946");
            Date endDate = Date.valueOf("1964");
            return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
        }
    }

    isBornBoomer是用来这个人是否是1946-1964年出生的,而每次isBornBoomer被调用的时候,都会生成startDate和birthDate两个对象,造成了空间浪费,如果改成这样效率会更好:

    class Person{
        private Date birthDate;
        private static Date startDate,endDate;
        static{
            startDate = Date.valueOf("1946");
            endDate = Date.valueOf("1964");
        }
    
        public Person(Date birthDate) {
            this.birthDate = birthDate;
        }
    
        boolean isBornBoomer() {
            return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
        }
    }

    因此,很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行

    静态初始化块可以置于类中的任何地方,类中可以有多个静态初始化块。
    在类初次被加载时,会按照静态初始化块的顺序来执行每个块,并且只会执行一次。

    static关键字的误区

    1. static关键字会改变类中成员的访问权限吗?

      有些初学的朋友会将java中的static与C/C++中的static关键字的功能混淆了。在这里只需要记住一点:与C/C++中的static不同,Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected(包括包访问权限)这几个关键字。看下面的例子就明白了:

      
      public class Person {
      
          public String name = "李四";
      
          private static String address = "中国";
      }

      图片

      说明static关键字不能改变变量和方法的访问权限

    2. 能通过this访问静态成员变量吗?

      public class Main {  
          static int value = 33;
      
          public static void main(String[] args) throws Exception{
              new Main().printValue();
          }
      
          private void printValue(){
              int value = 3;
              System.out.println(this.value);
          }
      }

      这段代码输出结果为:33

      this代表什么?this代表当前对象,那么通过new Main()来调用printValue的话,当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的,因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量,根本不可能与this关联,所以输出结果是33。在这里永远要记住一点:静态成员变量虽然独立于对象,但是不代表不可以通过对象去访问,所有的静态方法和静态变量都可以通过对象访问(只要访问权限足够)。

    3. static能作用于局部变量么?

      static是不允许用来修饰局部变量。不要问为什么,这是Java语法的规定

    static常见笔试面试题

    1、下面这段代码的输出结果是什么?

    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

    分析下这段代码的执行过程:

    • 找到main方法入口,main方法是程序入口,但在执行main方法之前,要先加载Test类

    • 加载Test类的时候,发现Test类继承Base类,于是先去加载Base类

    • 加载Base类的时候,发现Base类有static块,而是先执行static块,输出base static结果

    • Base类加载完成后,再去加载Test类,发现Test类也有static块,而是执行Test类中的static块,输出test static结果

    • Base类和Test类加载完成后,然后执行main方法中的new Test(),调用子类构造器之前会先调用父类构造器

    • 调用父类构造器,输出base constructor结果

    • 然后再调用子类构造器,输出test constructor结果

    2、这段代码的输出结果是什么?

    public class Test {
        Person person = new Person("Test");
        static{
            System.out.println("test static");
        }
    
        public Test() {
            System.out.println("test constructor");
        }
    
        public static void main(String[] args) {
            new MyClass();
        }
    }
    
    class Person{
        static{
            System.out.println("person static");
        }
        public Person(String str) {
            System.out.println("person "+str);
        }
    }
    
    
    class MyClass extends Test {
        Person person = new Person("MyClass");
        static{
            System.out.println("myclass static");
        }
    
        public MyClass() {
            System.out.println("myclass constructor");
        }
    }

    输出结果为:

    test static
    myclass static
    person static
    person Test
    test constructor
    person MyClass
    myclass constructor

    为什么输出结果是这样的?我们来分析下这段代码的执行过程:

    • 找到main方法入口,main方法是程序入口,但在执行main方法之前,要先加载Test类

    • 加载Test类的时候,发现Test类有static块,而是先执行static块,输出test static结果

    • 然后执行new MyClass(),执行此代码之前,先加载MyClass类,发现MyClass类继承Test类,而是要先加载Test类,Test类之前已加载

    • 加载MyClass类,发现MyClass类有static块,而是先执行static块,输出myclass static结果

    • 然后调用MyClass类的构造器生成对象,在生成对象前,需要先初始化父类Test的成员变量,而是执行Person person = new Person("Test")代码,发现Person类没有加载

    • 加载Person类,发现Person类有static块,而是先执行static块,输出person static结果

    • 接着执行Person构造器,输出person Test结果

    • 然后调用父类Test构造器,输出test constructor结果,这样就完成了父类Test的初始化了

    • 再初始化MyClass类成员变量,执行Person构造器,输出person MyClass结果

    • 最后调用MyClass类构造器,输出myclass constructor结果,这样就完成了MyClass类的初始化了

    3、这段代码的输出结果是什么?

    public class Test {
    
        static{
            System.out.println("test static 1");
        }
        public static void main(String[] args) {
    
        }
    
        static{
            System.out.println("test static 2");
        }
    }

    输出结果为:

    test static 1
    test static 2

    虽然在main方法中没有任何语句,但是还是会输出,原因上面已经讲述过了。另外,static块可以出现类中的任何地方(只要不是方法内部,记住,任何方法内部都不行),并且执行是按照static块的顺序执行的。

    展开全文
  • Java static关键字(超详细!)

    千次阅读 2021-04-11 18:26:02
    1.static static翻译为“静态” 所有static关键字修饰的都是类相关的,类级别的。 所有static修饰的,都是采用“类名.”的方式访问。 static修饰的变量:静态变量 static修饰的方法:静态方法 2.变量的分类: 变量...

    1.static

    1. static翻译为“静态”
    2. 所有static关键字修饰的都是类相关的类级别的。
    3. 所有static修饰的,都是采用“类名.”的方式访问。
    4. static修饰的变量静态变量
    5. static修饰的方法静态方法

    2.变量的分类:

    变量根据声明的位置进行划分:

    1. 方法体中声明的变量叫做:局部变量
    2. 方法体外声明的变量叫做:成员变量

    其中成员变量又可以分为:

    1. 实例变量
    2. 静态变量

    eg1.

    以下实例的,都是对象相关的,访问时采用 “引用.” 的方式访问。需要先new对象。

    实例相关的,必须先有对象,才能访问,可能会出现空指针异常。

    class Test{
    	// 成员变量中的实例变量
    	int i;
    
    	// 实例方法
    	public void m2(){
    		// 局部变量
    		int x = 200;
    	}
    }
    

    eg2.

    以下静态的,都是类相关的,访问时采用 “类名.” 的方式访问。不需要new对象。

    不需要对象的参与即可访问没有空指针异常的发生。

    class Test{
    	// 成员变量中的静态变量
    	static int k;
    
    	// 静态方法
    	public static void m1(){
    		// 局部变量
    		int m = 100;
    	}
    }
    

    3.什么时候变量声明为实例的,什么时候声明为静态的?

    如果这个类型的所有对象的某个属性值都是一样的,不建议定义为实例变量,浪费内存空间。
    建议定义为类级别特征,定义为静态变量,在方法区中只保留一份,节省内存开销。

    • 一个对象一份的是实例变量。
    • 所有对象一份的是静态变量。

    eg.

    class Chinese{
    
    	// 身份证号
    	// 每一个人的身份证号不同,所以身份证号应该是实例变量,一个对象一份。
    	String idCard; 
    
    	// 姓名
    	// 姓名也是一个人一个姓名,姓名也应该是实例变量。
    	String name;
    
    	// 国籍
    	String country;
    
    	// 无参数
    	public Chinese(){
    	
    	}
    
    	// 有参数
    	public Chinese(String s1,String s2, String s3){
    		idCard = s1;
    		name = s2;
    		country = s3;
    	}
    }
    
    class Chinese{
    
    	// 身份证号
    	// 每一个人的身份证号不同,所以身份证号应该是实例变量,一个对象一份。
    	String idCard; 
    
    	// 姓名
    	// 姓名也是一个人一个姓名,姓名也应该是实例变量。
    	String name;
    
    	// 国籍
    	// 重点重点五颗星:加static的变量叫做静态变量
    	static String country = "中国";
    
    	// 无参数
    	public Chinese(){
    	
    	}
    
    	// 有参数
    	public Chinese(String s1,String s2){
    		idCard = s1;
    		name = s2;
    	}
    }
    

    注意:

    1. 静态变量在类加载时初始化,不需要new对象,静态变量的空间就开出来了。
    2. 静态变量存储在方法区

    4.重点

    eg.

    public class StaticTest03{
    	public static void main(String[] args){	
    		// 通过"类名."的方式访问静态变量
    		System.out.println(Chinese.country);
    	
    		// 创建对象
    		Chinese c1 = new Chinese("1111111", "张三");
    		System.out.println(c1.idCard); // 1111111
    		System.out.println(c1.name); // 张三
    		System.out.println(c1.country); // 中国
    
    		// c1是空引用
    		c1 = null;
    		// 分析这里会不会出现空指针异常?
    		// 不会出现空指针异常。
    		// 因为静态变量不需要对象的存在。
    		// 实际上以下的代码在运行的时候,还是:System.out.println(Chinese.country);
    		System.out.println(c1.country);
    
    		// 这个会出现空指针异常,因为name是实例变量。
    		//System.out.println(c1.name);
    	}
    }
    
    class Chinese{
    
    	// 实例变量
    	String idCard;
    	String name;
    
    	// 静态变量
    	static String country = "中国";
    
    	//构造方法
    	public Chinese(String x, String y){
    		idCard = x;
    		name = y;
    	}
    }
    

    实例的:一定需要使用“引用.”来访问。

    Chinese c1 = new Chinese("1111111", "张三");
    System.out.println(c1.idCard); // 1111111
    System.out.println(c1.name); // 张三
    System.out.println(c1.country); // 中国
    

    静态的

    建议使用“类名.”来访问,但使用“引用.”也行(不建议使用"引用.")。

    静态的如果使用“引用.”来访问会让程序员产生困惑:程序员以为是实例的呢。

    // 通过"类名."的方式访问静态变量
    System.out.println(Chinese.country);
    
    System.out.println(c1.country)//这样也行
    

    注意:

    c1 = null;
    System.out.println(c1.country);
    

    这里不会出现空指针异常。因为静态变量不需要对象的存在。
    实际上以下的代码在运行的时候,还是:

    System.out.println(Chinese.country);
    

    结论:

    空指针异常只有在只有在“空引用”访问“实例”相关的,都会出现空指针异常。

    5.关于方法来说,什么时候定义为实例方法?什么时候定义为静态方法?

    1.思想角度:

    如果说该行为必须由对象去触发。那么该方法定义为实例方法。

    2.代码角度

    当这个方法体当中,直接访问了实例变量,这个方法一定是实例方法。

    我们以后开发中,大部分情况下,如果是工具类的话,工具类当中的方法
    一般都是静态的。(静态方法有一个优点,是不需要new对象,直接采用类名
    调用,极其方便。工具类就是为了方便,所以工具类中的方法一般都是static的。)

    展开全文
  • java static变量可以赋值吗?

    千次阅读 2021-03-17 13:01:37
    详细内容java static变量可以赋值吗?可以赋值的。static的主要作用是静态成员,指该变量的实例在内存中之存放一次。赋值是可以随便改的。javastatic关键字staticjava中非常重要的一个关键字,主要有两种作用:...

    详细内容

    8874ea6350d45b7c49bd3275106a4139.png

    java static变量可以赋值吗?

    可以赋值的。static的主要作用是静态成员,指该变量的实例在内存中之存放一次。赋值是可以随便改的。

    java中static关键字

    static是java中非常重要的一个关键字,主要有两种作用:

    ● 第一:为某特定数据类型或对象分配单一的存储空间,而与创建对象的个数无关。

    ● 第二:实现某个方法或属性与类而不是对象关联在一起

    简单来说,在Java语言中,static主要有5中使用情况:成员变量、成员方法、代码块,内部类和静态导包。

    基本用法:

    1、static修饰成员变量:该成员变量属于类变量,可以通过 ClassName.attributeName 直接引用,而不需要new出类的实例。

    2、static修饰成员方法:该方法属于类的方法,可以通过 ClassName.methodName 直接引用,而不需要new出类的实例。

    3、static修饰代码块:仅在类初始化的时候执行一次,且加载顺序是严格按照类中静态资源的定义顺序来加载的;静态代码块对于定义在它之后的静态变量,可以赋值,但是不能访问。;父类代码块->子类代码块。

    4、static修饰内部类:static不能修饰普通类,只能修饰内部类,被static修饰的内部类的创建方式: new OuterClass.InnerClass()。

    5、static导入包:语法“import static java.lang.Math.*”,这样在类中就可以直接使用Math类中的静态方法而不需要写类名,个人认为,在频繁使用某个类的时候比较方便,但是降低了可读性。并且不建议导入*

    推荐学习:Java视频教程

    展开全文
  • Java static关键字与static{}语句块

    万次阅读 多人点赞 2019-02-27 11:19:42
    二、 static的三个常用 1、 修饰成员变量 2、 修饰成员方法 3、 静态块(static{}) 一、 类的加载特性与时机 在进入static之前,先补一下关于类的脑。 1、 类加载的特性 在JVM的生命周期里,每个类只会被...
  • Java static修饰方法

    千次阅读 2017-04-24 23:29:09
    一、static 修饰方法 1、与静态变量一样,我们也可以使用 static 修饰方法,称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。调用静态方法可通过类名访问或者对象方法。 例如:public class ...
  • Java static变量保存在哪?

    万次阅读 多人点赞 2018-07-28 13:28:39
    java -version java version &amp;amp;amp;amp;quot;1.8.0_171&amp;amp;amp;amp;quot; Java(TM) SE Runtime Environment (build 1.8.0_171-b11) Java HotSpot(TM) 64-Bit Server VM (build 25.171-b11, ...
  • static可以修饰的对象 方法 成员变量 代码块 独立于类 在类的加载的时候执行,并且只执行一次 ...DBManager.java public class DBManager { private static String driver=""; private static String url=""; priv
  • 缓存存起来,定时重置缓存,使用公司内部缓存工具可以做到设置超时时间如果缓存为空则调用接口且重新为缓存赋值,但缓存失效时总会存在需要直接访问接口而导致访问太慢,所以我想是不是可以用static对数据做内存缓存...
  • 一个方法用static修饰,便是静态方法或类...所以,在static方法内部无法直接调用非static方法(可以通过先实例化对象,再用该对象调用非static方法),但非static方法中可以调用static方法,通过类.方法名()的方式。
  • 深度理解Java中的static

    千次阅读 多人点赞 2021-02-22 21:44:14
    static可以用来修饰类的成员方法、类的成员变量、类中的内部类(以及用static修饰的内部类中的变量、方法、内部类),另外可以编写static代码块来优化程序性能。 作用: 方便在没有创建对象的情况下来进行调用...
  • import java.io.*; import java.util.*;... public static void main(String args[]) throws Exception{ f(); } boolean f() { return true; } } 上述代码IDE报错:Cannot make a sta...
  • Java static(三) - 静态代码块

    千次阅读 2022-01-05 14:07:16
    static代码块也叫静态代码块,是在类中独立于类成员的static语句块,可以有多个,位置可以随便放,它不在任何的方法体内 JVM加载类时会执行这些静态代码块,如果static代码块有多个,JVM将按照它们在类中出现的先后...
  • Static方法在类加载时就已经存在了(JAVA虚拟机初始化时), 但是对象是在创建时才在内存中生成。而this指代的是当前的对象。   参考:https://zhidao.baidu.com/question/205972833.html...
  • Javastatic的含义和用法

    万次阅读 2021-02-12 11:55:35
    static:静态的,用于修饰成员(成员变量,成员方法);1.被static所修饰的变量或者方法会储存在数据共享区;2.被static修饰后的成员变量只有一份!3.当成员被static修饰之后,就多了一种访问方式,除了可以被对象调用...
  • JAVA static是什么?修饰符总结整理

    千次阅读 2018-08-20 20:10:42
    JAVA中修饰符的总结整理,尤其是static的理解,static总是忘记 其他修饰符修饰的变量有效范围如下:   类内 package内 子类 其他package private yes no no no default yes ...
  • javastatic什么意思

    千次阅读 2021-02-12 11:55:35
    java中,static表示“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,或者进行静态导包。static的特点:1、随着类的加载而被加载;2、优先于对象存在;3、被所有对象共享。Java是一种面向...
  • Javastatic的作用

    千次阅读 2020-10-25 16:24:54
    Javastatic是一个使用频率很高的关键字,今天总结一下static的用法。 static关键字主要有两种作用: ①、为某特定数据类型或对象分配单一的存储空间,而与创建对象的个数无关。 ②、实现某个方法或属性与类而不是...
  • javastatic修饰成员变量

    千次阅读 2022-03-10 14:48:39
    static: 静态的, 它是成员修饰符,可以修饰成员内容,不可以修饰局部 修饰成员变量--> 静态变量+类变量; 修饰方法 --> 静态方法+类方法 修饰块 修饰类 static修饰的成员变量与成员方法使用方式: 1...
  • javastatic的用法

    千次阅读 2021-04-17 19:54:16
    javastatic的用法
  • Java static 修饰符的理解

    千次阅读 2020-04-04 10:38:21
    static 修饰的变量,方法,代码块 只有变量和代码块会在类加载时就初始化 而static方法只要在被调用时才执行(里面的变量也只有这时候才初始化)。 但是,一般不常用的方法还是不建议用static 因为,系统启动后,...
  • java static方法的线程安全性

    千次阅读 2013-08-01 08:18:50
    本人曰:刚学java、jsp不久,对static变量倒是有所理解,但是,对static方法理解不够清楚,看完这篇文章,觉得还是讲的蛮清晰的,所以转载来备忘,也和大家一起分享学习之。 ~~~~~~~~~~~~~以下转载~~~~~~~~~~~~~~~~~...
  • Java基础知识——static和final

    千次阅读 2022-04-02 15:09:53
    一、static 1. static修饰变量: static修饰的变量属于静态变量,随着类加载直接分配内存,与实例对象无关,所有类共用静态变量(需要考虑作用域,private、public之类); 2. static修饰函数: static修饰的函数...
  • Java中的Static静态方法

    千次阅读 2022-01-23 15:54:09
    与静态变量相似,用static修饰符修饰的方法属于类的静态方法,又称为类方法。静态方法的实质是属于整个类的方法,而不加static修饰的方法是属于某个具体对象的方法。 一个方法生声明为static有以下几重含义: 非...
  • Java中的static的使用指南

    千次阅读 2021-03-09 18:03:19
    一、Java中的static使用之静态变量1.Java 中被static修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享、且优先于对象存在。静态成员可以使用类名直接访问,也可以...
  • 文章目录前言原题static简介使用String== 与 equals()常量与非常量intern()JAVA 源码native 源码使用后记 前言 跟同学在讨论 JAVA 期末试题时,对于一些 static 和 String 在对象中的使用方法,若有所思,特此记录...
  • JavaStatic代码块与构造方法的初始化顺序是怎么样的呢? 举个例子,也是笔试题常考的一类题目。三个Class,分别是ClassA,ClassB,ClassC,其中B继承自A,C继承自B。public class ClassA { static{ System.out....
  • java和jvm static的用法和例子 简析java类加载机制 为何javastatic静态数据无法访问非static数据,但是反过来却可以1.static用法和解析类中
  • Java static 静态方法 并发(是否线程安全) 1 2 3 4 5 6 7 public class TestUitl {  public static User setName(User user,String ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,313,067
精华内容 2,125,226
关键字:

java static