java-static关键字、代码块与final关键字

static关键字

static可以用来修饰哪些：

• 属性
• 方法
• 代码块
• 内部类

static修饰属性

1. 用static修饰的属性叫做静态属性，又叫做静态变量、类变量；

• 创建了类的多个对象，多个对象共享一个静态变量，修改静态变量时，会导致其他对象调用的此静态变量是修改后的。

2. 没用static修饰的属性叫做非静态属性，又叫做实例变量；

• 创建了类的多个对象，每个对象有独立的非静态属性，修改其中一个对象的非静态属性，不会改变其他对象的非静态属性

		Account.setInterestRate(1.23);
        ac1.setInterestRate(0.089);
        System.out.println(Account.getInterestRate());//0.089

静态变量的特点

1. 静态变量随着类的加载而加载，可以通过“类.静态变量”的方式进行调用；
2. 静态变量的加载早于对象的创建；
3. 静态变量在内存中只会存在一份，存在于方法区的静态域中；

判断属性是否可以声明为static

• 属性可以被多个对象共享时，不会随对象的不同而不同时，可以声明为static属性

    private int id;
    private String pwd="000000";
    private double balance;
    private static double interestRate;
    private static double minMoney=1.0;

static修饰方法

1. 操作静态变量的方法，一般声明为static；

    public static double getInterestRate() {
        return interestRate;
    }

    public static void setInterestRate(double interestRate) {
        Account.interestRate = interestRate;
    }

2. 工具类中的方法，习惯声明为static，可以类.方法直接调用。比如：Math、Arrays等。

        List list=Arrays.asList(new Integer[]{1,2,3,4});

单例模式

所谓的单例模式，就是采取一定的方法保证类在程序中只存在一份实例，而不会创建多个实例。单利模式有两种模式一种是饿汉模式，一种是懒汉模式

饿汉模式

class Bank{
    private Bank() {
    }

    private Bank instance=new Bank();

    public Bank getInstance(){
        return instance;
    }
}

懒汉模式

class Order{
    private Order(){

    }
    private static Order instance=null;
    public  Order getInstance(){
        if(instance==null){
            instance=new Order();//饿汉式
        }
        return instance;
    }
}

饿汉模式和懒汉模式的区别

• 饿汉式：对象加载时间过长；是线程安全的；
• 懒汉式：延迟对象的创建；目前的写法是线程不安全的；

单例模式的应用场景

• 网站计数器；
• 应用程序的日志应用；
• 数据库连接池设计；
• 读取配置文件的类等等

代码块

• 代码块的作用：初始化类、对象
• 代码块分为静态代码块和非静态代码块

静态代码块

• 内部可以有输出语句；
• 随着类的加载而执行，只执行一次；
• 作用：初始化类的信息；
• 多个静态代码块按照声明的先后顺序执行；
• 静态代码块的执行优先级高于非静态代码块；
• 静态代码块只能调用静态属性、静态方法，不能调用非静态结构；

    //静态代码块
    static {
        System.out.println("这是一个静态代码块");
        contry="CHN";
        getInfo();
    }

非静态代码块

• 内部可以有语句输出；
• 随着对象的创建而执行；
• 每创建一个对象，就执行一次非静态代码块；
• 作用：在创建对象时对对象的属性进行初始化；
• 多个非静态代码块按照声明的先手顺序执行；

    //静态方法
    private static void  getInfo(){
        System.out.println("这是静态方法getInfo");
    }

    //非静态方法
    private  void  getInfo1(){
        System.out.println("这是非静态方法getInfo");
    }

   //非静态代码块
    {
        System.out.println("这是一个非静态代码块");
        name=null;
        age=0;
        isMale=2;
        contry="RIBEN";
        getInfo();
        getInfo1();
        System.out.println(toString());
        System.out.println(getAge());

    }

final关键字

final关键字可以用来修饰：类、方法、变量

final修饰类

• final修饰类不能被其他类继承。如：String类、System类、StringBuffer类

final修饰方法

• final修饰的方法不能被重写。比如：Object类中的getClass()；

final修饰变量

• 被final修饰的变量成为一个常量
• 修饰属性：显示初始化、代码块中初始化、构造器中初始化

    private final int WIDTH=0;
    private final int HEIGH;
    private final int RIGHT;

    {
        HEIGH=100;
    }

    public FinalA() {
        RIGHT=200;
    }

    public FinalA(int RIGHT) {
        this.RIGHT = RIGHT;
    }

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

    public  void  eat(final String food){
//        food="ddd";//不能被再赋值
        final String ANIMAL="CAT";
//        ANIMAL="DOG";//不能被再赋值
        System.out.println(food);
    }

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