重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写, 注意！！！返回值和形参都不能改变。

重写的好处在于子类可以根据需要，定义特定 于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写的用法：

class Animal{public String name;public int age;public void eat(){System.out.println("动物正在吃饭");}public Animal(String name, int age) {this.name = name;this.age = age;}
}class Cat extends Animal{public Cat(String name, int age) {super(name, age);}@Overridepublic void eat(){System.out.println(name+"正在吃猫粮");}
}public class chongxie {public static void main(String[] args) {Animal cat = new Cat("猫",2);cat.eat();}
}

最终输出：

 如上：cat可以使用专属于其类型的方法，从而打印出其相对应的“吃猫粮”。

---

多态

多态定义

多态实现条件：

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

3.通过父类的引用调用重写的方法

多态的使用场景（个人理解）：在有多个类型之后，若有一个方法在很多个子类中被重写，而我们在创建一个子类变量的时候，若一时间不记得此变量具体为什么类型的时候，就可以利用多态，直接输出该变量的重写方法。

多态的使用

package practice3.chongxie;
class Animal1{String name;int age;public Animal1(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name+"正在吃饭");}
}class Dog extends Animal1{public Dog(String name,int age){super(name,age);}@Overridepublic void eat(){System.out.println(name+"正在吃狗粮");}
}class Cat1 extends Animal1{public Cat1(String name,int age){super(name,age);}@Overridepublic void eat(){System.out.println(name+"正在吃猫粮");}
}
public class duotai {public static void eat(Animal1 animal){//记得写static！！！！！！！！！！animal.eat();}public static void main(String[] args) {Dog dog = new Dog("修勾",2);Cat1 cat = new Cat1("修猫",1);eat(dog);eat(cat);}
}

最终输出结果：

---

向上转型

向上转型：创建一个子类对象，将其当成父类对象来使用。 

向上转型的格式：：父类类型 对象名 = new 子类类型()

Animal animal = new Cat("猫",2);//向上转型

向上转型的使用场景：

1.函数传参

如之前多态里的代码一样，在我们未确定我们创建的类型是什么的时候，要使用一个方法，可以先写一个函数，其形参可以设为一个父类类型，然后我们将子类传参进去，此时是不会报错的，这样子可以让我们写的代码思路更加清晰且可读性更强。

（之前多态的例子）：

package practice3.chongxie;
class Animal1{String name;int age;public Animal1(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name+"正在吃饭");}
}class Dog extends Animal1{public Dog(String name,int age){super(name,age);}@Overridepublic void eat(){System.out.println(name+"正在吃狗粮");}
}class Cat1 extends Animal1{public Cat1(String name,int age){super(name,age);}@Overridepublic void eat(){System.out.println(name+"正在吃猫粮");}
}
public class duotai {public static void eat(Animal1 animal){//记得写static！！！！！！！！！！animal.eat();}public static void main(String[] args) {Dog dog = new Dog("修勾",2);Cat1 cat = new Cat1("修猫",1);eat(dog);eat(cat);}
}

2.方法返回

场景模拟：有两个选择，买修猫或者买修勾，我们能通过输入 “狗”/“猫” 来选择我们想买的动物，那么就要创建一个变量，来装下修勾类或者修猫类，那么在我们定义变量的时候，是使用Dog类函数Cat类来定义嘞？这时候我们就可以定义一个函数，先判定要买的是猫还是狗狗，然后用Animal这个父类创建变量来接收。

package practice3.chongxie;
class Animal1{String name;int age;public Animal1(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println(name+"正在吃饭");}
}class Dog extends Animal1{public Dog(String name,int age){super(name,age);}@Overridepublic void eat(){System.out.println(name+"正在吃狗粮");}
}class Cat1 extends Animal1{public Cat1(String name,int age){super(name,age);}@Overridepublic void eat(){System.out.println(name+"正在吃猫粮");}
}
public class duotai {public static void eat(Animal1 animal){animal.eat();}public static Animal1 buyAnimal(String animal){//此时函数的返回值为父类，就所有其子类都可以返回if(animal=="猫"){return new Cat1("修猫咪",2);}else if(animal=="狗"){return new Dog("修勾勾",2);}else {return null;}}public static void main(String[] args) {Animal1 ani1 = buyAnimal("狗");ani1.eat();Animal1 ani2 = buyAnimal("猫");ani2.eat();}
}

最终输出：

向上转型缺点：

我们在将子类装到父类变量中时，由于其类型还是父类，使用子类若没有重写的方法，那么子类的方法我们是无法使用的，若要使用，我们则需要向下转型。

---

向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的 方法，此时：将父类引用再还原为子类对象即可，即向下转换。

向下转型使用方法：强制类型转换。

但向下转型有风险：当我们强制转为其子类的时候，若转错子类类型，那么此时就会报错，这时我们就需要先了解一个关键字：instanceof 

instanceof

instanceof的使用：（变量名） instanceof  （子类类名），若前面的变量为其子类类型，那么会返回true，反之则返回false。若我们用这个关键字先来判定为哪种类型，那么就能保证其安全性，不会报错。

向下转型的使用

package practice4.XiangXiaZhuanXing;
class Animal{public String name;public int age;public Animal(String name, int age) {this.name = name;this.age = age;}public void eat(){System.out.println("test正在吃饭");}
}class Bird extends Animal{public Bird(String name,int age){super(name,age);}public void eat(){System.out.println(name+"吃鸟粮");}public void said(){System.out.println("我是鸟");}
}public class practice4 {public static void main(String[] args) {Animal animal = new Bird("鸟",2);animal.eat();//这上面能都用到鸟的方法，针对鸟而不是针对动物这个大类，是因为重写了方法，所以输入向上转型，不能使用鸟中的方法，但是//此时eat算是animal的方法，因为animal中爷又这个方法，但是由于被重写，使用此时针对鸟，但如果我们将没有重写的方法调//出来，即把只在鸟这个类中的方法使用，此时还是会报错，如下：//animal.said();//此时报错，因为animal中没有这个方法//以及向上转型了，那么要怎么样向下转型呢？if(animal instanceof Bird){Bird bird = (Bird)animal;bird.said();}}
}

又是收获满满的一天~