【JavaSE笔记】第十三章 方法覆盖和多态

方法重载：同一个类当中，方法名相同，参数列表不同（类型，个数，顺序）

方法覆盖

只有当从父类中继承过来的方法无法满足当前子类业务的需求的时候，需要将父类中继承过来的方法进行覆盖，又被称为方法重写

• 发生在具有继承关系的父子类之间，首要条件
• 覆盖之后的方法与原方法具有相同的返回值类型、相同的方法名、相同的形式参数列表

• 建议使用复制粘贴
• 私有的方法不能继承，所以也不能覆盖
• 覆盖之后的方法不能比原方法拥有更低的访问权限，可以更高（学习访问控制）
• 覆盖之后的方法不能比原方法抛出更多的异常，可以相同或更少（学习异常）
• 方法覆盖只是和方法有关，和属性无关
• 静态方法不存在覆盖

public class Animal
{
	public void move()
	{
		System.out.println("动物在移动！");
	}
}

public class Cat extends Animal
{
	public void move()
	{
		System.out.println("猫在走猫步!");
	}
	public void catchMouse()
	{
		System.out.println("猫抓老鼠！");
	}
}

public class Bird extends Animal
{
public void move()
	{
		System.out.print("鸟儿在飞翔！");
	}
}

public class Test
{
	public static void main(String[] args)
	{
		Cat cat = new Cat();
		cat.move();
		cat.catchMouse();
		Bird bird = new Bird();
		bird.move();
	}
}

多态就是同一个行为发生在不同的对象上会产生不同的效果

Java中允许这样两种语法出现

• 向上转型（upcasting）子类型转换为父类型又被称为自动类型转换
• 向下转型（downcasting） 父类型转换成子类型又被称为强制类型转换
  不论向上转型还是向下转型，两种类型之间必须要有继承关系

public class Animal
{
	public void move()
	{
		System.out.println("Animal moving!");
	}
}

public class Cat extends Animal
{
	public void move()
	{
		System.out.println("走猫步!");
	}
	public void catchMouse()
	{
		System.out.println("抓老鼠！");
	}
}

public class Bird extends Animal
{
	public void move()
	{
		System.out.print("鸟儿在飞翔！");
	}
	public void sing()
	{
		System.out.println("鸟儿在歌唱！");
	}
}

public class Test01
{
	public static void main(String[] args)
	{
		Animal a1 = new Cat();
		a1.move();
		Animal a2 = new Bird();
		a2.move();
	}
}

Java中之所以有多态机制，是因为Java允许一个父类型的引用指向一个子类型对象（向上转型/自动类型转换）

在编译阶段编译器只知道a1变量的数据类型是Animal，那么此时编译器回去Animal.class字节码中查找move() 方法，发现Animal.class字节码中存在move() 方法，然后将该move()方法绑定到引用a1上，这个过程称为静态绑定完成了

运行阶段实际上在堆内存中new的对象是Cat类型，自动执行Cat类的move()方法，这个过程称为动态绑定

必须静态绑定成功之后才能进入动态绑定

public class Test03
{
	public static void main(String[] args)
	{
		Animal a = new Cat();
		a.catchMouse();
	}
}

public class Test03
{
	public static void main(String[] args)
	{
		Animal a = new Cat();
		Cat c = (Cat)a; //向下转型
		c.catchMouse();
	}
}

只有访问子类特有属性的时候，需要进行向下转型

public class Test05
{
	public static void main(String[] args)
	{
		Animal a = new Bird();
		Cat c = (Cat)a;
	}
}

运算结果是布尔类型，可能是true，也可能是false，假设（c instanceof Cat）

在实际开发中，在任何向下转型的操作之前，要使用instanceof进行判断

public class Test05
{
	public static void main(String[] args)
	{
		Animal a = new Bird();
		if(a instanceof Cat)
		{
			Cat c = (Cat)a;
			c.catchMouse();
		}
	}
}

多态的三个条件是

• 继承
• 方法覆盖
• 父类型引用指向子类型对象

public class Pet
{
	String name;
	public void eat()
	{
		
	}
}

public class Cat extends Pet
{
	public Cat(String name)
	{
		this.name = name;
	}
	public void eat()
	{
		System.out.println(this.name + "在吃鱼!");
	}
}

public class Dog extends Pet
{
	public Dog(String name)
	{
		this.name = name;
	}
	public void eat()
	{
		System.out.println(this.name + "在啃肉吃骨头");
	}
}

public class Master
{
	public void feed(Pet pet)
	{
		System.out.println("主人开始喂食");
		pet.eat();
		System.out.println("主人喂食完毕");
	}
}

public class Test
{
	public static void main(String[] args)
	{
		Dog dog = new Dog("二哈");
		Master master = new Master();
		master.feed(dog);
		Cat cat = new Cat("汤姆");
		master.feed(cat);
	}
}