Java学习笔记：类和对象之引用、继承、方法重载和构造方法

类和对象之引用、继承、方法重载和构造方法

• 学习参考网址：https://how2j.cn/p/6235

---

引用

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

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();
         
    }  
      
}

---

• 多个引用，一个对象
  • 引用有多个，但是对象只有一个。
  • 在这个例子里，所有引用都指向了同一个对象。
  • 对象就像 "房产"， 引用就像"房产证"
  • 房产证的复印件可以有多张，但是真正的"房产" 只有这么一处

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 五个引用，都指向同一个对象         
    }      
}

---

• 一个引用，多个对象
  • 第8行，引用garen指向新创建的对象（对象1）
  • 第9行，同一个引用garen指向新创建的对象（对象2）
  • 这个时候，对象1，就没有任何引用指向了
  • 换句话说，就没有任何手段控制和访问该对象，那么该对象就变得没有意义。

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

 

 继承 extends

• 物品类Item
  • 物品类Item 有属性 name,price

public class Item {
    String name;
    int price;
}

• 武器类Weapon（不继承）
  • 武器类： Weapon不继承Item的写法
  • 独立设计 name和price属性
  • 同时多了一个属性 damage 攻击力

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

• 武器类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;         
    }
    
}

 

方法重载

• 方法的重载指的是方法名一样，但是参数类型不一样
• attack方法的重载
• 有一种英雄，叫做物理攻击英雄 ADHero
• 为ADHero 提供三种方法

public void attack()

public void attack(Hero h1)

public void attack(Hero h1, Hero h2)

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

public class ADHero extends Hero {
    public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
 
    public void attack(Hero h1) {
        System.out.println(name + "对" + h1.name + "进行了一次攻击 ");
    }
 
    public void attack(Hero h1, Hero h2) {
        System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 ");
    }
 
    public static void main(String[] args) {
        ADHero bh = new ADHero();
        bh.name = "赏金猎人";
 
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";
 
        bh.attack(h1);
        bh.attack(h1, h2);
    }
 
}

---

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

public void attack(Hero h1)

public void attack(Hero h1,Hero h2)

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

 

• 这时，可以采用可变数量的参数
• 只需要设计一个方法

public void attack(Hero ...heros)

• 即可代表上述所有的方法了
• 在方法里，使用操作数组的方式处理参数heros即可

public class ADHero extends Hero {
 
    public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
 
    // 可变数量的参数
    public void attack(Hero... heros) {
        for (int i = 0; i < heros.length; i++) {
            System.out.println(name + " 攻击了 " + heros[i].name);
 
        }
    }
 
    public static void main(String[] args) {
        ADHero bh = new ADHero();
        bh.name = "赏金猎人";
 
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";
 
        bh.attack(h1);
        bh.attack(h1, h2); 
    } 
}

 

构造方法

• 通过一个类创建一个对象，这个过程叫做实例化 
• 实例化是通过调用构造方法(又叫做构造器)实现的

---

• 什么是构造方法
  • 方法名和类名一样（包括大小写）
  • 没有返回类型
  • 实例化一个对象的时候，必然调用构造方法

public class Hero {
 
    String name;
 
    float hp;
 
    float armor;
 
    int moveSpeed;
 
    // 方法名和类名一样（包括大小写）
    // 没有返回类型
    public Hero() {
        System.out.println("实例化一个对象的时候，必然调用构造方法");
    }
     
    public static void main(String[] args) {
        //实例化一个对象的时候，必然调用构造方法
        Hero h = new Hero();
    }
}

---

• 隐式的构造方法
  • Hero类的构造方法是

public Hero(){

}

• 这个无参的构造方法，如果不写，就会默认提供一个

public class Hero {
     
    String name; //姓名
     
    float hp; //血量
     
    float armor; //护甲
     
    int moveSpeed; //移动速度
     
    //这个无参的构造方法，如果不写，
    //就会默认提供一个无参的构造方法
    //  public Hero(){ 
    //      System.out.println("调用Hero的构造方法");
    //  }
 
    public static void main(String[] args) {
        Hero garen =  new Hero();
        garen.name = "盖伦";
        garen.hp = 616.28f;
        garen.armor = 27.536f;
        garen.moveSpeed = 350;
         
        Hero teemo =  new Hero();
        teemo.name = "提莫";
        teemo.hp = 383f;
        teemo.armor = 14f;
        teemo.moveSpeed = 330;
    }  
     
}

---

• 如果提供了一个有参的构造方法
  • 一旦提供了一个有参的构造方法 
  • 同时又没有显式的提供一个无参的构造方法 
  • 那么默认的无参的构造方法，就无了

public class Hero {
      
    String name; //姓名
      
    float hp; //血量
      
    float armor; //护甲
      
    int moveSpeed; //移动速度
      
    //有参的构造方法
    //默认的无参的构造方法就失效了
    public Hero(String heroname){ 
        name = heroname;
    }
      
    public static void main(String[] args) {
        Hero garen =  new Hero("盖伦"); 
          
        Hero teemo =  new Hero(); //无参的构造方法无了
    }  
      
}

---

• 构造方法的重载
  • 和普通方法一样，构造方法也可以重载

public class Hero {
       
    String name; //姓名
       
    float hp; //血量
       
    float armor; //护甲
       
    int moveSpeed; //移动速度
       
    //带一个参数的构造方法
    public Hero(String heroname){ 
        name = heroname;
    }
     
    //带两个参数的构造方法
    public Hero(String heroname,float herohp){ 
        name = heroname;
        hp = herohp;
    }
       
    public static void main(String[] args) {
        Hero garen =  new Hero("盖伦"); 
        Hero teemo =  new Hero("提莫",383);
    }
     
}