Java基础学习day13【谷】

Java基础学习day13

static关键字的使用

1.static:静态的
2.static可以用来修饰：属性、方法、代码块、内部类
3.使用static修饰属性：静态变量（或类变量）
3.1属性，按是否使用static修饰，又分为：静态属性Vs非静态属性（实例变量）
实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过的。
3.2static修饰属性的其他说明：

​ ① 静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用

​ ②静态变量的加载要早于对象的创建

​ ③由于类只会加载一次，则静态变量在内存中也只存在一份：存在的方法区的静态域中

​ ④ 类变量 实例变量

​ 类 yes no

​ 对象 yes yes

声明周期不同

4.使用static修饰方法：：静态方法
①随着类的加载而加载，可以通过"类，静态方法“的方式进行调用
② 静态方法 非静态方法
类 yes no
对象 yes yes
③静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
5.static注意点：
5,1在静态的方法内，不能使用this关键字、super:关键字
5,2关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

6.开发中，如何确定一个属性是否要声明为static的？

​ 属性被多个类所共享的，不会随着对象的不同而改变的

​ 类中的常量也常常声明为static 如Math.PI

​ 操作静态属性的方法，通常设置为static的

​ 工具类中的方法，习惯上声明为static的。如Math Array Collections

static练习

编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”，
定义封装这些属性的方法。账号要自动生成。
编写主类，使用银行账户类，输入、输出3个储户的上述信息。
考虑：哪些属性可以设计成static属性。

Account类

public class Account {
    private long id;
    private String pwd;
    private double balance;
    public static long init = 1234565432100L;
    private static double lx;
    private static double min;

    public Account(String pwd, double balance) {
        this();
        this.pwd = pwd;
        this.balance = balance;
    }

    public Account() {
        id += init;
        init++;
    }

    public long getId() {
        return id;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public static double getLx() {
        return lx;
    }

    public static void setLx(double lx) {
        Account.lx = lx;
    }

    public static double getMin() {
        return min;
    }

    public static void setMin(double min) {
        Account.min = min;
    }

}

AccountTest类

public class AccountTest {
    public static void main(String[] args) {
        Account account = new Account("123", 50000);
        Account account1 = new Account("123321", 5000);
        Account account2 = new Account("123111", 1000);
        Account.setLx(0.0112);
        Account.setMin(20.0);
        System.out.println(account.getBalance()+"\t"+account.getPwd()+"\t"+account.getLx()+"\t"+account.getMin()+"\t"+account.getId());
        System.out.println(account1.getBalance()+"\t"+account1.getPwd()+"\t"+account1.getLx()+"\t"+account1.getMin()+"\t"+account1.getId());
        System.out.println(account2.getBalance()+"\t"+account2.getPwd()+"\t"+account2.getLx()+"\t"+account2.getMin()+"\t"+account2.getId());

    }
}

单例设计模式（singleton）

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例

懒汉式

好处：线程安全

坏处：对象加载时间过长

class Bank{
    //1.私有化类的构造器
    private Bank() {
    }
    //2.内部创建类的对象
    //4.此对象也必须声明为静态的
    private static Bank bank=new Bank();

    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance(){
        return bank;
    }
}

懒汉式

好处：延迟对象的创建

坏处：线程不安全

class Bank{
    //1.私有构造器
    private Bank() {
    }
    //2.创建私有对象为null
    //4.静态方法只能调用静态类
    private static Bank bank= null;

    //3.构造对象方法
    public static Bank getInstance(){
        if(bank==null){
            bank=new Bank();
        }
        return bank;
    }
}

main

main()方法的使用说明：
1.main()方法作为程序的入口
2.main()方法也是一个普通的静态方法
3.main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner)

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

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

4.静态代码块

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

5.非静态代码块

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

由父及子，静态先行

对属性可以赋值的位置：

①默认初始化
②显式初始化/⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过“对象，属性“或“对象，方法“的方式，进行赋值
执行的先后顺序：@-②/⑤-③-④

final:最终的

1.final可以用来修饰的结构：类、方法、变量
2.final用来修饰一个类：此类不能被其他类所继承。比如：String类、System类、StringBuffer类
3.final用来修饰方法：表明此方法不可以被重写
比如：Object:类中getClass();
4.final用来修饰变量：此时的"变量"就称为是一个常量
4.1final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化

​ 4.2final修饰局部变量：

​ 尤其是使用final修饰形参时，表明此形参时一个常量。当我们调用此方法时候，给常量形参赋一个实参，一旦赋值之后，只能使用此常量形参，不可以修改此形参
static final 用来修饰属性：全局变量

---

！！！方法不可以进行常量的初始化！！！

---