重写

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

又是收获满满的一天~

JAVA中多态以及向上转型向下转型、重写的讲解相关推荐

访问修饰符、常见的包以及包的权限和包的导入（inport关键字）、继承（super关键字）、多态（向上和向下转型）
IDEA中快捷生成getter/setter的快捷键为 alt+inser(enter) getter/setter命名规范:都是以gte/set单词开头+要操作的属性名称一.访问修饰符 Java中 ...
【零基础学Java】—对象的向上和向下转型（二十七）
[零基础学Java]-对象的向上转型(二十七) 对象的向上转型,其实就是多态的写法格式:父类名称对象名=new 子类名称(): 含义:右侧创建一个子类对象,把它当做父类来看待使用注意事项:向上转 ...
Java中多态（向上转型）机制
1.为什么向上转型? 所谓多态,也即向上转型,就是某个对象的引用视为对其基类的引用,编译对象是基类,运行对象是父类.向上转型的对象由于Java后期绑定的特点,若父类重写了基类中的方法,则它调用的是父类 ...
Java多态中的向上转型/向下转型
Java 向上转型和向下转型的详解转型是在继承的基础上而言的,继承是面向对象语言中,代码复用的一种机制,通过继承,子类可以复用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法 ...
Java从入门到放弃09---多态/向上转型/向下转型/多态内存图/抽象类/关键字abstract不能和哪些关键字共存/接口/类与类,类与接口,接口与接口的关系/抽象类与接口的区别
Java从入门到放弃09-多态/向上转型/向下转型/多态内存图/抽象类/关键字abstract不能和哪些关键字共存/接口/类与类,类与接口,接口与接口的关系/抽象类与接口的区别 01 多态多态指的是 ...
java多态上转下_(转)java的多态（向上转型、向下转型）
在我的明白:java的向上和向下转型可以看成是类型的转换. ---------------- 版权声明:本文为CSDN博主「ldsh304」的原创文章,遵照CC 4.0 BY-SA版权协议,转载请附上 ...
Java 中的上转型和下转型
在我们的日常中,上转型和下转型都使用的比较少,所以当别人问起来什么是上转型,什么是下转型,自己往往一片模糊,或者不能将他们进行明显的区分. 在这里,我将以我个人理解来论述上下转型,希望对大家有帮助,如 ...
java中多态_java之多态
1.多态的概述:是面向对象的三大特性之一,封装.继承.多态. ①一个具体的对象有多种形态,老虎既属于猫科动物(因为子父类是相对的,所以猫科动物也可以看做子类),又属于哺乳动物,所以老虎既可以拥有猫科动 ...
深入Java核心 Java中多态的实现机制(1)
在疯狂java中,多态是这样解释的: 多态:相同类型的变量,调用同一个方法时,呈现出多中不同的行为特征, 这就是多态. 加上下面的解释:(多态四小类:强制的,重载的,参数的和包含的) 同时, 还用人这 ...

JAVA中多态以及向上转型向下转型、重写的讲解

重写