java面向对象 final && static 关键字

public final class Test {
    public static int totalNumber = 5;
    public final int ID;
    public Test() {
        ID = ++totalNumber; // 可在构造器中给final修饰的“变量”赋值
    }
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.ID);
        final int I = 10;
        final int J;
        J = 20;
        J = 30; // 非法
    }
}

总结

package com.jyc.p2;
/*
* 一.static关键字的使用
*   static可以用来修饰 属性 方法 构造器 内部类
*   使用static修饰属性 :静态变量
*       属性使用static修饰又分为静态属性（类变量） vs 非静态属性（实例变量）
*       实例变量：我们创建了类的多个对象，每个对象都有独立的一套类中的非静态属性.当修改一个对象中的
*                非静属性时，不会导致对象中同样的属性值的修改
*       静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量
*                其他对象调用此静态变量时，是修改过的
*      static修饰符的其他说明
*         1.静态变量随着类的加载而加载（可以通过类.静态变量的方式进行调用）
*         2.静态变量的加载要早于对象的创建
*         3.由于类只会加载一次，则静态变量在内存中也会存在一份，存在方法区的静态域中
*         4.类不可以调用实例变量
*
*      例如 System.out  Math.PI
*
*   使用static修饰方法
*    1. 随着类的加载而加载，可以通过类.静态方法的方式进行调用
*    2.不能调用非静态方法
*    3.静态方法中只能调用静态的方法或属性，非静态的方法中，既可以调用非静态的方法和属性，也可以调用静态
*    的方法和属性
*
*   static注意点
*   在静态的方法内不能使用this super 关键字
*   从生命周期的角度理解
*   属性是可以被多个对象共享的，不会随着对象的不同而不同
*   操作静态的方法，通常设置为static
*   工具类中的方法，习惯上声明为static 比如 Math.Arrays
*
* 二 单例设计模式
*  所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，
*
* 饿汉式 vs 懒汉式
* 懒汉式 ：延迟 对象的创建
* 饿汉式： 对象加载时间过长，线程安全
*
* 三 main方法的使用
*   1.mian()程序的入口
*     public static void main(String[] args) {}（也是普通的静态方法）
*     也可以作为我们与控制台交互的方式
*
* 四 代码块(或者初始化)
*   1.代码块的作用 用来初始化类 对象
*   2.代码块只能使用static修饰
*   3.分类 静态代码块 vs 非静态代码块
*   5.静态代码块
*       内部可以有输出语句
*       随着类者加载而执行，而且只执行一次
*       初始化类信息
*       如果一个类中定义了多个代码块，则按照声明的先后顺序执行
*       静态代码块的执行由于非静态代码块
*       静态代码块内可以调用静态属性静态方法，不能调用非静态结构
*
*     非静态代码块
*       内部可以有输出语句
*       随着对象的创建而执行，每创建一个对象执行一次
*       作用：可以对对象的属性进行初始化
*       如果一个类中定义了多个代码块，则按照声明的先后顺序执行
*       非静态代码块可以调用静态属性，静态方法 或非静态属性 非静态方法
*
*   属性可以赋值的位置
*   1.默认初始化
*   2.显示初始化
*   3.构造器中初始化
*   4.有了对象以后 可以对象.属性 对象.方法进行初始化
*   5.代码块中赋值
*   赋值顺序 1--> 2/5--> 3 -->4
*
* 五  final关键字 最终的
*  final 可以修饰的结构  类 方法 变量
*
*  final修饰一个类 此类不能够在继承
*   比如 String System
*
*  final修饰一个方法 表明方法不可以被重写
*    比如 object.getClass（）
*
*  final可以用来修饰变量  此时的变量就是常量了
     final修饰属性 可以考虑赋值的位置有 显示初始化 代码块中 构造器中
     final修饰属性 修饰局部变量
        尤其是final修饰形参时，表明形参是一个常量，当我们调用此方法时给常量形参赋一个实参
        一但赋值以后，就只能在方法体内使用形参，但不能重新赋值
     static final：用来修饰属性 全局常量
     static final：用来修饰方法 不能被继承


* */
public class test1 {
    public static void main(String[] args) {
        Chinese c1=new Chinese("zs",18);
        Chinese c2=new Chinese("ls",22);
        c1.nation="中国";

        System.out.println(c2.nation);
        System.out.println("-----------单例设计模式饿汉式-------");
        Bank bank1=Bank.getInstance();
        Bank bank2=Bank.getInstance();
        System.out.println(bank1==bank2);
        System.out.println("-----------代码块-------");

        System.out.println(Chinese.desc);
        System.out.println(c2.language);

    }
}
class Chinese{
    String name;
    int age;
    String language;
    final  int width=10;
    final  int left;
    final  int right;
    static  String nation;
    static  String desc="我是一个人";
    Chinese(){
        right=100;
    }
    Chinese( String name, int age){
        this.age=age;
        this.name=name;
        right=100;

    }

    public  static  void show(){
        System.out.println("show执行");
        //name="tom";无法从静态上下文中引用非静态 变量
        nation="中国";//可以调用静态结构
    }
    //代码块
    {
        System.out.println("代码块");
        language="汉语";
        show();
        left=100;
    }
    static {
        System.out.println("静态代码块");
        desc="我是一个中国人";
        show();
    }
}
//饿汉式
 class Bank{
    //私有化类的构造器
     private  Bank(){}
     //内部创建类的对象（要求此对象必须为静态的）
     private  static  Bank instance=new Bank();

     //通过公共的静态对象 返回类的对象
     public  static  Bank getInstance(){
         return  instance;
     }
 }
 //饿汉式
 class Change{
    private  Change(){}
    //声明当前类对象，没有初始化
    private   static  Change instance =null;
    //声明public static的返回当前类对象方法
    public  static Change getInstance(){
        if (instance==null){
            instance= new Change();
      }
    return  instance;
}

 }

// class  C extends  String{} 不能继承

//class A{  不能重写
// final public  void  show(){}
//}
//class  B extends  A{
//    public  void  show(){}
//}