static的意思

static的意思

package text1.test2;
/**
 * 栈：局部变量
 * 堆：new出来的结构：对象、数组
 * 方法区：类的加载信息，静态域，常量池
 *
 * 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
 * ③静态方法中，只能调用静态的属性或静态的方法
 * ④非静态方法中的局部可以调用静态方法；
 * ⑤静态可以调用静态，非静态也可以调用静态
 *
 * 5.static注意点：
 * 5.1在静态的方法内，不能使用this关键字、super关键字
 * 5.2关于静态属性和静态方法的使用，大家都从生命周期的角度去理解
 *
 * 6.在开发中：如何确定一个属性是否要声明为static的？
 * 属性是可以被多个对象共享的，不会随着对象的不同而不同的；
 * 操作静态属性的方法，通常设置为static的
 * 工具类中的方法，习惯上声明为static的，比如：Math、Arrays、Collections
 */
public class StaticTest {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.name = "jun";
        c1.age = 13;
        c1.nation = "UOI1";
        System.out.println(c1.age);

        Chinese c2 = new Chinese();
        c2.nation = "UOI2";
        c2.name = "dong";
        c2.age = 30;
        System.out.println(c2.age);
//      静态static
//        System.out.println(c1.nation);
        Chinese.nation = "中国";
        System.out.println(Chinese.nation);

        c2.eat();
        Chinese.show();

    }
}

class Chinese {
    String name;
    int age;
    static String nation;

    public void eat() {
        System.out.println("中国人吃中餐！");
        //调用静态方法
        show();
        //调用静态属性
        System.out.println(Chinese.nation);
        //调用非静态方法
        info();

        System.out.println("nation:" + this.nation);

    }

    public static void show() {
        System.out.println("我是一个中国人!");
        //调用非静态结构
        System.out.println(Chinese.nation);
        //调用静态结构
        walR();
    }

    public void info() {
        System.out.println("name:" + name + ",age:" + age + ",nation:" + nation);
    }

    public static void walR() {
        System.out.println("曹总");
    }
}

饿汉式

package text1.test2;

//单列设计模式
//1.所谓类的单例设计模式，就是采取一定的方法保证在整体的软件系统中，
//对某个类只能存在一个对象实例。
//2.如何实现？
//饿汉式VS懒汉式
//3.区别饿汉式和懒汉式
//饿汉式：
// 坏处：对象加载时间过长
// 好处：饿汉式是线程安全的

//懒汉式：好处：延迟对象的创建
//目前写法坏处，线程不安全

public class SingletonTest1 {
    public static void main(String[] args) {
//        Bank bank =new Bank();
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);
    }
}

//饿汉式
class Bank {
    //1.私有化类的构造器
    private Bank() {

    }

    //2.内部创造类的对象
    //要求此静态也必须声明为静态的
    private static Bank instance = new Bank();

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

懒汉式

package text1.test2;

public class SingletonTest2 {
    public static void main(String[] args) {
        Order order1=Order.getInstance();
        Order order2=Order.getInstance();
        System.out.println(order1==order2);
    }
}

//懒汉式
class Order{
    //1.私有化类的构造器
    private Order(){

    }

    //2.声明当前类的对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance=null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if (instance==null){
            instance=new Order();
        }
        return instance;
    }
}