零基础学JAVA DAY7

今天是周五，明天就是周末啦，爽哦。这一周把JAVA的基础算是学完了，搞明白了很多之前不懂得东西，嘿嘿嘿，怪我之前不好好学习哦。就这样，不多写了，洗个脸睡觉去，明天恰火锅。

/**
 * 在方法中，使参数引用指向一个新的对象
 *
 * 外面的引用是指向原来的对象？还是新的对象？
 */
public class Hero {

    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public Hero(){

    }

    public Hero(String name,float hp){
        this.name = name;
        this.hp = hp;
    }

    //复活
    public void revive(Hero h){
        //此时方法内的h指向Hero对象，开辟了一块新的内存，并不是teemo所指向的内存
        h = new Hero("提莫",383);
        //h.hp = 383; 这样的话不重新引用对象，对应的方法内直接修改传入参数的属性或者调用方法，参数就传过去了
    }

    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);

        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
        //调用方法后内存指向发生变化了
        teemo.revive(teemo);

        System.out.println(teemo.hp);

    }
}

package charactor;

/**
 * 对象属性的初始化有三种方式
 * 故意把初始化块，放在构造方法下面，问题：
 *
 * 这三种方式，谁先执行？谁后执行？
 * （静态变量、静态初始化块）>（变量、初始化块）>构造器
 * 最后执行的是构造器初始化
 */
public class Hero {
    public String name = "声明初始化";

    public Hero(){
        name = "构造器初始化";
    }
    {
        name = "初始化块";
    }

    public static void main(String[] args) {
        Hero hero = new Hero();
        System.out.println(hero.name);
    }
}

饿汉式

package charactor;

/**
 * 　　1、单例类只能有一个实例。
 * 　　2、单例类必须自己创建自己的唯一实例。
 * 　　3、单例类必须给所有其他对象提供这一实例。
 */
public class GiantDragon {
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){

    }
    //饿汉式单例类.在类初始化时，已经自行实例化
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
    public static GiantDragon instance = new GiantDragon();

    //public static 方法，提供给调用者获取定义的对象
    public static GiantDragon getInstance(){
        return instance;
    }

}

package charactor;

public class TestGiantDragon {
    public static void main(String[] args) {
        //通过new实例化会报错
        // GiantDragon g = new GiantDragon();

        //只能通过getInstance得到对象
        GiantDragon dragon1 = GiantDragon.getInstance();
        GiantDragon dragon2 = GiantDragon.getInstance();
        GiantDragon dragon3 = GiantDragon.getInstance();

        System.out.println(dragon1 == dragon2);
        System.out.println(dragon2 == dragon3);

    }
}

懒汉式

package charactor;

/**
 * 　　1、单例类只能有一个实例。
 * 　　2、单例类必须自己创建自己的唯一实例。
 * 　　3、单例类必须给所有其他对象提供这一实例。
 */
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;
    }

}

package charactor;

public class TestGiantDragon {
    public static void main(String[] args) {
        //通过new实例化会报错
        // GiantDragon g = new GiantDragon();

        //只能通过getInstance得到对象
        GiantDragon dragon1 = GiantDragon.getInstance();
        GiantDragon dragon2 = GiantDragon.getInstance();
        GiantDragon dragon3 = GiantDragon.getInstance();

        System.out.println(dragon1 == dragon2);
        System.out.println(dragon2 == dragon3);

    }
}

单例模式三元素

构造方法私有化
静态属性指向实例
public static的 getInstance方法，返回第二步的静态属性

{
    public static void main(String[] args) {
        for (HeroType heroType : HeroType.values()){
            switch (heroType){
                case ASSASSIN:
                    System.out.println(heroType+" 刺客");
                    break;
                case ASSIST:
                    System.out.println(heroType+" 辅助");
                    break;
                case FARMING:
                    System.out.println("打野");
                    break;
                case PUSH:
                    System.out.println("推进");
                    break;
                case RANGED:
                    System.out.println("远程");
                    break;
                case TANK:
                    System.out.println("坦克");
                    break;
                case WARRIOR:
                    System.out.println("近战");
                    break;
                case WIZARD:
                    System.out.println("法师");
                    break;
            }
        }
    }
}

子类转父类(向上转型)
所谓的转型，是指当引用类型和对象类型不一致的时候，才需要进行类型转换
类型转换有时候会成功，有时候会失败(参考基本类型的类型转换)

到底能否转换成功？教大家一个很简单的判别办法
把右边的当做左边来用，看说得通不

Hero h = new Hero();
ADHero ad = new ADHero();
h = ad;

右边ad引用所指向的对象的类型是物理攻击英雄
左边h引用的类型是普通英雄
把物理攻击英雄当做普通英雄，说不说得通？说得通，就可以转

所有的子类转换为父类，都是说得通的。
苹果手机继承了手机，把苹果手机当做普通手机使用
怡宝纯净水继承了饮品，把怡宝纯净水当做饮品来使用

父类转子类(向下转型)
父类转子类，有的时候行，有的时候不行，所以必须进行强制转换。
强制转换的意思就是转换有风险，风险自担。

对象的转型spring要用到许多，此时暂时不接触。等需要了回头再来看。目前先理解基本的概念，实例等日后再练习。