精华内容
下载资源
问答
  • Static用法

    千次阅读 2021-03-19 15:29:53
    1.1、Static是一个修饰符,用于修饰类的成员方法、类的成员变量,另外编写static代码块来优化程序性能。 1.1.1、static 修饰变量 被static修饰的成员变量属于类,不属于某个对象(当有多个对象访问或者修改的成员...

    一、Static 关键字
    1.1、Static是一个修饰符,用于修饰类的成员方法、类的成员变量,另外编写static代码块来优化程序性能。
    1.1.1、static 修饰变量
    被static修饰的成员变量属于类,不属于某个对象(当有多个对象访问或者修改的成员变量时,其中一个对象将static成员变量进行修改,其它的对象的static成员变量值跟着改变)
    被static修饰的成员变量也可以通过类名来访问

    public class ReviewStatic
    {
     public static void main(String[] args) 
     {
      Cup cup1=new Cup("25");
      Cup cup2=new Cup("30");
      
      cup1.name="保温杯";
      cup2.name="塑料杯";
      
      System.out.println(cup1.name+"\t"+cup1.temperature);
      System.out.println(cup2.name+"\t"+cup2.temperature);
     }
    }
    class Cup
    {
     public static String name=null;//即类共有,只要一个对象修改 都会跟着变
     public String temperature=null;
     public Cup(String temperature) 
     {
      this.temperature=temperature;
     }
    }

    塑料杯 25
    塑料杯 30

    1.1.2、static修饰方法:
    static 修饰的方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都必须依赖具体的对象才能够被调用。但是要注意的是,虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员变量的和方法
    
    class Cup
    {
     public static String name=null;
     public String temperature=null;
     public Cup(String temperature) 
     {
      this.temperature=temperature;
     }
     
     public static void PrintText() 
     {
      **temperature="30";**/编译器会报错 静态方法只能访问静态成员
    
     }
    }
    class Cup
    {
     public static String name=null;
     public String temperature=null;
     public Cup(String temperature) 
     {
      this.temperature=temperature;
     }
     
     public static void PrintText() 
     {
      name="玻璃杯";
     }
    }

    非静态方法可以访问静态成员变量,和非静态成员变量

    class Cup
    {
     public static String name=null;
     public String temperature=null;
     public Cup(String temperature) 
     {
      this.temperature=temperature;
     }
     
     public void set() 
     {
      name="玻璃杯";
      temperature="45";
     }
     
     
    }
    展开全文
  • C++ static 用法总结

    2011-08-23 21:22:58
    C++ static 用法总结C++ static 用法总结
  • static用法小结

    2010-02-23 22:15:15
    C语言 static 用法 小结 C语言 static 用法 小结
  • Java之static用法

    2013-08-13 00:16:54
    Java之static用法 在Java语言中,static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块
  • c语言static用法总结

    2011-07-18 16:17:25
    c语言static用法总结,精炼地介绍了static的用法。简单易懂,适合初学者参考。
  • c语言中static用法总结.pdf
  • static用法详解

    2017-07-12 13:53:00
    如果一个类成员被声明为static,它就能够在类的任何对象创建之前被访问,而不必引用任何对象。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ,所以它被声明为static。  声明为static...

      如果一个类成员被声明为static,它就能够在类的任何对象创建之前被访问,而不必引用任何对象。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ,所以它被声明为static。
      声明为static的变量实质上就是全局变量。当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例变量共用同一个static变量,例如:声明一个static的变量count作为new一个类实例的计数。声明为static的方法有以下几条限制:
      1、它们仅能调用其他的static 方法。
      2、它们只能访问static数据。
      3、它们不能以任何方式引用this 或super。
      如果你需要通过计算来初始化你的static变量,你可以声明一个static块,Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块:
      

    public class UserStatic {  
            static int a = 3;  
            static int b;    
            static void meth(int x) {  
                System.out.println("x = " + x);  
                System.out.println("a = " + a);  
                System.out.println("b = " + b);    
            }   
            static {  
                System.out.println("Static block initialized.");  
                b = a * 4;    
            }   
            public static void main(String args[]) {  
                meth(42);   
            }  
        }

      一旦UseStatic 类被装载,所有的static语句被运行。首先,a被设置为3,接着static 块执行(打印一条消息),最后,b被初始化为a*4 或12。然后调用main(),main() 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。
      注意:在一个static 方法中引用任何实例变量都是非法的。
      在定义它们的类的外面,static 方法和变量能独立于任何对象而被使用。这样,你只要在类的名字后面加点号(.)运算符即可。例如,如果你希望从类外面调用一个static方法,你可以使用下面通用的格式:
         classname.method( )
      这里,classname 是类的名字,在该类中定义static方法。可以看到,这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。
      总结:
      1、static成员是不能被其所在class创建的实例访问的。
      2、如果不加static修饰的成员是对象成员,也就是归每个对象所有的。
      3、加static修饰的成员是类成员,就是可以由一个类直接调用,为所有对象共有的。
      Java Static:作为修饰符, 可以用来修饰变量、方法、代码块(但绝对不能修饰类)。

      1、修饰变量:
      类的所有对象共同拥有的一个属性,也称为类变量。这类似于C语言中的全局变量。类变量在类加载的时候初始化,而且只被初始化一次。在程序中任何对象对静态变量做修改,其他对象看到的是修改后的值。因此类变量可以用作计数器。另外,java Static变量可以用类名直接访问,而不必需要对象。
      2、修饰方法:
      类的所有对象共同拥有的一个功能,称为静态方法。静态方法也可以用类名直接访问,而不必需要对象。所以在静态方法里不能直接访问非静态变量和非静态方法,在Static方法里不能出现this或者super等关键字。
      3、修饰Java代码块:
    用static去修饰类里面的一个独立的代码块,称为静态代码块。静态代码块在类第一次被加载的时候执行,而且只执行一次。静态代码块没有名字,因此不能显式调用,而只有在类加载的时候由虚拟机来调用。它主要用来完成一些初始化操作。
      4、说说类加载:
      JVM在第一次使用一个类时,会到classpath所指定的路径里去找这个类所对应的字节码文件, 并读进JVM保存起来,这个过程称之为类加载。
      
      可见,无论是变量,方法,还是代码块,只要用static修饰,就是在类被加载时就已经”准备好了”,也就是可以被使用或者已经被执行。都可以脱离对象而执行。反之,如果没有static,则必须通过对象来访问。

    展开全文
  • java Static 用法

    2011-07-20 17:01:35
    java Static 用法注:static成员变量的生存周期为程序运行开始到程序运行结束。。这就意味着你并不需要去初始化或者管理这些变量,随时拿来用即可,另外一方面,如果定义了过多的静态变量的话,会占用大量内存造成...
    
    

    java Static 用法


    注:static成员变量的生存周期为程序运行开始到程序运行结束。。



    这就意味着你并不需要去初始化或者管理这些变量,随时拿来用即可,另外一方面,如果定义了过多的静态变量的话,会占用大量内存造成浪费,所以不要过多使用静态成员变量



    有时你希望定义一个类成员,使它的使用完全独立于该类的任何对象。通常情况下,类成员必须通过它的类的对象访问,但是可以创建这样一个成员,它能够被它自己使用,而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static,它就能够在它的类的任何对象创建之前被访问,而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ,所以它被声明为static。

    声明为static的变量实质上就是全局变量。当声明一个对象时,并不产生static变量的拷贝,而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制:
    ·
    它们仅能调用其他的static 方法。
    ·
    它们只能访问static数据。
    ·
    它们不能以任何方式引用this 或super(关键字super 与继承有关,在下一章中描述)。
    如果你需要通过计算来初始化你的static变量,你可以声明一个static块,Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法,一些static变量,以及一个static 初始化块:
    // Demonstrate static variables,methods,and blocks.

    class UseStatic {
    static int a = 3;
    static int b;


    static void meth(int x) {
    System.out.println("x = " + x);
    System.out.println("a = " + a);
    System.out.println("b = " + b);


    }

    static {
    System.out.println("Static block initialized.");
    b = a * 4;


    }

    public static void main(String args[]) {
    meth(42);
    }
    }


    一旦UseStatic 类被装载,所有的static语句被运行。首先,a被设置为3,接着static 块执行(打印一条消息),最后,b被初始化为a*4 或12。然后调用main(),main() 调用meth() ,把值42传递给x。3个println ( ) 语句引用两个static变量a和b,以及局部变量x 。

    注意:在一个static 方法中引用任何实例变量都是非法的。

    下面是该程序的输出:

    Static block initialized.
    x = 42
    a = 3
    b = 12
    在定义它们的类的外面,static 方法和变量能独立于任何对象而被使用。这样,你只要在类的名字后面加点号运算符即可。例如,如果你希望从类外面调用一个static方法,你可以使用下面通用的格式:

    classname.method( )

    这里,classname 是类的名字,在该类中定义static方法。可以看到,这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

    下面是一个例子。在main() 中,static方法callme() 和static 变量b在它们的类之外被访问。

    class StaticDemo {
    static int a = 42;
    static int b = 99;
    static void callme() {


    System.out.println("a = " + a);
    }
    }


    class StaticByName {

    public static void main(String args[]) {
    StaticDemo.callme();
    System.out.println("b = " + StaticDemo.b);


    }
    }

    下面是该程序的输出:

    a = 42
    b = 99
    解释的很透彻,还想补充点,就是static成员是不能被其所在class创建的实例访问的。Example: Class MyClass { public static str = "this is for test purpose"; } MyClass instanceClass = new MyClass(); Console.WriteLine(MyClass.str); // Runs well Console.WriteLine(instanceClass.str); // Error,lack of accessor
     
    通俗点的解释如下:

    1。如果不加static修饰的成员是对象成员,也就是归每个对象所有的。

    2。加static修饰的成员是类成员,就是可以由一个类直接调用,为所有对象共有的
    展开全文
  • c语言中static使用方法

    2011-03-22 22:21:43
    c语言 static 所有用法,菜鸟必看
  • C语言中static用法大全

    2011-11-01 18:13:37
    详细讲解C语言中static用法 掌握static的各种使用场合
  • c++ static用法,全局变量,与别的语言不一样.pdf
  • java中静态代码块的用法 static用法详解 一java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不...
  • java中Static用法

    千次阅读 2019-11-01 15:45:36
    Java关键字static静态修饰符,可能大家都很熟悉,具体有什么用法? 当我们通过new关键字去创建对象的时候,那么数据的存储空间才会被分配,类中的成员方法才能被对象所使用。但是呢有两种特殊的情况: 1、我们通过...

    Java关键字static静态修饰符,可能大家都很熟悉,具体有什么用法?

    当我们通过new关键字去创建对象的时候,那么数据的存储空间才会被分配,类中的成员方法才能被对象所使用。但是呢有两种特殊的情况:
    1、我们通过new关键字创建的对象共享同一个资源,而不是说每个对象都拥有自己的数据,或者说根本就不需要去创建对象,这个资源和对象之间是没有关系的。
    2、希望某个方法不与包含它的类的任何对象联系在一起。总结下来就是说:即使没有创建对象,也能使用属性和调用方法,static目的就是在于解决这个问题。

    1.修饰成员变量和方法

    在Java程序里面,所有的东西都是对象,而对象的抽象就是类,对于一个类而言,如果要使用他的成员或方法,那么普通情况下必须先实例化对象后,通过对象的引用才能够访问这些成员或方法,但是有种情况例外,就是该成员是用static声明的,即可引用成员或方法。最基本的有Integer.parseInt(),Float.parseFloat()等等用来把对象转换为所需要的基本数据类型,这样的变量和方法我们又叫做类变量和类方法。

    public class StaticTest {
        //静态字符串变量
        public static String codeStr = "123456";
        //静态整型变量
        public static int codeInt = 12;
        public static void main(String[] args) {
            //输出字符串:123456
            System.out.println(codeStr);
            //输出整型:144
            System.out.println(codeInt * 12);
        }
    }
    
    2.修饰成员变量和方法

    一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的。需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的. 静态方法在类加载的时候 就已经加载 可以用类名直接调用
    比如main方法就必须是静态的 这是程序入口
    两者的区别就是:静态代码块是自动执行的;
    静态方法是被调用的时候才执行的.

    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    public class StaticTest {
        //静态字符串变量
        public static String codeStr = "123456";
        //静态整型变量
        public static int codeInt = 12;
        public static void main(String[] args) throws Exception {
            //输出字符串:123456
            System.out.println(codeStr);
            //输出整型:144
            System.out.println(codeInt * 12);
            //通过静态方法获取当前时间字符串:201911011518264
            System.out.println(getSystemDateTime("yyyyMMddHHssSSS"));
        }
    
        /**
         * @Title: getSystemDateTime
         * @Description: 获取当前时间字符串yyyyMMddHHssSSS格式
         * @param datepattern
         * @return
         * @throws Exception
         */
        public static String getSystemDateTime(String datepattern) throws Exception {
            SimpleDateFormat df = new SimpleDateFormat(datepattern);
            return df.format(Calendar.getInstance().getTime());
        }
    }
    

    1.static可以修饰变量,方法
    2.被static修饰的变量或者方法是独立于该类的任何对象,也就是说,这些变量和方法不属于任何一个实例对象,而是被类的实例对象所共享。
    3.在类被加载的时候,就会去加载被static修饰的部分。
    4.被static修饰的变量或者方法是优先于对象存在的,也就是说当一个类加载完毕之后,即便没有创建对象,也可以去访问。

    3.静态内部类

    需要了解2个概念:
    1)首先,用内部类是因为内部类与所在外部类有一定的关系,往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件存放这个类。
    2)静态内部类也叫嵌套类,用这个名字给他定义是更加形象的。意思是说内部类和外部类的关系只是层次嵌套关系,所以只是在创建类文件的时候类文件名是如下形式:outer$inner.java,在使用方面完全和两个普通类一样
    作用:
    1)静态内部类的作用:只是为了降低包的深度,方便类的使用,静态内部类适用于包含类当中,但又不依赖与外在的类,不用使用外在类的非静态属性和方法,只是为了方便管理类结构而定义。在创建静态内部类的时候,不需要外部类对象的引用。
    通俗的讲:比如有A,B两个类,B有点特殊,虽然可以独立存在,但只被A使用。如果把B并入A里,复杂度提高,搞得A违反单一职责。如果B独立,又可能被其他类(比如同一个包下的C)依赖,不符合设计的本意。所以不如将其变成A.B,等于添加个注释,告诉其他类别使用B了,它只跟A玩。
    2)非静态内部类才是真正的内部类:可以自由使用外部类的所有变量和方法

    public class StaticTest {
     public static void main(String[] args) {
         //输出123
         Pinner.print();
         //输出456
         Inner inner = new Inner();
         inner.print();
     }
     //静态内部类有静态方法
     static class Pinner {
         public static void print() {
             System.out.println("123");
         }
     }
     //静态内部类有非静态方法
     static class Inner {
         public void print() {
             System.out.println("456");
         }
     }
    }
    
    4.静态导包

    静态导包就是java包的静态导入,用import static代替import静态导入包。
    一般我们导入一个类都用 import com……ClassName;而静态导入是这样:import static com……ClassName.;这里的多了个static,还有就是类名ClassName后面多了个. ,意思是导入这个类里的静态方法。当然,也可以只导入某个静态方法,只要把 .* 换成静态方法名就行了。然后在这个类中,就可以直接用方法名调用静态方法,而不必用ClassName.方法名 的方式来调用。
    优点:可以简化一些操作,例如打印操作System.out.println(…);就可以将其写入一个静态方法print(…),在使用时直接print(…)就可以了。

    //导入工具包里的静态方法
    //原来的导入
    import jieyi.tools.util.DateUtil;
    //现在的导入
    import static jieyi.tools.util.DateUtil.getSystemDateTime;
    public class StaticTest {
        public static void main(String[] args) throws Exception {
            //原来的导入
            System.out.println(DateUtil.getSystemDateTime("yyyyMMddHHssSSS"));
            //现在的导入
            String dateTime = getSystemDateTime("yyyyMMddHHssSSS");
        }
    }
    

    在静态方法中没有this关键字因为静态是随着类的加载而加载,而this是随着对象的创建而存在的。静态比对象优先存在。
    静态可以访问静态的,但是静态不能访问非静态的。
    非静态的可以去访问静态的。
    静态只能访问静态。
    非静态既可以访问非静态的,也可以访问静态的

    参考:
    Static特别用法-静态导包
    .
    Java之static静态关键字详解
    .

    展开全文
  • static用法小结.doc

    2008-07-13 12:05:03
    static用法小结.doc
  • static用法大全

    2008-11-22 09:52:01
    static关键字是C, C++中都存在的关键字, 它主要有三种使用方式, 其中前两种只指在C语言中使用, 第三种在C++中使用(C,C++中具体细微操作不尽相同, 本文以C++为准). (1)局部静态变量 (2)外部静态变量/函数 (3)...
  • java中static用法理解

    千次阅读 2018-05-25 11:05:04
    在java的关键字中,static和final是两个我们必须掌握的关键字。...修饰成员变量在我们平时的使用当中,static最常用的功能就是修饰类的属性和方法,让他们成为类的成员属性和方法,我们通常将用static修饰的成员称为...
  • static用法总结

    千次阅读 2006-01-15 13:03:00
    static用法 请先看下面这段程序:
  • java-static用法

    千次阅读 2019-02-11 10:48:55
    static静态方法,对于静态方法来说,是没有this的,因为它不依附于任何对象 static静态语句块,在类初次被加载的时候,会按照static块的顺序来执行每个static块,并且只会执行一次。 static静态变量,静态变量被所有...
  • java中静态代码块的用法 static用法详解 url: http://www.cnblogs.com/panjun-Donet/archive/2010/08/10/1796209.html (一)java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的...
  • 【每日一C之八】C语言static用法

    千次阅读 2014-04-01 19:07:55
    每日一C之static用法  每天拾一个C语言贝壳,厚积薄发,积跬步以致千里。  今日贝壳:C语言static的用法与static修饰变量的空间存储特征。  要点: static在C中主要有两个作用,一修饰作用域;二修饰生存期...
  • java 中的static 用法

    千次阅读 2018-07-11 08:10:16
    三种static关键字的使用方法:1. 用来修饰成员变量2. 用来修饰成员方法3. 静态代码块一旦一个方法使用static进行修饰,那么这种静态方法,不需要创建对象,调用格式应该为:类名称.静态方法名如果需要使用的静态方法...
  • Java Static 用法总结

    千次阅读 2012-12-25 13:29:47
    Java中的Static关键字用的很多,但是总结起来,大概有三部分内容:Static memberStatic BlockStatic import下面分别介绍Static EntityStatic实体包括静态变量、静态方法、静态内部类。首先理解一下Static这个词,在...
  • static修饰类 及final与static用法总结

    千次阅读 2013-08-07 09:26:58
    static与final总结与 static修饰类
  • 1.test.h 定义 class Test{ static Test* GetInstance(); static CameraHardwareInterface* mSelf; } 2.test.cpp实现 //错误用法 static Test* Test::GetInstance(){ .
  • QT中的static用法

    千次阅读 2017-03-20 10:35:56
    C++的static有两种用法:面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类;后者主要说明static在类中的作用。 一、面向过程设计中的static 1、静态全局变量 在全局...
  • 一篇文章彻底让你搞懂c/c++中的static用法!1.static在c语言中:1、全局静态变量2、 局部静态变量3、静态函数2.static在C++中:1、static修饰的成员变量称为静态成员变量2、static修饰的成员函数称为静态成员函数 1....
  • Java中 static 用法总结

    千次阅读 2018-05-10 23:49:52
    static可以修饰方法(静态方法) 属性(静态属性) 代码块(静态代码块); static修饰的内容不再属于单个对象,而是属于这个类和类绑定,并且单独存放。当这个类同时有很多个实例化的对象时其中一个修改了这个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,677,304
精华内容 1,070,921
关键字:

static用法