//代码有点多了，请拉至最下面
//对象转型
package charactor;

import charactor1.Support;//使用其他包下的类，必须import

import java.util.Scanner;

public class Hero {
	
	//Hero类饿汉式单例模式
	//private Hero()//1.构造方法私有化
	//{
	//	
	//}
	
	//private static Hero instance = new Hero();//2.静态/类属性指向实例化
	
	//public static Hero getInstance()//3.public static 的getInstance方法,返回第二步的静态属性
	//{
	//	return instance;
	//}
	
	public String name; //姓名  实例属性，对象属性，非静态属性
	
	public float hp; //血量
	
	protected float armor; //护甲
	
	protected int moveSpeed; //移动速度
	
	static String copyright;  //版权    类属性，静态属性
	
	public int maxHp = 9999;//声明该属性的时候初始化
	
	//物品栏的容量
	public static int itemCapacity = 8;//声明的时候初始化
	
	static
	{
		itemCapacity = 6;//静态初始化块  初始化
	}
	
	int killed; //送了多少次
	
	int kill; //杀人次数
	
	int support; //助攻次数
	
	int money; //金钱
	
	int lastHit; //补刀数
	
	int attackSpeed; //攻击速度
	
	String wordAfterKill; //杀人后说的话
	
	String wordAfterKilled; //被杀后说的话
	
	//坑队友
	void keng()
	{
		System.out.println("坑队友！");
	}
	
	//获取护甲值
	float getArmor()
	{
		return armor;
	}
	
	//增加移动速度
	void addSpeed(int speed)
	{
		//在原来的基础上增加移动速度
		moveSpeed = moveSpeed + speed;
	}
	
	//超神
	void legendary()
	{
		System.out.println("超神了");
	}
	
	//获取当前的血量
	float getHp()
	{
		return hp;
	}
	
	//回血
	void recovery(float blood)
	{
		hp = hp + blood;
	}
	
	
	//实例方法、对象方法、非静态方法
	//必须有对象才能够调用
	public void die()
	{
		hp = 0;
		battleWin();//对象方法中可以直接调用类方法
	}
	
	//类方法、静态方法
	//通过类就可以直接调用
	public static void battleWin()
	{
		System.out.println("battle win");
		
	}
	public static void main(String[] args)
	{
		Hero garen = new Hero();
		garen.name = "盖伦";
		garen.hp = 616.28f;
		garen.armor = 27.536f;
		garen.moveSpeed = 350;
		garen.addSpeed(100);
		garen.copyright = "版权由Riot Games公司所有";
		
		Hero teemo = new Hero();
		teemo.name = "提莫";
		teemo.hp = 383f;
		teemo.armor = 14f;
		teemo.moveSpeed = 330;
		
		Scanner s = new Scanner(System.in);
		int a = s.nextInt();
		System.out.println("第一个整数：" + a);
		int b = s.nextInt();
		System.out.println("第二个整数：" + b);
		System.out.println("两个数的和是：" + (a + b));
		System.out.println("比较5>8:" + (a > b));
		System.out.println("比较5>=8:" + (a >= b));
		System.out.println("比较5<8:" + (a < b));
		System.out.println("比较5<=8:" + (a <= b));
		System.out.println("比较5==8:" + (a == b));
		System.out.println("比较5!=8:" + (a != b));
		
		int i = 0;
		while (i < 5)
		{
			System.out.println(i++);
		}
		int m = 1;
		long j = s.nextInt();
		while (j > 0)
		{
			m *= j;
			j--;
		}
		System.out.println(m);
		
		//使用while打印1到4
		int n = 0;
		while (n < 5)
		{
			System.out.println("while循环输出的" + n);
			n++;
		}
		
		int y = 1;
		int sum = 0;
		for(int x = 0; x < 10; x++)
		{
			sum += y;
			y *= 2;
			System.out.println("for循环输出的" + x);
		}
		System.out.println(sum);
		
		for(int t = 1; t < 101; t++)
		{
			if (t % 3 ==0 || t % 5 == 0)
				continue;
			System.out.println(t);
			
		}
		
		for(int q = 0; q < 10; q++)
		{
			if(0 == j % 2)
				break;
			System.out.println(q);
		}
		
		int year1 = 0;
		double f = 1.2;
		for(int year = 1; f < 100; year++ )
		{
			
			int r = year;
			double u;
			for(u = 1.2; r > 0; r--)
			{
				u *= (1 + 0.20);
				
			}
			f += u;
			year1 = year;
		}
		System.out.println(year1);
		System.out.println();
		//float f = 0;  //每年的投资总收益
		//float p = 12000;  //每年的投入
		//int n = 1;    //起始年份
		//float r = 1.2f;   //每年的投资收益率
		//while (f < 1000000)
		//{
		//    f = (int)((f + p)*(1 + r));
		//    System.out.println("第" + n + "年，总收益为：" + f + "元。");
		//    n++;
		//}
		//System.out.println(n - 1);
		
		System.out.println(garen.copyright);
		System.out.println(teemo.copyright);
		
		garen.copyright = "Blizzard Entertainment Enterprise";
		System.out.println(garen.copyright);
		System.out.println(teemo.copyright);
		
		garen.die();//必须有一个对象才能调用
		Hero.battleWin();//无需对象，直接通过类调用
		
		System.out.println(Hero.itemCapacity);
		
		System.out.println();
		
		//枚举
		//增强型for循环遍历枚举类HeroType，把每种枚举常量输出为中文字符串
		for(HeroType heroType:HeroType.values())
		{
			System.out.println(heroType);

			switch(heroType)
			{
			case TANK:
				System.out.println("坦克");
				break;
			case WIZARD:
				System.out.println("法师");
				break;
			case ASSASSIN:
				System.out.println("刺客");
				break;
			case ASSIST:
				System.out.println("辅助");
				break;
			case WARRIOR:
				System.out.println("近战");
				break;
			case RANGED:
				System.out.println("远程");
				break;
			case PUSH:
				System.out.println("推进");
				break;
			case FARMING:
				System.out.println("打野");
				break;
				
			}
		}
		System.out.println();
		
		//普通循环遍历所有枚举常量
		//枚举名.values()这个方法会返回一个装着枚举元素的数组
		for(int k = 0; k < HeroType.values().length; k++)
		{
			HeroType heroType1 = HeroType.values()[k];
			
			switch(heroType1)
			{
			case TANK:
				System.out.println("坦克");
				break;
			case WIZARD:
				System.out.println("法师");
				break;
			case ASSASSIN:
				System.out.println("刺客");
				break;
			case ASSIST:
				System.out.println("辅助");
				break;
			case WARRIOR:
				System.out.println("近战");
				break;
			case RANGED:
				System.out.println("远程");
				break;
			case PUSH:
				System.out.println("推进");
				break;
			case FARMING:
				System.out.println("打野");
				break;
				
			}
			
		}
		
		//用户输入英文，得到相应的中文字符
		System.out.println("print a type:");
		Scanner scan = new Scanner(System.in);
		String type = scan.nextLine();
		
		try
		{
			HeroType heroType2 = HeroType.valueOf(type);
			switch(heroType2)
			{
			case TANK:
				System.out.println("坦克");
				break;
			case WIZARD:
				System.out.println("法师");
				break;
			case ASSIST:
				System.out.println("辅助");
				break;
			case PUSH:
				System.out.println("推进");
				break;
			}
		}
		catch(IllegalArgumentException e)
		{
			System.out.println("没有该类型");
		}
    	
		
		//对象转型
		//明确引用类型与对象转型的概念
		//在这个例子里，有一个对象类型 new ADHero(),同时也有一个引用ad
		//对象是有类型的，是ADHero
		//引用也是有类型的，是ADHero
		//通常情况下，引用类型和对象类型是一样的
		//接下来要讨论的类型转换的问题，指的是引用类型和对象类型不一致的情况下的转换问题
		
		//右边对象的类型转换为左边引用的类型
		ADHero ad = new ADHero();
		
		//子类转父类（向上转型）
		//所谓的转型，是指当引用类型和对象类型不一致的时候，才需要进行类型转换
		//类型转换有时候会成功，有时候会失败（参考基本类型的类型转换）
		//能否转换成功的判别方法：把右边的当作左边来用，看说得通不
		
		//所有的子类转换为父类，都是说得通的
		//苹果手机 继承了 手机， 把苹果手机当作普通手机使用
		//怡宝纯净水 继承了 饮品，把怡宝纯净水当作饮品来使用
		
		//类型转换指的是把一个引用所指向的对象的类型，转换为另一个引用的类型
		//ad引用所指向的对象的类型是ADHero
		//h引用的类型是Hero
		//把ADHero当作Hero使用，一定可以
		
		Hero h = new Hero();
		
		h = ad;//子类转父类，一定行，转换后h引用指向一个ad对象
		//右边ad引用所指向的对象的类型是 物理攻击英雄，左边h引用类型是 普通英雄
		//把物理攻击英雄 当做 普通英雄，说得通，可以转
		
		//父类转子类（向下转型）
		//父类转子类，有的时候行，有的时候不行，所以必须进行强制转换
		//强制转换的意思就是 转换有风险，风险自担
		
		Support s1 = new Support();
		
		ad = (ADHero)h;//父类转子类，要进行强转，此时h这个引用所指向的对象是ADHero		
		h = s1;//转换后，h引用指向一个support对象
		//上面能成功是因为：h现在是指向ADHero，但是h引用类型是Hero
		
		ad = (ADHero)h;//强制转换失败，抛出异常ClassCastException类型转换异常
		
	}
}

      /*
        总结：
                Object obj = new Man();
                obj instanceof Man
            1、等号左边的引用类型，决定了是否编译错误。
               左边的类型和instanceof右边的类有继承关系就可以编译通过
            2、等号右边的对象类型，决定了结果的真假。
               该类型是本类或子类对象都是真，
               如果是父类对象或无继承关系则为假(父类对象不是子类的实例)

         */