java static关键字_【Java基础】标识符与static关键字

木 头 课 堂

小 木 前 言

        标识符可以用来标识变量名、类名、类中的方法名和文件名等。

        命名规则:

        (1)由字母、数字、下划线、$组成，不能以数字开头。

        (2)大小写敏感。

        (3)不得使用java中的关键字和保留字。

        关键字:

      都是小写的，jdk1.2多了strictfp(经准浮点型)，关键字jdk1.4多了assert(断言)关键字，jdk1.5多 了enum(枚举)关键字......

        true、false、 null严格说不应该算关键字， 应称其为保留字更合适。

        习惯:

        (1)标识符要符合语义信息。

        (2)包名所有字母小写。

        (3)类名每个单词首字母大写，其它小写。//TarenaStudent

     (4)变量和方法:第一个单词小写，从第二个单词开始首字母大写。//tarenaStudent

        (5)常量:所有字母大写，每个单词之间用" "连接。

        常用的转义字符:

"\b" (退格)"\f" (换页)"\n" (换行)"Vr" (回车)"\t" (水平制表符(到下一个tab位置))"\'"(单引号)"\"" (双引号)"II" (反斜杠)

        直接用到字符串里!是字符串的一部分。

小 木 正 文

——————————————

❶Java中的关键字

——————————————

        Java中的关键字有很多，如下图所示，有一些常用的如下所示:

注:

1、需要注意的是java中true, false, null不是关键字，是字面量

2、特殊关键字(Java保留字，它不用，你也不能用) : goto,const。

——————————————

❷static关键字

——————————————

        static静态关键字修饰:属性、方法、内部类、代码块。

        static属性

        1) static修饰的资源属于类级别，是全体对象实例共享的资源。

        2)静态属性:

        使用static修饰的属性，属于类的全体类的实例共享的变量。

        静态属性是在类的加载期间初始化的。

        使用类名.属性访问，如: System.out

        3)实例变量:

        属于对象的属性。

        使用对象.属性访问，如: person.name

        举例如下所示:

public class StaticFieldDemo{      public static void main(String[] args){            Foo f1 = new Foo();             Foo f2 = new Foo();            Foo f3 = new Foo();            System. out. println(f1.id +""+ f2.id + ""+ f3.id +""+ Foo.i);      }}class Foo {        int id;//实例变量        static int i= 0; //静态类级别变量        public Foo() {              id= i++;        }}

注:

        int id实例变量，相当于"每个人的水杯"。

        static int i=0静态类级别变量，相当于"共用的水桶”。

        程序执行过程内存图如下所示:

        第1步:加载类。

        注: static变 量在类加载期间初始化。

        第2步:在内存堆中分配对象空间。属性默认自动初始化，为"0"值。

        第3步:进行属性的赋值。

        第4步:递归调用父类构造器。(默认调用父类无参数构造器! )。

        第5步:调用本类构造器。

第6步：

        中间步骤省略，输出结果时，内存结构图如下所示:

注:

        1、f1.id相当于"每个人一个水杯”。

        2、Foo.i 相当于公用的"水桶”。

static方法

        使用static声明的方法，属于类的方法，一般用来表示工具方法。

        在类加载以后就可以自己调用，不需要创建任何类的实例对象。

        案例如下所示，这些方法都是属于类的方法(静态方法) :

/***静态方法*/public class StaticMethodDemo {    public static void main(String[] args) {        int c = Moo.add(1,2);        System.out.println(c);         double d = Math.sin(Math.PI);        System.out.println(d);        long now = System.currentTimeMillis();    } }class Moo {        int  a= 2;        //静态方法是属于类的方法，是公共工具的方法        //静态方法不能访问属于对象的资源(对象属性，对象方法)        public static int add(int a, int b) {            // return a+b+ this.a;编译错误，使用方法时没有对象            return a + b;        } }

静态代码块

        静态代码块是在类加载期间运行的代码块，由于类只加载一次， 所以静态代码块只执行一次!

        静态代码块用途不是很常 见，一般用来在类加载以后初始化一些静态资源时候使用。如:加载配置文件。

        参考代码如下所示:

/***静态方法*/public class StaticBlockDemo {      public static void main(String[] args) {          Xoo xoo = new Xoo();      }}class Xoo {      //代码块，在创建对象时执行，使用很少，和构造器差不多      {          System.out.println("创建对象了!");      }      //静态代码块，在类加载期间执行，用在加载配置文件等      static {          System.out.println("类加载了!");      }      public Xoo() {          System.out.println("调用了构造器!");      }}

static修饰符综述

        把对象相关的变成类相关的，它可以修饰属性、方法、代码块和内部类。

        static修饰属性(类变量) :

        那么这个属性就可以用"类名.属性名"来访问，也就是使这个属性成为本类的类变量，为本类对象所共享。

        类加载的过程，类本身也是保存在文件中(字节码文件保存着类的信息)的，java会通过I/0流把类的文件读入JVM (java虚拟机) ，这个过程称为类的加载。JVM会通过类路径(CLASSPATH) 来找字节码文件。需要的时候才会进行类加载，生成对象时是先加载后构造。

        类变量，会在加载时自动初始化，初始化规则和实例变量相同。

注意:

        类中的实例变量是在创建对象时被初始化的。

        static修饰的属性，是在类加载时被创建并进行初始化，类加载的过程只进行一次，也就是类变量只会被创建一次。

        static修饰方法(静态方法) :

        会使这个方法成为整个类所公有的方法，可以用"类名.方法名"访问。

        static修饰的方法，不能直接访问本类中的非静态成员，但本类的非静态方法可以访问本类的静态成员。

        在静态方法中不能出现this关键字。

        父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。(在使用对象调用静态方 法时其实是调用编译时类型的静态方法)

        java中的main方法必须写成static的原因:在类加载时无法创建对象，而静态方法可以不通过对象调用，所以在类加载时就可以通过main方法入口来运行程序。

        static修饰初始代码块:

        这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一-次。

        可以用静态初始代码块初始化一个类。

        动态初始代码块，写在类体中的"小”， 这个代码块是在生成对象时运行，这种代码块叫动态初始代码块。

        下面的例子显示的类有一个static方法，-些static变量， 以及一个static初始化块:

class UseStatic {    static inta=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= 42a=3b= 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=42b= 99

        解释的很透彻，还想补充点，就是static成 员是不能被其所在class创建的实例访问的。

Example: Class MyClass { public static str = "this is for test purpose";}MyClass instanceClass = new MyClass();Console.WriteLine(MyClass.str); // Runs wellConsole.WriteLine(instanceClass.str); // Error,lack of accessor

        通俗点的解释如下:

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

        2、加static修饰的成员是类成员，就是可以由一一个类直接调用，为所有对象共有的。

无  成 本 赞 赏

生活不易，还请小伙伴多多支持，顺手给小编加个鸡腿，万分感谢~~~

END

— — — — — — — — — — — — —

 

更多信息，扫码关注我们哦！