HOW2J.CN - 学习笔记（类和对象）

引用

引用的概念，如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。

1. 引用和指向

new Hero();

代表 创建 了一个Hero对象

但是也仅仅是创建了一个对象，没有办法访问它

为了访问这个对象，会使用 引用 来 代表 这个对象

Hero h = new Hero();

h这个遍历是Hero类型，又叫做引用

=的意思指的h这个引用 代表 右侧创建的对象

“代表” 在面向对象里，又叫做“指向”

public class Hero {
     
    String name; // 姓名   
    float hp; // 血量  
    float armor; // 护甲  
    int moveSpeed; // 移动速度 
    public static void main(String[] args) {
   
        // 创建一个对象
        new Hero();     
        // 使用一个引用来指向这个对象
        Hero h = new Hero();   
    }   
}

2. 多个引用，一个对象

引用有多个，但是对象只有一个。

在这个例子里，所有引用都指向了同一个对象。

对象就像房产，引用就像房产证

房产证的复印件可以有多张，但是真正的房产只有这么一处

public class Hero {
    
    String name; // 姓名   
    float hp; // 血量   
    float armor; // 护甲 
    int moveSpeed; // 移动速度 
    
    public static void main(String[] args) {
       
        // 使用一个引用来指向这个对象
        Hero h1 = new Hero();
        Hero h2 = h1;  // h2指向h1所指向的对象
        Hero h3 = h1;
        Hero h4 = h1;
        Hero h5 = h4;     
        // h1,h2,h3,h4,h5 五个引用，都指向同一个对象       
    }        
}

3. 一个引用，多个对象

Hero garden = new Hero(); 引用garen指向新创建的对象（对象1）

garen = new Hero(); 同一个引用garen指向新创建的对象（对象2）

这个时候，对象1，就没有任何引用指向了

换句话说，就没有任何手段控制和访问该对象，那么该对象就变得没有意义。

public class Hero {
   
    public String name;
    protected float hp;
    
    public static void main(String[] args) {
   
    	Hero garen = new Hero();
		garen = new Hero();
    }  
}

4. 练习 - 引用

如代码问题：

h4所指向的对象和h2所指向的对象，是否是同一个对象？

public class Hero {
   
    public String name;
    protected float hp;
  
    public static void main(String[] args) {
   
           Hero h1 =  new Hero();
           Hero h2 =  new Hero();
           Hero h3;
           Hero h4;
           h3 = h1;
           h4 = h3;
    }
}

h4 指向 h3，最终间接地指向了对象1
而h2指向的是对象2，所以h4和h2不是指向同一个对象

---

继承

在LOL中，武器是物品的一种，也是有名称和价格的

所以在设计类的时候，可以让武器继承物品，从而继承名称和价格属性

1. 物品类 Item

物品类Item，有属性name、price

public class Item {
   
	String name;
	int price;
}

2. 武器类 Weapon（不继承）

武器类：Weapon 不继承Item 的写法

独立设计 name和price属性

同时多了一个属性 damage 攻击力

public class Weapon {
   
	String name;
	int price;
	int damage; // 攻击力
}

3. 武器类 Weapon（继承类Item）

这一次Weapon 继承Item

虽然Weapon自己没有设计name和price，但是通过继承Item类，也具备了name和price属性

public class Weapon extends Item {
   
    int damage; // 攻击力

    public static void main(String[] args) {
   
        Weapon infinityEdge = new Weapon();
        infinityEdge.damage = 65; // damage属性在类Weapon中新设计的
        infinityEdge.name = "无尽之刃"; // name属性，是从Item中继承来的，就不需要重复设计了
        infinityEdge.price = 3600;
    }
}

4. 练习 - 护甲

设计一个类Armor护甲
继承Item类，并且额外提供一个int类型属性ac: 护甲等级
实例化出两件护甲
名称 价格 护甲等级
布甲 300 15
锁子甲 500 40

public class Armor extends Item {
   
    int ac;

    public static void main(String[] args) {
   
        Armor cloth = new Armor();
        Armor chain = new Armor();

        cloth.name = "护甲";
        cloth.price = 300;
        cloth.ac = 15;

        chain.name = "锁子甲";
        chain.price = 500;
        chain.ac = 40;
    }
}

---

方法重载

方法的重载指的是方法名一样，但是参数类型不一样

1. attack方法的重载

public void attack()
public void attack(Hero h1)
public void attack(Hero h1, Hero h2)

方法名是一样的，但是参数类型不一样
在调用方法attack的时候，会根据传递的参数类型以及数量，自动调用对应的方法

public class Hero {
   
    String name; // 姓名
    float hp; // 血量

    public void attack() {
   
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }

    public void attack(Hero h) {
   
        System.out.println(name + " 攻击了 " + h.name);
    }

    public void attack(Hero h1, Hero h2) {
   
        System.out.println(name + " 同时攻击了 " + h1.name + " 和 " + h2.name);
    }

    public static void main(String[] args) {
   
        Hero gareen = new Hero();
        gareen.name = "盖伦";

        Hero teemo = new Hero();
        teemo.name = "提莫";

        Hero db = new Hero();
        db.name = "死歌";

        gareen.attack();
        gareen.attack(teemo);
        gareen.attack(teemo, db);
    }
}

盖伦 进行了一次攻击 ，但是不确定打中谁了
盖伦 攻击了 提莫
盖伦 同时攻击了 提莫 和 死歌

2. 可变数量的参数

如果要攻击更多的英雄，就需要设计更多的方法，这样类会显得很累赘，像这样：

public void attack(Hero h1)
public void attack(Hero h1,Hero h2)
public void attack(Hero h1,Hero h2,Hero h3