classDemo

static关键字
作用：
一.静态导入
直接看代码：

        public class OldImport {

            public static void main(String[] args) {

                double a = Math.cos(Math.PI / 2);
                double b = Math.pow(2.4,1.2);
                double r = Math.max(a,b);

                System.out.println(r);
            }
        }

        Math有点多 进行更改：

        import static java.lang.Math.PI;
        import static java.lang.Math.cos;
        import static java.lang.Math.max;
        import static java.lang.Math.pow;
        public class StaticImport {

            public static void main(String[] args) {

                double a = cos(PI / 2);
                double b = pow(2.4,1.2);
                double r = max(a,b);

                System.out.println(r);
            }
        }

        这就是静态导入。我们平时使用一个静态方法的时候，都是【类名.方法名】，使用静态变量的时候都是【类名.变量名】，如果一段代码中频繁的用到了这个类的方法或者变量，我们就要写好多次类名，比如上面的Math，这显然不是喜欢偷懒的程序员所希望做的，所以出现了静态导入的功能。
    二.静态变量

        1.java提供了两种类型的变量：用static修饰的静态变量和不用static修饰的成员变量

            1）静态变量属于类，在内存中只有一个实例。当jtbl所在的类被加载的时候，就会为该静态变量分配内存空间，该变量就可以被使用。jtbl有两种被使用方式：【类名.变量名】和【对象.变量名】。

            2）实例变量属于对象，只有对象被创建后，实例对象才会被分配空间，才能被使用。他在内存中存在多个实例，只能通过【对象.变量名】来使用。

            3）静态变量被类拥有，所有对象都共享这个静态变量，而实例对象是与具体对象相关的。
            4）当你的某一个变量会经常被外部代码访问的时候，可以考虑设计为静态的。

            public class StaticAttribute {
                public static int staticInt = 10;
                public static int staticIntNo ;
                public int nonStatic = 5;

                public static void main(String[] args) {
                    StaticAttribute s = new StaticAttribute();

                    System.out.println("s.staticInt= " + s.staticInt);
                    System.out.println("StaticAttribute.staticInt= " + StaticAttribute.staticInt);

                    System.out.println("s.staticIntNo= " + s.staticIntNo);
                    System.out.println("StaticAttribute.staticIntNo= " + StaticAttribute.staticIntNo);

                    System.out.println("s.nonStatic= " + s.nonStatic);

                    System.out.println("使用s,让三个变量都+1");

                    s.staticInt ++;
                    s.staticIntNo ++;
                    s.nonStatic ++;

                    StaticAttribute s2 = new StaticAttribute();

                    System.out.println("s2.staticInt= " + s2.staticInt);
                    System.out.println("StaticAttribute.staticInt= " + StaticAttribute.staticInt);

                    System.out.println("s2.staticIntNo= " + s2.staticIntNo);
                    System.out.println("StaticAttribute.staticIntNo= " + StaticAttribute.staticIntNo);

                    System.out.println("s2.nonStatic= " + s2.nonStatic);

                }
            }
            //        结果：
            //        s.staticInt= 10
            //        StaticAttribute.staticInt= 10
            //        s.staticIntNo= 0
            //        StaticAttribute.staticIntNo= 0
            //        s.nonStatic= 5
            //        使用s,让三个变量都+1
            //        s2.staticInt= 11
            //        StaticAttribute.staticInt= 11
            //        s2.staticIntNo= 1
            //        StaticAttribute.staticIntNo= 1
            //        s2.nonStatic= 5
    三.静态方法
        1.与静态变量一样，java类也同时提供了static方法和非static方法。

            1）static方法是类的方法，不需要创建对象就可以使用，比如Math类里面的方法。使用方法【对象.方法名】或者【类名.方法名】
            2）非static方法是对象的方法，只有对象被创建出来以后才可以被使用。使用方法【对象.方法名】
        2.注意事项

            static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态变量和静态方法。因为当static方法被调用的时候，这个类的对象可能还没有创建，即使已经被创建了，也无法确认调用哪个对象的方法。不能访问非静态方法同理。
            但是静态方法调用普通方法或者属性时必须通过对象去调用。
                例子：
                public class Demo2 {
                    void foo(){
                        System.out.println("123");
                    }
                    static void show(){
                         new Demo2().foo();
                    }
                    public static void main(String[] args){
                        Demo2.show();
                    }
                }
                //输出：123

代码块：
一.什么是代码块

    所谓代码块就是用大括号将多行代码封装在一起，形成一个独立的数据体，用于实现特定的算法。一般来说代码块是不能单独运行的，它必须要有运行主体。在Java中代码块主要分为四种：普通代码块，静态代码块，同步代码块和构造代码块。

二.代码块分类

    普通代码块

        普通代码块是我们用得最多的也是最普遍的，它就是在方法名后面用{}括起来的代码段。普通代码块是不能够单独存在的，它必须要紧跟在方法名后面。同时也必须要使用方法名调用它。
        public void common(){  
            System.out.println("普通代码块执行");  
        } 

    静态代码块

        静态代码块就是用static修饰的用{}括起来的代码段，它的主要目的就是对静态属性进行初始化。

        静态代码块可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

        很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

    构造代码块

        在类中直接定义没有任何修饰符、前缀、后缀的代码块即为构造代码块。我们明白一个类必须至少有一个构造函数，构造函数在生成对象时被调用。构造代码块和构造函数一样同样是在生成一个对象时被调用。

        构造代码块的应用场景：

        1）初始化实例变量 
            如果一个类中存在若干个构造函数，这些构造函数都需要对实例变量进行初始化，如果我们直接在构造函数中实例化，必定会产生很多重复代码，繁琐和可读性差。这里我们可以充分利用构造代码块来实现。这是利用编译器会将构造代码块添加到每个构造函数中的特性。

        2）初始化实例环境 
            一个对象必须在适当的场景下才能存在，如果没有适当的场景，则就需要在创建对象时创建此场景。我们可以利用构造代码块来创建此场景，尤其是该场景的创建过程较为复杂。构造代码会在构造函数之前执行。

    综合静态代码块、普通代码块、构造代码块的例子：

public class CodeBlock {
                private int a = 1;
                private int b ;
                private int c ;
                //静态代码块
                static {
                    int a = 4;
                    System.out.println("我是静态代码块1");
                }
                //构造代码块
                {
                    int a = 0;
                    b = 2;
                    System.out.println("构造代码块1");
                }

                public CodeBlock(){
                    this.c = 3;
                    System.out.println("构造函数");
                }

                public int add(){

                    System.out.println("count a + b + c");
                    return a + b + c;
                }
                //静态代码块
                static {
                    System.out.println("我是静态代码块2，我什么也不做");
                }
                //构造代码块
                {
                    System.out.println("构造代码块2");
                }
                public static void main(String[] args) {
                    CodeBlock c = new CodeBlock();
                    System.out.println(c.add());

                    System.out.println();
                    System.out.println("*******再来一次*********");
                    System.out.println();

                    CodeBlock c1 = new CodeBlock();
                    System.out.println(c1.add());
                }
            }

        //结果：
        //我是静态代码块1
        //我是静态代码块2，我什么也不做
        //构造代码块1
        //构造代码块2
        //构造函数
        //count a + b + c
        //6
        //
        //*******再来一次*********
        //
        //构造代码块1
        //构造代码块2
        //构造函数
        //count a + b + c
        //6

    总结：

        1）静态代码块只会执行一次。有多个静态代码块时按顺序依次执行。
        2）构造代码块每次创建新对象时都会执行。有多个时依次执行。
        3）执行顺序：静态代码块 > 构造代码块 > 构造函数。
        4）构造代码块和静态代码块有自己的作用域，作用域内部的变量不影响作用域外部。