static关键字的讲解——静态变量、静态方法、支持重载、静态代码块

static

关键字、修饰符 修饰变量、方法、代码块、内部类
1.静态变量

1）静态变量随着类的加载（方法区的静态常量池）而加载到方法区的静态区，与类同级，也叫类变量，通过类名.形式调用静态变量，也可以通过对象来调用 静态变量。
2）存储在方法区静态区时，系统会默认给静态变量赋予系统默认初始值。
3.类产生的对象共享同一个静态变量。看静态变量是否需要被所有的对象来共享，如果需要就设置成静态变量。
**问：**方法里可以定义静态变量？
**答：**静态变量与类同级，只有方法被调用时里面的内容才能出现，前后矛盾，不能定义

代码演示

package cn.tedu.staticx;

public class StaticDemo1 {
    public static void main(String[] args) {
        //创建Person类的对象
        Person p=new Person();
        p.name="郭靖";
        p.age=19;
        p.gender='男';
        Person p1=new Person();
        p1.name="黄蓉";
        p1.age=18;
        p1.gender='女';
        //输出
        System.out.println(p.name+","+p.age+","+p.gender);
        System.out.println(p1.name+","+p1.age+","+p1.gender);
        System.out.println(p.toString());
        System.out.println(p1.toString());
    }
}

//定义代表人的类
class Person{
    //属性
    String name;
    int age;
    static char gender;

    //定义一个方法输出对象的属性值
    public String toString(){
        return  this.name+","+this.age+","+this.gender;
    }
}

2.静态方法
静态方法会随着类的加载而加载到方法区的静态区，与类同级也叫做类方法，通过类名.形式来调用，也可以通过对象调用。静态区不会对静态方法赋予初始化值，但是被调用就会加载到栈中执行。
Java中静态方法只能直接使用静态信息，但是非静态方法可以直接使用静态信息以及非静态信息。
3.支持重载
不支持重写
静态方法与类同级，重写针对的是对象，级别不一样，静态方法没有提供重写。父子类中要么出现方法签名一致的都是非静态方法（重写），要么都是静态方法（没有重写）。
代码演示

package cn.tedu.staticx;

public class StaticDemo3 {
    public static void main(String[] args) {
        //向上造型
        SDemo s=new SDemo1();
        //向上造型对象执行的是子类方法，证明发生重写
        s.m();
    }
}
class  SDemo{
    public void m(){
        System.out.println(1);
    }
    public static void n(){}
}
class  SDemo1 extends SDemo{
    //注解---给计算机看的注释
    //@Override表明下面的方法是重写方法
    @Override
    public void m(){
        System.out.println(2);
    }
    //加注解在报错说明不是重写方法
    //静态方法与类同级
    //重写--运行时多态--针对的是对象，相当于和对象一个级别
    //静态方法就没有提供重写
    //@Override
    public static void n(){}
}

4.静态代码块

a.可以给静态变量进行初始化
b.预先加载资源
c.随着类的加载而加载，只加载一次
d.static修饰的静态信息都只加载一次
e.父子类执行顺序（父类静态信息--子类静态信息--父类对象级别信息--子类对象级别信息）

代码演示1

package cn.tedu.staticx;

public class StaticDemo4 {
    public static void main(String[] args) {
        //匿名对象
        new SDemo2();
        new SDemo2();
    }
}

//
class SDemo2{
    static int i;//静态变量
    //静态代码块
    //给静态变量进行初始化
    //预先加载资源
    //因为静态代码块随着类的加载而加载，但是类只加载一次
    static {
        i=1;
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块");
    }
    public SDemo2(){
        System.out.println("构造方法");
    }
}

小案例：

注：如果右边的i没有初始化值，则结果为1
代码演示2

package cn.tedu.staticx;

public class StaticText2 {
    public static void main(String[] args) {
        System.out.println(new STDemo().i);
    }
}
class STDemo{
    /*int i=5;
    {
        i=1; //1
    }*/
    {
        i=1;
    }
    int i=3;  //3
}

代码演示3

package cn.tedu.staticx;

public class StaticText3 {
    public static void main(String[] args) {
        System.out.println(new STDemo1().x+","+new STDemo1().y);
    }
}
class STDemo1{
    /*//StackOverflowError--栈溢出错误
    STDemo1 st=new STDemo1();
    static int x;
    static int y=3;
    public STDemo1(){
        x++;
        y++;*/
    /*
     * 加载        执行第一步   执行第二步  执行第三步
       st=null     st=0x01     st=0x01   st=0x01
       x=0           x=1       x=1       x=1
       y=0           y=1       y=1       y=3
     */

    static STDemo1 st=new STDemo1();
    static int x;
    static int y=3;
    public STDemo1(){
        x++;
        y++;
    }
}