1.多态的概述
2.多态的格式和使用
1 public class FuTest1 {
2 public void method(){
3 System.out.println("父类方法");
4 }
5 public void methodFu(){
6 System.out.println("父类特有方法");
7 }
8 }
9
10
11 public class ZiTest extends FuTest1{
12 @Override
13 public void method(){
14 System.out.println("子类特有方法");
15 }
16 }
17
18
19 /*
20 代码中体现多态性，其实就是一句话:父类引用指向子类对象
21 格式：
22 父类名称 对象名 = new 子类名称();
23 或者：
24 接口名称 对象名 = new 实现类名称
25 */
26 public class Demo01Multi {
27 public static void main(String[] args) {
28 // ZiTest zi = new ZiTest();
29 // zi.method();
30 // zi.methodFu();
31 //多态的写法：左侧父类的引用，指向了右侧子类的对象。
32 FuTest1 obj = new ZiTest();
33 obj.method();
34 obj.methodFu();
35 }
36 }3.多态中成员变量的使用特点
1 public class FuTest2 /*extends Object*/ {
2 int num = 10;
3 public void showNum(){
4 System.out.println(num);
5 }
6
7
8
9 public class ZiTest2 extends FuTest2{
10 int num = 20;
11 int age = 15;
12
13 @Override
14 public void showNum() {
15 System.out.println(num);
16 }
17 }
18
19
20 /*
21 访问成员变量的两种方式：
22 1.直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有则想上找。
23 2.间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则想上找。
24 */
25 public class Demo02Multi {
26 public static void main(String[] args) {
27 FuTest2 obj = new ZiTest2();
28 System.out.println(obj.num); //父：10
29 //System.out.println(obj.age);//错误写法：父类没有该变量，向上找不到
30 System.out.println("=======================");
31 //子类没有覆盖重写就是父：10
32 //子类覆盖重写，就是访问子：20
33 obj.showNum();
34 }
35 }4.多态中成员方法的使用特点
1 public class FuTest3 {
2 public void method(){
3 System.out.println("父类方法");
4 }
5 public void methodFu(){
6 System.out.println("父类特有方法");
7 }
8 }
9
10
11 public class ZiTest3 extends FuTest3{
12 public void method(){
13 System.out.println("子类方法");
14 }
15 public void methodZi(){
16 System.out.println("子类特有方法");
17 }
18 }
19
20
21 /*
22 在多态的代码中，成员方法的访问规则是：
23 看new的是谁，就优先用谁，没有则向上找。
24 口诀：编译看左边，运行看右边
25 对比一下：
26 成员变量：编译看左边，运行还看左边
27 成员方法：编译看左边，运行看右边
28 */
29 public class Domo02Multi {
30 public static void main(String[] args) {
31 FuTest3 obj = new ZiTest3(); //多态
32 obj.method(); // 父子都有，优先用子
33 obj.methodFu(); //子类没有，父类有，向上找到父类
34
35 }
36 }5.使用多态的好处
6.对象的向上转型
1 public abstract class Animal {
2 public abstract void eat();
3 }
4
5
6
7 public class Cat extends Animal{
8
9 @Override
10 public void eat() {
11 System.out.println("猫吃鱼");
12 }
13 }
14
15
16 public class Demo01Main {
17 public static void main(String[] args) {
18 //对象的向上转型：父类引用指向子类对象
19 Anima anima= new Cat();
20 anima.eat();
21 }
22 }7.对象的向下转型
1 public abstract class Anima {
2 public abstract void eat();
3 }
4
5
6 public class Cat extends Anima{
7
8 @Override
9 public void eat() {
10 System.out.println("猫吃鱼");
11 }
12 public void catchMouse(){
13 System.out.println("猫抓老鼠");
14 }
15 }
16
17
18 public class Demo01Main {
19 public static void main(String[] args) {
20 //对象的向上转型：父类引用指向子类对象
21 Anima anima= new Cat(); //本来创建的时候就是一只猫
22 anima.eat();//猫吃鱼
23 //anima.catchMouse();//错误写法
24
25 //向下转型，进行“还原”动作
26 Cat cat = (Cat) anima;
27 cat.catchMouse();//猫抓老鼠
28
29 //下面是错误的向下转型
30 //本来new的时候是一只猫，现在非要当作狗
31 //错误写法！编译不会报错，但是运行会出现异常
32 //java.lang.ClassCastException
33 // Dog dog = (Dog) animal;
34 }
35 }8.用instanceof关键字进行类型判断
1 /接上面6.7代码
2 public class Dog extends Anima{
3 @Override
4 public void eat() {
5 System.out.println("狗啃骨头");
6 }
7 }
8
9 //如何才能直到一个父类引用的对象，本来是什么子类：
格式： 对象 instatceof 类名称
这将会得到一个boolean值的结果，也就是判断前面的对象能不能当作后面类型的实例
10 public class Demo02Instanceof {
11 public static void main(String[] args) {
12 Anima anima = new Cat();
13 anima.eat();
14 giveMePet(new Dog());
15 }
//如果希望调用子类特有的方法，需要向下转型
//判断一个父类引用animal本来是不是Dog
16 public static void giveMePet(Anima anima){
17 if (anima instanceof Dog){
18 Dog dog = (Dog) anima;
19 dog.eat();
20 }
21 if(anima instanceof Cat){
22 Cat cat = (Cat) anima;
23 cat.eat();
24 }
25 }
26 }
