public class Hero1传参3Text {
    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public Hero1传参3Text(){

    }

    public Hero1传参3Text(String name,float hp){
        this.name = name;
        this.hp = hp;
    }

    //复活
    public void revive(Hero1传参3Text h){
        h = new Hero1传参3Text("提莫",383);
    }/*h = new Hero1传参3Text("提莫",383);相当于重新开辟了一个空间并赋
     值，并不改变原来hp的值*/
    //真正的复活应该是这样的
    public void revive3(Hero1传参3Text h){
        hp = 383;//直接将这hp的地址赋值
    }
    public static void main(String[] args) {
        Hero1传参3Text teemo =  new Hero1传参3Text("提莫",383);

        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;

        teemo.revive(teemo);
        System.out.println(teemo.hp);
        //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？

    }
    /*java值传递：当变量作为参数传递到方法内部时，过程执行的是拷贝，不论方法对形参如何修改，都不会影响实参数据。当变量为类类型时传递，实质传递的是该引用的地址，
    内部对形参修改影响的只是引用的地址新指向，除非修改对象.属性值，才能真正影响外部实参。*/
    public void revive1(Hero1传参3Text h){
        System.out.println(h.hp);

        //比较以下两段
    /*
        h = new Hero("提莫",383);
        //h又新开辟一片空间，指向了另一个对象；这片空间的h.hp从-17变为383，而这个h.hp另一片空间的
        System.out.println(h.hp);
    */

        h.hp= 383;//引用传递首地址  的改变; 即指向同一个对象
    }
}

public class Test12 {
    String name; //姓名
 
    float hp; //血量
 
    float armor; //护甲
 
    int moveSpeed; //移动速度
 
    public Test12 (){
 
    }
 
    public Test12 (String name,float hp){
        this.name = name;
        this.hp = hp;
    }
 
    //虚假的复活
    public void revive(Test12  h){
        h = new Test12 ("提莫",383);
    }
    //真实的复活
    public void revive2(Test12  h){
       this.hp = 383;
    }
 
 
    public static void main(String[] args) {
        Test12  teemo =  new Test12("提莫",383);
 
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
 
        teemo.revive2(teemo);
 
        //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？
        System.out.println(teemo.hp);
    }
}

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 = new Hero("提莫", 383);
	}
	
	public static void main(String[] args) {
		Hero teemo = new Hero("提莫", 383);
		System.out.println(teemo.hp);
		//受到400点的伤害,teemo挂了
		teemo.hp = teemo.hp - 400;
		if(teemo.hp < 0)
			teemo.hp = 0;
		System.out.println(teemo.hp);
		teemo.revive(teemo);
		System.out.println(teemo.hp);  
		//方法内可以通过方法改变方法内的类型参数;无法改变方法外的类型参数
	}

package JIchuDome;
/**为Hero设计4个参数的构造方法
 这四个参数分别是
 String heroName
 float heroHP
 float heroArmor
 int heroMoveSpeed
 */
public class Hero {
    String name; //姓名

    float HP; //血量

    float Armor; //护甲

    int MoveSpeed; //移动速度

    public Hero(String name, float HP, float Armor, int MoveSpeed) {
        this.name = name;
        this.HP = HP;
        this.Armor = Armor;
        this.MoveSpeed = MoveSpeed;
    }

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

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

package JIchuDome;

public class Test {
    public static void main(String[] args) {
        Hero teemo = new Hero("提莫",383,0,250);
        //提莫受到400伤害。挂了
        teemo.HP=teemo.HP-400;

        teemo.revive(teemo);
        System.out.println(teemo);//用了toString方法
    }
}

package Seven;

public class Test12 {
    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public Test12 (){

    }

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

    //虚假的复活
    public void revive(Test12  h){
        h = new Test12 ("提莫",383);
    }
    //真实的复活
    public void revive2(Test12  h){
       this.hp = new Test12("提莫",383).hp;
    }


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

        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;

        teemo.revive2(teemo);

        //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？
        System.out.println(teemo.hp);
    }
}

//复活那段代码
    public void revive(Hero h){
    	System.out.println(h.hp);
    	
    	//比较以下两段
    /*   	
    	h = new Hero("提莫",383);
    	//h又新开辟一片空间，指向了另一个对象；这片空间的h.hp从-17变为383，而这个h.hp另一片空间的
    	System.out.println(h.hp);
    */	
    	
    	h.hp= 383;//引用传递首地址  的改变; 即指向同一个对象
    }

/**
	 * 在方法中，使参数引用指向一个新的对象
	 * 外面的引用是指向原来的对象？还是新的对象？
	 * (指向的是原来的对象，按照代码的执行顺序来看，先进的main方法，在main方法中
	 * 调用了复活的这个方法，使他的参数指向了teemo这个地址值)
	 * 
	 * 问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？
	 * 输出17.0
	 * (首先，创建了Hero的带参对象，对象名调用了hp - 400 赋值给了变量 hp
	 * 相当于 变量hp(383) = 变量hp(383 - 400)  也就等于-17.0  ， 
	 * 可以当成一个赋值运算符的详细版  (teemo.hp -= 400;)   下面随后调用了
	 * 复活的方法，把teemo这个对象名传了进去（传入了一个地址值），相当于就是
	 * 让复活方法参数里的对象引用指向了 teemo这个地址值，对hp的影响没有变化
	 * 所以说还是输出17.0)
	 * 
	 * 
	 * */

public Hero(String name,float hp){
		     this.name = name;
		        this.hp = hp;
		    }
		 
		    //复活
		    public void revive(Hero h){
		        h = new Hero("提莫",383);
		        this.hp =h.hp; 
		        
		    }
		 
		    public static void main(String[] args) {
		        Hero teemo =  new Hero("提莫",383);
		         
		        //受到400伤害，挂了
		        teemo.hp = teemo.hp - 400<=0?0:teemo.hp-400;
		        System.out.println(teemo.name+"的血量为："+teemo.hp+"已阵亡");
		       System.out.println(teemo);
		        
		        teemo.revive(teemo);
		        System.out.println(teemo.name+"的血量为："+teemo.hp+"已复活"); //输出多少？ 怎么理解？
		        System.out.println(teemo); 
		    }

public class Hero {
    String name;
    float hp;
    float armor;
    int moveSpeed;

    public Hero(String name,float hp,float armor,int moveSpeed){
        this(name,hp);
        this.armor = armor;
        this.moveSpeed = moveSpeed;
    }
    public Hero(){
    }
    public Hero(String name,float hp){
        this.name = name;
        this.hp = hp;
    }
    public void revive(Hero h){
        h = new Hero("提莫",383);
        h.hp = 12f;
        System.out.println("revive复活后："+h.hp);
        System.out.println("h地址："+h);
        System.out.println();
    }

    public void revive2(Hero h){
        h.hp = 1f;
        System.out.println("revive2复活后："+h.hp);
        System.out.println("h地址："+h);
        System.out.println();
    }


    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
        System.out.println("复活之前:"+teemo.hp);
        System.out.println();
        System.out.println("teemo地址:"+teemo);
        teemo.revive(teemo);

        System.out.println(teemo.hp); //输出多少？ 怎么理解？
        System.out.println("teemo地址:"+teemo);
        teemo.revive2(teemo);
        System.out.println(teemo.hp);


    }
}

package test;


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 Hero revive(Hero h){
    	h = new Hero("提莫",383);
    	return h;
    }

    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);
        
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
        
        teemo = teemo.revive(teemo);
        System.out.println(teemo.hp);//383
        //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？
        
    }
     
}

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){//31行跳转21行调用revive的时候，引用h指向 引用teemo所指向的对象 "提莫"
        h = new Hero("提莫",383);//在第22行方法体内，引用h指向了一个新的对象 “新的提莫”，原引用h指向引用teemo所指向的对象"提莫"将失效，引用h改为指向新的对象，所以引用teemo所指的原有的对象"提莫"没有任何修改
    }
 
    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);
         
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
         
        teemo.revive(teemo);//在第31行，调用revive的时候，引用h指向 引用teemo所指向的对象 "提莫"
        System.out.println(teemo.hp);//输出-17.0
         
        //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？
        teemo.revive1(teemo);
        System.out.println(teemo.hp);//输出383
    }
    //复活（正确复活方法，要在原有的对象"提莫"上做修改）
    public void revive1(Hero h){//调用revive1的时候，引用h指向 引用teemo所指向的对象 "提莫"，引用h和引用teemo指向同一个对象"提莫"
    	h.hp=383;//引用h和引用teemo指向同一个对象"提莫",引用h修改对象"提莫"hp属性，则对象"提莫"hp属性就为383，所以teemo.hp输出为383（原地满血复活）
    }     
}

public class Hero {   
    String name; 	//姓名        
    float hp; 	//血量        
    public Hero(String name,float hp){
        this.name = name;
        this.hp = hp;
    }

    public void revive(Hero h){	   //复活
    	h.hp = 98;
    	h.name = "k.o.";
    }
    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);     
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400; 
        System.out.println("teemo.hp = "+teemo.hp);
        
        teemo.revive(teemo);
//问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？    
        System.out.println("teemo.hp = "+teemo.hp);
        System.out.println("teemo.name = "+teemo.name);
    }
}
//结果：
/*
 * teemo.hp = -17.0
 * teemo.hp = 98.0
 * teemo.name = k.o.
 */
/*
我的理解：

开始执行 revive(teemo) 时，Hero h ---> teemo

然后通过 h.hp 来访问 h 所指向的对象，并用
= 98; 来修改 teemo 的属性

但执行完 revive(teemo) 后，实参 teemo 的属性确实
发生了改变
这与 C 语言中向被调函数传递地址很像，或者说
开始执行 revive(teemo) 时，传递出去的 teemo 其实是
一个内存地址
*/

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 float revive(float h) {
        h = new Hero("提莫", 383).hp;
        return h;//返回满血提莫的血量
    }

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

        // 受到400伤害，挂了
        teemo.hp = teemo.hp - 400;

        teemo.hp = teemo.revive(teemo.hp);//返回满血提莫的血量，对提莫的血量进行赋值

        // 问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？
        System.out.println(teemo.hp);
    }

}

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 Hero revive(Hero h){
        h = new Hero("提莫",383);
		return h;
    }
    public static void main(String[] args) {
        Hero teemo =  new Hero("提莫",383);
         
        //受到400伤害，挂了
        teemo.hp = teemo.hp - 400;
         
        Hero h=teemo.revive(teemo);
         
         System.out.println(h.hp); 
         
         
    }

}

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.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); 输出多少？ 怎么理解？
         
    }
      
}
 步骤 5 : 答案-传参