可以避免由于instance为空导致的空指针异常

package JIchuDome;
/**为Hero设计4个参数的构造方法
 这四个参数分别是
 String heroName
 float heroHP
 float heroArmor
 int heroMoveSpeed
 */
public class Hero {
    //构造方法私有化，外部无法访问，
    private Hero(){

    }
//准备类属性，指向实例化对象
    private static Hero hero = new Hero();
//提供给调用者获取类对象方法
    public static Hero getHero(){
        return hero;
    }
    String name; //姓名

    float HP; //血量

    float Armor; //护甲

    int MoveSpeed; //移动速度



    @Override
    public String toString() {
        return "Hero{" +
                "name='" + name + '\'' +
                ", HP=" + HP +
                ", Armor=" + Armor +
                ", MoveSpeed=" + MoveSpeed +
                '}';
    }

    //复活方法
    public void revive(Hero h){
        this.HP=383;
    }
}

=============================================================================================================================
package JIchuDome;

public class Item {
    //构造方法私有化，进行实例化
    private Item(){

    }
    //准备类属性，指向一个实例化对象，但是暂时指向null
    private static Item item;
    //返回实例化对象
    public static Item getItem(){
        //第一次访问时，没有实例化对象，创建实例化对象
        if (item == null) {
            item = new Item();
        }
        //返回实例化对象
        return item;
    }
    String name;
    int price;
}

package charactor;
/*
* package charactor;

public class GiantDragon {

    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){
    }

    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;

    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }

}*/
/*使用饿汉式单例模式, 把Hero类改造成为单例模式

使用懒汉式单例模式，把Item类改造成为单例模式*/
public class Item {
    String name;
    int price;
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private Item(){
    }
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static Item instance;
    //public static 方法，返回实例对象
    public static Item getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new Item();
        }
        //返回 instance指向的对象
        return instance;
    }

    public static void main(String[] args) {
        Item potion = new Item();
        potion.name= "血瓶";
        potion.price =50;

        Item shoe = new Item();
        shoe.name= "草鞋";
        shoe.price =300;

        Item sword = new Item();
        sword.name= "长剑";
        sword.price =350;

    }
}

package charactor;
  
public class GiantDragon {
  
    private GiantDragon(){       
    }
   
    private volatile static GiantDragon instance;
       
    public static GiantDragon getInstance(){
        if(null==instance){
           synchronized (GiantDragon.class) {
                if(instance ==null){
                    instance = new GiantDragon();
                }
            }
        }
        return instance;
    }
       
}

public class Lhan {//懒汉单例，调用才创建单例
    private Lhan(){}
    private static Lhan guaishou;//要声明为类属性(静态属性)
    public static Lhan getLhan(){
        if(guaishou == null){//如果怪兽没有实例化将会new一个出来，否则直接返回已创建的单例
            guaishou =  new Lhan() ;
            return guaishou;
        }
        else
            return guaishou;
    }
    public static void main(String[] args){
            System.out.println("刷出怪兽！");
            getLhan();
    }
}