黑马程序员-----------static关键字

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1  static关键字

1.1static的特点

1.static关键字：静态的，全局的。

2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”，只有一份拷贝，被多个对象共享；

3.特点：

                          1).随着类的加载而加载

                          2).优先于对象存在

                          3).被类的所有对象共享

                          4).可以通过类名调用，也可以通过对象名调用；

4.static关键字注意事项：

                            1).在静态方法中是没有this关键字的

                            2).静态方法只能访问静态的成员变量和静态的成员方法

1.2静态变量及其与成员变量的区别

 

静态变量：

 

什么时候定义静态变量呢？

当该成员变量的值，每一个对象都一致时，就对该成员变量进行静态修饰。

 

静态变量和成员变量的区别：

1，所属范围不同。

静态变量所属于类，成员变量所属对象。

静态变量也称为：类变量；成员变量也称为实例变量。

 

2，调用不同。

静态变量可以被对象和类调用(一般都用类名调用)

成员变量只能被对象调用。

 

3，加载时期不同。

静态变量随着类的加载而加载。

成员变量随着对象的加载而加载。

 

4，内存存储区域不同。

静态变量存储在方法区中。

成员变量存储在堆内存中。

 

class Circle

{

         privatedouble radius;//圆的半径。

         privatestatic double pi = 3.14;//每一个圆对象中都存储一份，有点浪费内存空间。实现对象的共享。加入静态关键字修饰。

         Circle(doubleradius)

         {

                   this.radius= radius;

         }

         //获取圆的面积。

         doublegetArea()

         {

                   returnradius*radius*pi;

         }

         staticvoid show()

         {

                   System.out.println("circleshow run.."+pi);

         }

}

class CircleDemo

{

         publicstatic void main(String[] args)

         {

                   Circlec = new Circle(3);

                  

         }

}

 

1.3 静态代码块

 

需求：类一加载，需要做一些动作。不一定需要对象。

目标：必须了解加载的顺序。

静态代码块：

         特点：随着类的加载而执行,仅执行一次。

         作用：给类进行初始化。

 

class Demo

{

         staticint x = 9;//静态变量有两次初始化。 一次默认初始化，一次显示初始化。

         static//静态代码块。在静态变量显示初始化以后在执行。

         {

                   System.out.println("类加载就执行的部..."+x);

         }

         staticvoid show()

         {

                   System.out.println("showrun");

         }

}       

 

class StaticCodeDemo

{

         publicstatic void main(String[] args)

         {

                   Demo.show();

                   Demo.show();

         }

}

 

1.4静态方法

 

静态方法使用注意事项：

1，静态方法不能访问非静态的成员。

         但是非静态可以访问静态成员的。

         说明：静态的弊端在于访问出现局限性。好处是可以直接被类名调用。

 

2，静态方法中不允许出现this，super关键字。

 

 

为什么不行呢?

原理揭秘：

1，静态是随着类的加载就加载了。也是随着类的消失而消失了。

2，静态优先于对象存在，被对象共享。

3，因为静态先存在于内存中无法访问后来的对象的中的数据，所以静态无法访问非静态。

而且内部无法书写this。因为这时对象有可能不存在，this没有任何指向。

 

class Person

{

         privateString name;

         privateint age;

 

         Person(Stringname,int age)

         {

                   this.name= name;

                   this.age= age;

         }

         publicvoid speak()

         {

                   System.out.println("name="+this.name+",age="+this.age);

                   sleep();

         }

 

         //定义一个睡觉功能。

         publicstatic void sleep()

         {

//               System.out.println(name);

                   System.out.println("睡觉zzzZZZZ");

         }

}

 

class PersonDemo

{

         publicstatic void main(String[] args)

         {

 

 

//               Personp = new Person("lisi",20);

//               p.speak();

                   /*

                   创建对象就是为了产生实例，并进行数据的封装。

                   而调用功能时，确没有用到这些对象中封装的数据。

                   该对象的创建有意义吗？虽然可以编译并运行，但是在堆内存中空间较为浪费。

 

                   不建议创建对象。那该怎么调用呢？java中的解决方案就是 使用 static关键字，这是一个成员修饰符。

                   被静态static修饰的方法除了可以被对象调用外，还可以被类名调用。

                   静态看上去很美，是不是所有的方法都静态呢？不行！

 

                   那么什么时候需要将方法定义成静态的呢？

                   定义功能时，如果功能不需要访问类中定义的成员变量(非静态)时，该功能就需要静态修饰。

 

                   */

//               p.sleep();

                   Person.sleep();

        

         }

}

 

 

 

 

2 构造代码块

 

         用于给所有的对象初始化。很少用并很少见。

 

 

class Demo

{

         intx = 4;//成员变量 1，默认初始化，2，显示初始化。

         {//构造代码块。只要创建对象就会被调用。给所有对象初始化，构造函数只给对应的对象针对性的初始化。

                   //这里面可以定义不同构造函数的共性代码。

                   System.out.println("coderun..."+x);

//               System.out.println("----->hahah");

         }

 

         Demo()

         {

                   System.out.println("demorun");

         }

         Demo(intx)

         {

                   System.out.println("demorun...."+x);

//               System.out.println("----->hahah");

         }

 

 

}

 

class ConstructorCodeDemo

{

         publicstatic void main(String[] args)

         {

                   newDemo();

                   newDemo(5);

 

 

                   {//局部代码块,作用：就可以控制局部变量的生命周期。

                            intx = 5;

                            System.out.println("局部代码块..."+x);

                   }

 

                   System.out.println("over...");

         }

}

 

3.static和构造代码块的执行先后顺序

 

public class Demo2 {

    public static int k = 0;

   public static Demo2 t1 = new Demo2("t1");

   public static Demo2 t2 = new Demo2("t2");

   public static int i = print("i");

   public static int j = print("j");

   public static int n = 99;

    {

       print("constructor code");

    }

   static {

       print("static code");

    }

   public static int print(String s) {

       System.out.println("i="+i +"   "+s+ "  k=" + k + "  n=" + n + "   j=" + j);

       ++i;

       ++k;

       ++n;

       return i;

    }

    public Demo2(String string) {

    

       print(string);

    }

   public static void main(String[] args) {

       Demo2 d=new Demo2("T");

    }

}

 

输出结果：

i=0  constructor code  k=0  n=0  j=0

i=1  t1  k=1  n=1  j=0

i=2  constructor code  k=2  n=2   j=0

i=3  t2  k=3  n=3  j=0

i=4  i  k=4  n=4  j=0

i=5  j  k=5  n=5  j=0

i=6  static code  k=6  n=99  j=6

i=7  constructor code  k=7  n=100  j=6

i=8  T  k=8  n=101  j=6