多态:用父类的引用指向子类的对象
package com.qianfeng.test;
/*
-
多态:一种事物的多种形态 狗 == 动物 == 生物 学生 == 高级动物 == 动物 == 生物
-
多态的前提:类与类之间一定要有继承的关系
*/
public class Demo6 {public static void main(String[] args) {
// 使用继承--使用子类的引用工作 Dog dog = new Dog(); dog.play();// 调用父类的方法 dog.show();// 调用自己的方法 // 多态:用父类的引用指向子类的对象 // 注意:这里说的父类不是单指直接的父类,只要是父类即可 Animal animal = new Dog(); /* * 一个程序运行的时候分成三个阶段: 预编译:程序打开的时候,活儿已经干完了. (预处理命令 #define) * 编译:从打开程序开始到点击左上角的三角之前的阶段.----只会识别=前面的引用类型,不会去识别=后面的对象. * 运行:从点击三角开始.----这里才会去真正识别=后面的对象. */ animal.play(); // animal.show();//调用方法的工作机制:1.首先由animal找到Dog对象,Dog对象再去调用show方法 // 不能通过的原因:在编译的时候识别的是引用类型,不识别对象.所以只能识别出animal特有的方法,不能调用子类特有的方法. /* * 优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,而不用再去创建新的方法.解释在Demo7 * 缺点:不能直接调用子类特有的方法,只能调用父类有的方法 */
}
}
class Animal {
String name;
public Animal(String name) {
super();
this.name = name;
}
public Animal() {
super();
// TODO Auto-generated constructor stub
}
public void play() {
System.out.println("Animal-play");
}
}
class Dog extends Animal {
public void show() {
System.out.println("Dog-show");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("Cat-eat");
}
}
多态的优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,而不用再去创建新的方法。
package com.qianfeng.test;
/*
-
优点:可以提高代码的扩展性,使用之前定义好的功能,后面直接拿来使用,而不用再去创建新的方法.解释在Demo7
*/
public class Demo7 {public static void main(String[] args) {
Dog1 dog1 = new Dog1(); Cat1 cat1 = new Cat1(); Animal1 animal1 = new Animal1(); // feedDog(dog1); // feedCat(cat1); feedAnimal(dog1); feedAnimal(cat1); feedAnimal(animal1);
}
public static void feedAnimal(Animal1 animal) {// animal = dog1 = new Dog1()
//多态animal.eat();
}
// public static void feedDog(Dog1 dog1) {
// dog1.eat();
// }
//
// public static void feedCat(Cat1 cat1) {
// cat1.eat();
// }
}
class Animal1 {
String name;
public Animal1(String name) {
super();
this.name = name;
}
public Animal1() {
super();
// TODO Auto-generated constructor stub
}
public void play() {
System.out.println("Animal1-play");
}
public void eat() {
System.out.println("动物吃");
}
}
class Dog1 extends Animal1 {
public void show() {
System.out.println("Dog1-show");
}
public void eat() {
System.out.println("狗吃");
}
}
class Cat1 extends Animal1 {
public void eat() {
System.out.println("Cat1-eat");
}
}
向上转型与向下转型
package com.qianfeng.test;
/*
- 前提:这里一定是多态
- 父类的类型比子类的类型等级高
- 向上转型:相当于自动类型转换,由低类型到高类型
-
注意:是将子类的引用转成父类的引用,但是只是将=前面进行转换,与=后面无关
- 向下转型:相当于强制类型转换,由高类型到低类型
-
注意:是将父类的引用强制转换成子类的引用.
*/
public class Demo8 {
public static void main(String[] args) {
// 向上转型
Animal2 animal2 = new Dog2();// 多态
// 向下转型--为了调用子类特有的方法
Dog2 dog2 = (Dog2) animal2;
dog2.show();// 调用子类特有方法
// 注意点:
// 1.这里不叫向上转型,这是错误.不能使用子类的引用指向父类的对象.
// Dog2 dog22 = new Animal2();
// 2.这里不是多态,所以不是向下转型,向下转型的前提是多态
Animal2 animal22 = new Animal2();
Dog2 dog22 = (Dog2) animal22;
}
}
class Animal2 {
String name;
public Animal2(String name) {
super();
this.name = name;
}
public Animal2() {
super();
// TODO Auto-generated constructor stub
}
public void play() {
System.out.println("Animal2-play");
}
}
class Dog2 extends Animal2 {
public void show() {
System.out.println("Dog2-show");
}
}
class Cat2 extends Animal2 {
public void eat() {
System.out.println("Cat2-eat");
}
}
intstanceof关键字
package com.qianfeng.test;
public class Demo9 {
public static void main(String[] args) {
Dog3 dog3 = new Dog3();
Cat3 cat3 = new Cat3();
feedAnimal(cat3);
}
public static void feedAnimal(Animal3 animal3) {// animal3 = dog3 = new
// Dog3() 多态
// animal3.eat();
// 容错处理:包容这块出错的代码,不让他影响后面正常代码的执行-----增加用户体验
// intstanceof本身是一个运算符.构成: 对象 instanceof 类 ,作用:确定前面的对象是否是后面的类或子类的对象
// 返回值有两个:如果是返回true
// 不是:返回false
// 注意点:
// 1.instanceof前后必须有继承关系
if (!(animal3 instanceof Dog3)) {
System.out.println("传入的对象不是Dog3或子类的对象");
System.exit(0);// 退出程序
}
// 向下转型
Dog3 dog3 = (Dog3) animal3;
dog3.show();// 调用子类特有的方法
System.out.println("继续");
}
}
class Animal3 {
String name;
public Animal3(String name) {
super();
this.name = name;
}
public Animal3() {
super();
// TODO Auto-generated constructor stub
}
public void play() {
System.out.println("Animal3-play");
}
public void eat() {
System.out.println("animal-eat");
}
}
class Dog3 extends Animal3 {
public void show() {
System.out.println("Dog3-show");
}
public void eat() {
System.out.println("Dog3-eat");
}
}
class Cat3 extends Animal3 {
public void eat() {
System.out.println("Cat3-eat");
}
}
成员在多态下的使用
package com.qianfeng.test;
/*
*成员在多态下的使用
*/
public class Demo10 {
public static void main(String[] args) {
// 继承中成员的使用
Zi zi = new Zi();
System.out.println(zi.age);// 3 ,说明在继承下,子类的优先
/*
* 多态下 当父类与子类定义了同名的属性:成员变量编译的时候看父类,运行的时候还是看父类 成员方法:编译的时候看父类,运行的时候看子类
* 静态的成员方法:编译运行都看父类
*/
Fu fu = new Zi();
System.out.println(fu.age);// 5
fu.eat();
Fu.play();
}
}
class Fu {
int age = 5;
public void eat() {
System.out.println("eat");
}
public static void play() {
System.out.println("Fu-play");
}
}
class Zi extends Fu {
int age = 3;
public void show() {
System.out.println("Zi-show");
}
public static void play() {
System.out.println("Zi-play");
}
}