java学习笔记46--static修饰符

1)static变量
        在类中,使用static修饰的成员变量,就是静态变量,反之为非静态变量。

        静态变量和非静态变量的区别
            静态变量数属于类的,"可以"使用类名来访问,非静态变量是属于对象的,"必须"使用对象来访问.
                例如:
                public class Student{
                    private static int age;
                    private double score;
                    public static void main(String[] args) {
                        Student s = new Student();
                        //推荐使用类名访问静态成员
                        System.out.println(Student.age);
                        System.out.println(s.age);

                        System.out.println(s.score);
                    }
                }

        静态变量对于类而言在内存中只有一个,能被类的所有实例所共享。实例变量对于类的每个实例都有一份,它们之间互不影响.
            例如:
            public class Student{
                private static int count;
                private int num;
                public Student() {
                    count++;
                    num++;
                }
                public static void main(String[] args) {
                    Student s1 = new Student();
                    Student s2 = new Student();
                    Student s3 = new Student();
                    Student s4 = new Student();
                    //因为还是在类中,所以可以直接访问私有属性
                    System.out.println(s1.num);
                    System.out.println(s2.num);
                    System.out.println(s3.num);
                    System.out.println(s4.num);

                    System.out.println(Student.count);
                    System.out.println(s1.count);
                    System.out.println(s2.count);
                    System.out.println(s3.count);
                    System.out.println(s4.count);
                }
            }

        在加载类的过程中为静态变量分配内存,实例变量在创建对象时分配内存
            所以静态变量可以使用类名来直接访问,而不需要使用对象来访问.

2)static方法
        在类中,使用static修饰的成员方法,就是静态方法,反之为非静态方法。

        静态方法和非静态方法的区别
            静态方法数属于类的,"可以"使用类名来调用,非静态方法是属于对象的,"必须"使用对象来调用.
        
        静态方法"不可以"直接访问类中的非静态变量和非静态方法,但是"可以"直接访问类中的静态变量和静态方法
            注意:this和super在类中属于非静态的变量.(静态方法中不能使用)
            例如:
            public class Student{
                private static int count;
                private int num;
                public void run(){}
                public static void go(){}
                

                public static void test(){
                    //编译通过
                    System.out.println(count);
                    go();
                    
                    //编译报错
                    System.out.println(num);
                    run();
                }

            }

        非静态方法"可以"直接访问类中的非静态变量和非静态方法,也"可以"直接访问类中的静态变量和静态方法
            例如:
            public class Student{
                private static int count;
                private int num;
                public void run(){}
                public static void go(){}

                public void test(){
                    //编译通过
                    System.out.println(count);
                    go();
                    
                    //编译通过
                    System.out.println(num);
                    run();
                }

            }

            思考:为什么静态方法和非静态方法不能直接相互访问?
        
        
        父类的静态方法可以被子类继承,但是不能被子类重写
            例如:
                public class Person {
                     public static void method() {}
                }
                
                //编译报错
                public class Student extends Person {
                     public void method(){}
                }

            例如:
                public class Person {
                     public static void test() {
                        System.out.println("Person");
                     }
                }
                
                //编译通过,但不是重写
                public class Student extends Person {
                     public static void test(){
                        System.out.println("Student");
                     }
                }
                main:
                    Perosn p = new Student();
                    p.test();//输出Person
                    p = new Person();
                    p.test();//输出Perosn

                和非静态方法重写后的效果不一样
        

        父类的非静态方法不能被子类重写为静态方法    
            例如:
                public class Person {
                     public void test() {
                        System.out.println("Person");
                     }
                }
                
                //编译报错
                public class Student extends Person {
                     public static void test(){
                        System.out.println("Student");
                     }
                }
    

3)代码块和静态代码块
        类中可以编写代码块和静态代码块
        例如:
            public class Person {
                {
                    //代码块(匿名代码块)
                }

                static{
                    //静态代码块
                }
            }
        
        匿名代码块和静态代码块的执行
            因为没有名字,在程序并不能主动调用这些代码块。

            匿名代码块是在创建对象的时候自动执行的,并且在构造器执行之前。同时匿名代码块在每次创建对象的时候都会自动执行.

            静态代码块是在类加载完成之后就自动执行,并且只执行一次.

            注:每个类在第一次被使用的时候就会被加载,并且一般只会加载一次.

            例如:
                public class Person {
                    {
                        System.out.println("匿名代码块");
                    }

                    static{
                        System.out.println("静态代码块");
                    }
                    public Person(){
                        System.out.println("构造器");
                    }
                }
                main:
                    Student s1 = new Student();
                    Student s2 = new Student();
                    Student s3 = new Student();
                    //输出结果:
                    静态代码块
                    匿名代码块
                    构造器
                    匿名代码块
                    构造器
                    匿名代码块
                    构造器

        匿名代码块和静态代码块的作用
            匿名代码块的作用是给对象的成员变量初始化赋值,但是因为构造器也能完成这项工作,所以匿名代码块使用的并不多。

            静态代码块的作用是给类中的静态成员变量初始化赋值。
            例如:
                public class Person {
                    public static String name;
                    static{
                        name = "tom";
                    }
                    public Person(){
                        name = "zs";
                    }
                }
                main:
                    System.out.println(Person.name);//tom

                注:在构造器中给静态变量赋值,并不能保证能赋值成功,因为构造器是在创建对象的时候才指向,但是静态变量可以不创建对象而直接使用类名来访问.

        
        创建和初始化对象的过程
            Student s = new Student();
            1)Student类之前没有进行类加载
                1类加载,同时初始化类中静态的属性
                2执行静态代码块
                3分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
                4调用Student的父类构造器
                5对Student中的属性进行显示赋值(如果有的话)
                6执行匿名代码块
                7执行构造器
                8返回内存地址

                注:子类中非静态属性的显示赋值是在父类构造器执行完之后和子类中的匿名代码块执行之前的时候

            例如:
                public class Person{
                    private String name = "zs";
                    public Person() {
                        System.out.println("Person构造器");
                        print();
                    }
                    public void print(){
                        System.out.println("Person  print方法: name = "+name);
                    }
                }

                public class Student extends Person{
                    private String name = "tom";
                    {
                        System.out.println("Student匿名代码块");
                    }

                    static{
                        System.out.println("Student静态代码块");
                    }
                    public Student(){
                        System.out.println("Student构造器");
                    }
                    public void print(){
                        System.out.println("student print方法: name = "+name);
                    }
                    public static void main(String[] args) {
                        new Student();
                    }
                }

                //输出结果:
                Student静态代码块
                Person构造器
                student print方法: name = null
                Student匿名代码块
                Student构造器

 

            Student s = new Student();
            2)Student类之前已经进行了类加载
                1.分配内存空间,同时初始化非静态的属性(赋默认值,0/false/null)
                2.调用Student的父类构造器
                3.对Student中的属性进行显示赋值(如果有的话)
                4.执行匿名代码块
                5.执行构造器
                6.返回内存地址

4)静态导入
        静态导入是JDK5.0引入的新特性。
        例如:
        import static java.lang.Math.random;
        import static java.lang.Math.PI;

        public class Test {
            public static void main(String[] args) {
                //之前是需要Math.random()调用的
                System.out.println(random());
                System.out.println(PI);
            }
        }