Java基础-static关键字和单例模式

时间 2019-12-02

原文原文链接

static关键字

static关键字的特色java
1. 用来修饰类的成员-修饰成员变量的称之为类变量(静态变量),修饰成员方法的称之为类方法(静态方法)。(属性拿static修饰完以后就不叫属性了,他也就不属于任何对象了，而是属于多个对象共享的，就叫类变量或静态变量，方法也同样)bash
2. 当类被加载的时候就会被加载，优先于对象的存在。ui
3. 用来修饰与语句块-称之为静态代码块。先于构造方法以前执行，只会执行一次。用来对静态成员作初始化this
4. 静态修饰的成员被全部的对象共享spa
5. 调用的时候能够直接经过类名.成员来进行访问。code
static关键字注意事项视频

1.静态方法中只能访问外部的静态成员 (为何？当咱们去调用静态方法的时候，对象都没产生，对象没产生怎么可能有属性呢，由于属性是属于某个对象的对吧) 2.静态方法中不能出现this关键字 (为何？一样的道理，当咱们去调用静态方法的时候，对象都没产生，对象没产生this又是指谁呢？)对象

ok 上代码！生命周期

public class StaticDemo {


    public static void main(String[] args)
    {
        Device device1 = new Device();
        device1.showName();
        device1.showEnergy();
        Device device2 = new Device();
        device2.energy++;
        device2.showName();
        device2.showEnergy();
    }
}

class Device
{
    private String name="device1";//普通的属性
    public int energy=2;//普通的属性

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getEnergy() {
        return energy;
    }

    public void setEnergy(int energy) {
        this.energy = energy;
    }

    public void showName()
    {
        System.out.println(name);
    }

    public void showEnergy()
    {
        System.out.println(energy);
    }
}
复制代码

看下输出结果:内存

device1
2
device1
3
复制代码

ok,如今分析下，我第一个对象的energy属性初始值时2,第二个对象的energy属性我用public修饰了，因此我直接能够调用下，而后加一了，打印出来的结果两个对象是不同的。这就说明了什么？每一个对象都有他本身的独立的一份属性。对不对？~对的哈。。这句话很重要~~

那我如今若是把name这个属性改为用static来修饰的话，如今会怎么样? public static String name="device1";//静态变量,他如今不属于任何一个对象了，被多个对象共享，他如今是属于类的，他也称为类变量

如今咱们把调用方法改为这样

public static void main(String[] args)
    {
        Device device1 = new Device();
        device1.name = "cyy";
        device1.showName();
        device1.showEnergy();
        Device device2 = new Device();
        device2.energy++;
        device2.showName();
        device2.showEnergy();
    }
复制代码

如今name不是个属性了，他如今是个静态变量,我在device1里面把他设置成cyy,如今打印结果来看下。

cyy
2
cyy
3
复制代码

看到没两个name都变成cyy了。这说明了什么？这是否是说明了，这个name你们都共享了呀，再也不是每一个对象独立拥有的了，对吧！那既然他都不是共享的了，那咱们访问的时候是否是就能够直接Device.name就能够了啊，由于他如今不属于对象了，他如今属于类的。而age可不能够直接经过Device.age来访问啊，固然不能够，由于他如今并不属于类对吧。

好的，如今若是咱们把一个方法改为静态的呢，好比这样：

public static void showName()
{
    System.out.println(energy);
    System.out.println(name);
}
复制代码

若是这么写的话，是否是会报错呀，编译时就会报错，会提示： Non-static field 'energy' cannot be referenced from a static context

什么意思?大概意思就是说，你静态方法不能访问非静态变量~为何？！由于你静态方法调用的时候，尚未建立对象呢，人家energy是个属性，又不是静态变量，你会跑的时候，人家还没出生呢，你咋能去找人家玩儿呢？对吧，因此静态方法不能访问非静态变量，静态方法中不能使用this，只能访问外部静态的东西。

那非静态方法可不能够访问静态变量?思考一下？答案固然是能够的，想像一下，静态变量在你对象建立以前就已经分配好内存空间了，已经存在了，你对象建立完以后，他已经存在了，因此确定是能够访问的，对吧。总结就是静态的只能访问静态的，非静态的均可以访问。

还有个static语句块

他何时执行呢？

在类被加载的时候就会执行，只会执行一次，用来对静态变量进行初始化。优先于构造方法的执行。

上代码：

class Device
{
    public static String name;//普通的属性
    public int energy=2;//普通的属性

    //static语句块
    static {

        name = "device1";
        System.out.println("===我是静态语句块里的"+name);
    }

    //构造方法
    public Device(String name)
    {
        this.name = name;
        System.out.println("===我是构造方法里的"+name);
    }


    public static void showName()
    {
        System.out.println(name);
    }

    public void showEnergy()
    {
        System.out.println(energy);
    }
}

复制代码

咱们如今使用下：

Device device1 = new Device("cyy");
        Device device2 = new Device("cyy513");
复制代码

看下打印结果:

===我是静态语句块里的device1
===我是构造方法里的cyy
===我是构造方法里的cyy513
复制代码

发现了吧,我new了两个对象，可是静态语句块里的system.out.println只打印了一次，说明啥static语句块只执行一次，无论你建立多少次对象。并且我是先于构造方法执行的。

那会有人说，那我之后都不用属性了，我所有用static变量，多好，多方便，其实这样有不少缺点:

破坏了java面向对象的封装性
static变量的生命周期比较长，程序结束的时候，他的内存才会释放，而属性呢，这个对象运行完了他的属性内存是否是就释放了呀。

那咱们何时用static呀？

当咱们一个类里面，没有任何属性，只有方法，而这个方法是为其余的类服务的，这个时候适合用static的。

单例模式

定义：

顾名思义，单例模式的意思就是只有一个实例，单例模式确保某一个类只有一个实例，并且自行实例化并为整个系统提供这个实例，这个类称为单例类。

通俗的说，就是我有一个类，整个系统就一个实例，并且他是本身建立本身，他必须对外提供个方法，把我本身给你。

上代码：

class SingleTon
{

    private SingleTon singleTon = new SingleTon();

    /**
     * 构造方法必定不能是公开的，否则别人就能够随便构造了。
     * 因此构造方法必须是private，对吧
     */
    private SingleTon()
    {

    }
    //若是我这么写，会出现什么问题
    public static SingleTon getInstance()
    {
        return singleTon;
    }
}
复制代码

是否是会出现以前说的那种错误呀，静态方法不能引用非静态变量。对不对。因此要怎么作？是否是给前面singleton加上个static就能够了是吧。由于这个SingleTon是静态的在内存里只有一份对吧~正确写法，

class SingleTon
{

    public static SingleTon singleTon = new SingleTon();
    private SingleTon()
    {}
 
    public static SingleTon getInstance()
    {
        return singleTon;
    }
}
复制代码

这种方式称之为饿汉式。为何？由于我在调用getInstance()以前这个对象是否是就已经产生了呀，由于它是静态的嘛，在类加载时候，就已经new SingleTon()了呀。那咱们如今有没有更好的方法呢？好比在getInstance()的时候再去建立这个对象呀?固然能够呀~这么写就能够了.

class SingleTon
{

    public static SingleTon singleTon = null;

    /**
     * 构造方法必定不能是公开的，否则别人就能够随便构造了。
     * 因此构造方法必须是private，对吧
     */
    private SingleTon()
    {

    }
    //若是我这么写，会出现什么问题
    public static SingleTon getInstance()
    {
        if (singleTon==null)
        {
            singleTon = new SingleTon();
        }
        return singleTon;
    }
}
复制代码

这种就是懒汉式加载。

不论是懒汉式仍是饿汉式，是否是目的就是一个，让他整个系统中只有一个实例。

ok，结束~ 后续我会继续更新，Android自定义View,Android NDK，音视频方向的文章，欢迎你们关注，共同进步。