结果为
而当子类没有重写这个方法时，会从父类中继承该方法，调用的时候也是调用这个方法
package test1;
class Father1{
public Father1() {
}
public void show(){
System.out.println(“父类的show方法”);
}
}
class Son1 extends Father1{
public Son1() {
}
// public void show(){
// System.out.println(“子类的show方法”);
// }
}
public class duotaiDemo3 {
public static void main(String[] args) {
Father1 f = new Son1();
f.show();
}
}
编译看左边的意思是编译过程中看父类中是否有这个方法
运行看右边的意思是运行过程中实际调用的方法是子类中重写后的方法
第四条静态的成员方法
class Animal{
int num =10;
public void eat(){
System.out.println(“动物要进食”);
}
public static void sleep(){
System.out.println(“动物要休息”);
}
}
class Cat extends Animal{
int num = 20;
public void eat(){
System.out.println(“猫咪要吃饭”);
}
public static void sleep(){
System.out.println(“猫咪要睡觉”);
}
}
public class Demo1 {
public static void main(String[] args) {
Animal a = new Cat();
//System.out.println(a.num);
Animal.sleep();
Cat.sleep();
}
}
结果为
因为是用类名调用，所以都是打印相对应的结果
介绍完多态访问成员的特点后，我们需要思考一个问题，为什么要使用，以及使用多态有什么好处
下面来看这个例子
class Animal{
public void eat(){
System.out.println(“动物要进食”);
}
public void sleep(){
System.out.println(“动物要休息”);
}
}
class Cat extends Animal{
public void eat(){
System.out.println(“猫咪要吃饭”);
}
public void sleep(){
System.out.println(“猫咪要睡觉”);
}
}
class Dog extends Animal{
public void eat(){
System.out.println(“狗要啃骨头”);
}
public void sleep(){
System.out.println(“狗要打盹”);
}
}
public class Demo1 {
public static void main(String[] args) {
Cat c = new Cat();
c.eat();
c.sleep();
Dog d = new Dog();
d.eat();
d.sleep();
}
}
这里发现，如果输出猫和狗的实例对象的eat和sleep方法的结果，就需要分别用Cat类的对象c来调用，用Dog类的对象d来调用。这里是因为对象较少，调用的方法也只有eat和sleep两个方法，所以看起来还算简洁。
但如果我要创建十只猫的实例呢？要c1.eat()，c2.sleep()……这样一直调用下去吗？
那如果我不止猫和狗两种动物呢？我还要写狼的类，写豹子的类，写大象的类，都继承Animal类，然后输出这些类的对象调用方法的结果。
这时就会发现，代码的调用方法部分将变得非常冗长，有没有一种办法，可以让我们不需要用实例对象一个一个的调用方法呢？
这时候我们就需要用到多态了。而我们需要做的事情，就是创建对象，并且将对象作为参数传入一个工具类中，工具类里面会定义各种需要调用的方法。
class Animal{
public void eat(){
System.out.println(“动物要进食”);
}
public void sleep(){
System.out.println(“动物要休息”);
}
}
class Cat extends Animal{
public void eat(){
System.out.println(“猫咪要吃饭”);
}
public void sleep(){
System.out.println(“猫咪要睡觉”);
}
}
class Dog extends Animal{
public void eat(){
System.out.println(“狗要啃骨头”);
}
public void sleep(){
System.out.printl
【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开：qq.cn.hn/FTf 免费领取
n(“狗要打盹”);
}
}
class Bird extends Animal{
public void eat(){
System.out.println(“鸟儿吃虫子”);
}
public void sleep(){
System.out.println(“鸟儿休憩”);
}
}
class AnimalTools {
//private的作用是让外面无法创建AnimalTools类的对象，只能使用这里面的方法
private AnimalTools() {
}
public static void funAnimal(Animal animal){
animal.eat();
animal.sleep();
}
}
public class Demo1 {
public static void main(String[] args) {
Cat c = new Cat();
Dog d = new Dog();
Bird b = new Bird();
AnimalTools.funAnimal?;
AnimalTools.funAnimal(d);
AnimalTools.funAnimal(b);
Cat c2 = new Cat();
AnimalTools.funAnimal(c2);
}
}
结果为
多态的好处：