一、重载和重写

1.重载是多态的一种体现，方法的重载是让类以统一的方式处理不同类型数据的一种手段。重载是方法名不变，但参数一定变。
使用方法重载时需注意的：

1. 同一个类中方法名相同，参数列表不同
2. 返回值类型不能用于区分方法的重载

2.构造方法能重载，声明为final的方法不能被重载，声明为static的方法不能被重载但能被再次声明

示例：

public class Book { 
   
 //定义3个重载方法
 public float  getPrice(){ 
    
  return 100;
 }
 public  float getPrice(int page){ 
   
  return (float)(page*0.1);
 }
 public  float  getPrice(int page ,float discount){ 
   
  return (float) (page*discount);
 }
 public static void main(String[] args) { 
   
  Book book=new Book();//创建Book对象
  System.out.println("default图书价格:"+book.getPrice());
  System.out.println("根据页数计算图书价格:"+book.getPrice(268)); 
      System.out.println("根据页数和折扣计算图书格:"+book.getPrice(360,0.2f));
 }
}

3.重写

• 重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型
• 重写方法不能使用比被重写的方法更严格的访问权限
• 重写方法不能声明抛出比被重写方法范围更大的异常类型
• 重写是外壳不变，核心变

示例：

public class Bird { 
    // 父类 飞鸟
 //Bird类的fly()方法
 public void fly(){ 
   
          System.out.println("我在蓝天白云间自由的飞翔...");
 }
}
public class Ostrich extends Bird{ 
   // 子类 鸵鸟
 public  void fly(){ 
    //重写父类方法
                System.out.println("我只能在陆地上拍拍翅膀奔跑...");
 }
 public  void prey(){ 
    //捕食方法
  fly();
  System.out.println("执行捕食方法");
 }
 public static void main(String[] args) { 
   
  Ostrich ostrich=new Ostrich();
  ostrich.prey(); //调用ostrich对象的prey()
 }
}

4.重写覆盖问题
子类包含与父类同名的方法，该现象被称为方法重写，也被称为方法覆盖。

示例：

public class Ostrich extends Bird{ 
   
 public  void fly(){ 
   
  System.out.println("我只能在陆地上拍拍翅膀奔跑...");
 }
 //捕食方法
 public  void prey(){ 
   
  //在prey()方法中使用super关键调用父类的fly()方法
  super.fly();
  System.out.println("执行捕食方法");
 }
 public static void main(String[] args) { 
   
  //创建Ostrich对象
  Ostrich ostrich=new Ostrich();
  ostrich.prey();//调用ostrich对象的fly()
 }
}

二、多态

1.多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。

代码如下（示例）：

//父类 人物
public class Figure { 
   
 protected String name;
 public void attack(){ 
   
  //此处不进行具体的攻击操作，不同职业的英雄攻击方式不同
 }
 public  void run(){ 
     
  System.out.println("在奔跑");
 }
}
 
//子类 战士
public class Warrior  extends  Figure{ 
   
 //重写父类的attack()方法
 public void attack(){ 
   
             System.out.println(this.name+"正在物理攻击......");
 }
}

//子类 法师
public class Master extends Figure { 
   
 //重写父类的attack()方法
 public void attack(){ 
     
  System.out.println(this.name+"正在魔法攻击......");
 } 
 public static void main(String[] args) { 
   
      Figure master=new Master();
      master.name="恶魔巫师";
      Figure warrior=new Warrior();
      warrior.name="撼地神牛";
      master.attack();
      warrior.attack();
 }
}

2.引用变量的强制类型转换

引用变量只能调用其编译时类型的方法，而不能调用运行时类型的方法。如果需要让引用变量调用运行时类型的方法，则必须将其强制类型转换为运 行时类型，强制类型转换需借助于类型转换运算符。
3.instanced of 运算符
语法：

a instanceof A

示例：

//子类 法师
public class Master extends Figure { 
   
 //重写父类的attack()方法
 public void attack(){ 
     
             System.out.println(this.name+"正在魔法攻击......");
 }
 //子类特有的轰炸功能
 public void bomb(){ 
   
             System.out.println(this.name+“正在魔法轰炸......");
 } 
 public static void mafigurein(String[] args) { 
   
      Figure figure=new Master();
      figure.name="恶魔巫师";
                       figure.attack();
                       if(figure instanceof Master )
        Master master = (Master)figure; // 使用向下类型转换
       master.bomb();   //成功调用Master类的bomb
 }
}

总结

• 重载就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
• 重写就是在子类方法重写父类方法，重写的方法和被重写的方法必须具有相同方法名称、参数
• 列表和返回类型。
• 多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
• 在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。