【Java基础-面向对象下（1/2）】

static关键字

static关键字的使用

1、static：静态的
2、static可以用来修饰：属性、方法、代码块、内部类

3、使用static修饰属性：静态变量（或类变量）
    3.1 属性，按是否使用static修饰，又分为：静态变量 vs 非静态变量（实例属性）
       实例变量：当我们创建了类的多个对象，每个对象都独立拥有一套类中的非静态属性。当修改其中一个对象的非静态属性时，
                不会导致其他对象中其他对象中同样的属性值的修改。
       静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态
                变量时，是修改过了的。
    3.2 static修饰属性的其他说明：
        ① 静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用。
        ② 静态变量的加载要早于对象的创建。
        ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

        ④           类变量     实例变量
            类       yes         no
            对象     yes         yes

    3.3 静态属性举例： System.out ; Math.Pi

4、使用static修饰方法：
       ① 静态变量随着类的加载而加载。可以通过“类.静态方法”的方式进行调用。

       ②           静态方法     非静态方法
            类       yes         no
            对象     yes         yes

      ③ 静态方法中，只能调用静态的方法或属性
        非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

        （加载早的不能调用加载晚的，因为不知道加载晚的会是什么样的。而加载晚的可以调用加载早的，因为已经确定加载早的是什么样的）
        ☆:static是随着类加载而加载，非static是随着对象加载而加载，如果没有生成对象，“解释器”就无法知道其非static属性和方法是什么样的
            所以就不能调用。且对象的生命周期到时会释放，类还一直在。所以非static的属性和方法会变成什么样也是一直不确定的。
            所以规定static不能调用非static的。

 5、static注意点：
    5.1 在静态的方法中，不能使用this关键字、super关键字。（this是当前对象，super是当前对象的父类，他们都基于有当前对象才能使用，
                                                      加载比静态晚，所以不能调用。---生命周期。）
    5.2 关于静态属性和方法的使用，大家都从生命周期的角度去理解。

 6、开发中，如何确定一个属性是否要声明为static的？
        > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
        > 类中的常量也声明为static的

    开发中，如何确定一个方法是否要声明为static的？
        > 操作静态属性的方法，通常设置为static的
        > 工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

	Chinese.nation = "中国";
    System.out.println(Chinese.nation);//中国，静态变量随着类的加载而加载，早于类的对象的创建。

    Chinese c1 = new Chinese();
    Chinese c2 = new Chinese();
    c1.name = "姚明";
    c1.age = 40;
    c1.nation = "CHN";

    c2.name = "马龙";
    c2.age = 30;
    c2.nation = "China";
    System.out.println(c1.nation);//China，共享一个同名静态变量，修改一个对象的静态变量值，其他对象的静态变量的值也会变修改。

    c1.eat();
    Chinese.show();
//---------------------------------  类  ------------------------------
class Chinese{
    String name;
    int age;
    static String nation;

    public void eat(){
        System.out.println("中国人吃中餐");

        //调用非静态结构
        this.info();
        System.out.println(name);

        //调用静态结构
        walk();
        System.out.println(nation);
    }


    public void info(){

    }

    public static void show(){
        System.out.println("我是一个中国人");

        //不能调用非静态的结构
        //eat();
        //name = "Tom";

        //可以调用静态的结构
        System.out.println(Chinese.nation);//在本类中，Chinese.可以省略
        walk();
    }

    public static void walk(){

    }
}    

代码块

类的成员之四：代码块（或初始化块）

    1、代码块的作用：用来初始化类、对象
    2、代码块如果有修饰的话，只能使用static
    3、分类：静态代码块 vs 非静态代码块

    4、静态代码块
        >内部可以有输出语句
        >随着类的加载而执行,而且只执行一次（和类加载次数一样）
        >作用：初始化类的信息
        >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
        >静态代码块的执行要优先于非静态代码块执行。
        >静态代码块内只能调用静态的属性、方法。不能调用非静态的结构。

    5、非静态代码块
        >内部可以有输出语句
        >随着对象的创建而执行
        >每创建一次对象，就执行一次非静态代码块
        >作用：可以在创建对象时，对对象的属性等进行初始化
        >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
        >非静态代码块内部可以调用静态的方法、属性和非静态的属性、方法。

    对属性赋值的位置：
    ①默认初始化
    ②显式初始化
    ③构造器中初始化
    ④有了对象后，通过“对象.属性”、“对象.方法”的方式，进行赋值
    ⑤在代码块中赋值

    执行顺序：① - ② / ⑤ - ③ - ④

 		System.out.println("******代码块*******");

          String desc = DaimakuaiPerson.desc;//输出hello,static,block-2  --->随着类的加载而执行
          System.out.println(DaimakuaiPerson.desc);//

          DaimakuaiPerson daimakuaiPerson1 = new DaimakuaiPerson();//hello,block
          DaimakuaiPerson daimakuaiPerson2 = new DaimakuaiPerson();//hello,block
//--------------------------  类  ----------------------------
class DaimakuaiPerson{

    //属性
    String name;
    int age;
    static String desc = "我是一个人";

    //构造器
    public DaimakuaiPerson(){
    }

    public DaimakuaiPerson(String name,int age){
        this.name = name;
        this.age = age;
    }

    //代码块
    {       //非static的
        System.out.println("hello,block-2");
        //非静态的属性、方法
        this.age = 1;
        eat();
        //静态的属性、方法
        System.out.println(desc);
        info();
    }

    {       //非static的
        System.out.println("hello,block-1");
        this.age = 1;
    }

    static{ //static的
        System.out.println("hello,static,block-2");
        desc = "我是一个爱学习的人";
        //静态的属性、方法
        System.out.println(desc);
        info();
        //不能调用非静态的结构！
        //age = 1;
        //eat();
    }

    static{ //static的
        System.out.println("hello,static,block-1");
        desc = "我是一个爱学习的人";
    }

                                        //方法
    public void eat(){
        System.out.println("吃饭");
    }

    @Override
    public String toString() {
        return "DaimakuaiPerson{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void info(){
        System.out.println("info");
    }
}          

final关键字

final：最终的

    1、final可以用来修饰的结构：类、方法、属性
    2、final 用来修饰一个类：此类不能被其他类所继承。
            比如：String类、System类、StringBuffer类

    3、final 用来修饰方法：表明此方法不能被重写。
            比如：Object类中的getClass();

    4、final 用来修饰变量：此时的"变量"就称为一个常量。
         4.1 final修饰属性：可以考虑的赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
                （方法不能赋值，在构造器调用创建对象前就要确认final修饰的属性的值。原因:它们是不能被更改的,在调用构造器之后
                  的任何操作都不能对这些属性进行修改。不能只默认初始化同理，不能在对象创建之后还可能是处于没被赋值的状态！）

         4.2 final修饰局部变量:
                尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。
                一旦赋值以后，就只能在方法体内使用此形参，当不能进行重写赋值。

   static final：用来修饰属性：全局常量

class FinalB{
    public final void A(){

    }
}

class FinalC extends FinalB{

//    @Override
//    public void A() {     //不能重写final的方法
//    }
}


class FinalTest{

    //final int WIDTH;  //不能未初始化

    static final int WIDTH = 0; //需要显式初始化
    final int LEFT; //如果是未显式初始化，可以在代码块中赋值。
    final int RIGHT;//如果是未显式初始化，可以在构造器中赋值。
    {
        LEFT = 1;
    }

    public FinalTest(){
        RIGHT = 2;
    }
    //如果有多个构造器，它们都需要对未初始化的final属性进行赋值操作
    public FinalTest(int n){
        RIGHT = n;
    }


}