一、final 关键字

不可改变的，最终的。它可以修饰成员变量，成员方法，类

修饰类
该类不能被继承

修饰变量
成员变量成为常量，只能被赋值一次，不能被修改

修饰成员方法
方法不能被重写

1、final 修饰的是基本数据类型的变量，值不能被修改
2、修饰是引用数据类型的变量的时候，地址值不能被修改
3、final 修饰变量的初始化时机，在构造对象完毕之前即可
（构造方法、静态代码块、构造代码块内完成赋值均可）

二、多态 (polymorphic)

1、基本

多态：某一个事物，在不同时刻体现出来的不同的状态

多态的前提
1、继承
2、重写（否则多态无意义）
3、父类引用指向派生类对象

书写格式
父类对象名 = new 派生类

2、多态访问成员特点

1、成员变量
编译看左边，运行看左边

2、构造方法
创建子类对象的时候，先访问父类的构造方法，先对父类的数据进行初始化

3、成员方法
编译看左边，运行看右边
若存在重写，则直接调用，若无，向父类继承的方法中寻找，再无则报错

4、静态的成员方法：
编译看左边，运行看左边
静态的随着类的加载而加载，所以两个重复的静态会同时存在，不属于重写
运行父类引用的 static 方法

总结：
只有访问成员方法的时候是编译看左边，运行看右边，其他的是编译看左边，运行看左边

3、向上转型和向下转型

向上转型
多态就是一个典型的向上转型，指向派生类的父类引用
父类对象名 = new 派生类
可以看做是派生类的核心，外面套了一层父类的外壳

向下转型
将被父类引用的派生类重新用派生类引用接回
派生类对象名= （派生类）父类
可以看做是将多态时套上的外壳剥下，重新套上新的外壳

内存图

3、instanceof 关键字

instanceof 是 Java 的一个关键字，左边对象，右边类，返回是Boolean类型

对象名 instanceof 类

它的具体作用是测试左边的对象是否是右边类或者该类的子类创建的实例对象，是，则返回 true，否则返回 false

4、多态访问成员特点

优点
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)

缺点
多态的弊端：
1、不能访问子类的特有功能
（由多态访问成员的特点导致的）
      解决方式：
      向下转型
      格式：派生类 z = (派生类)父类
      必须要存在继承关系，而且不能夸层转型

2、不能通过多态去访问父类和子类同名的方法
解决方式：
super 关键字，调用父类的成员

五、练习

//   test1
class Animal{public void eat(){System.out.println("吃");}
}class Dog extends Animal{public void eat(){System.out.println("狗吃肉");}public void lookDoor(){System.out.println("看门");}
}class Cat extends Animal{public void eat(){System.out.println("猫吃鱼");}public void catchMice(){System.out.println("捉老鼠");}
}public class PolymorphicTest1 {public static void main(String[] args) {//使用多态定义一个狗Animal3 a = new Dog3();a.eat();
//        a.lookDoor(); //报错System.out.println("----------------");//向下转型Dog3 d = (Dog3)a;d.eat();d.lookDoor();System.out.println("-------------");//多态  向上转型a = new Cat3();a.eat();
//        a.catchMice(); //报错System.out.println("-------------");//向下转型Cat3 c = (Cat3)a;c.eat();c.catchMice();//错误的演示
//        Dog3 dd = new Animal3();
//        Dog3 ddd = new Cat3();
//        Dog3 dddd = (Dog3) a; //ClassCastException

/*   test2爷爷 --- 父亲 --- 儿子*/
class GrandFather{public void song(){System.out.println("唱山歌");}
}class Father extends GrandFather{public void song(){System.out.println("唱情歌");}
}class Son extends Father{public void song(){System.out.println("唱儿歌");}
}public class PolymorphicTest12 {public static void main(String[] args) {//向上转型GrandFather gf = new Father();//向上转型GrandFather gf1 = new Son();//向下转型，可以看做是对gf1的重新向上转型Father f = (Father) gf1;// 向上转型Father f1 = new Son();//ClassCastException//Son s = (Son)((Father)gf);}
}

//   test3
/*不同地方饮食文化不同的案例*/class Person{public void eat(){System.out.println("吃饭");}
}class SouthPerson extends Person{public void eat(){System.out.println("炒菜，米饭");}public void playMahjong(){System.out.println("打麻将");}
}public class PolymorphicTest3 {public static void main(String[] args) {//测试        //南方人Person p1 = new SouthPerson();p1.eat();//使用匿名对象的方式调用((SouthPerson) p1).playMahjong();
//        p1.playMahjong();

/*   test4继承的时候：子类中有和父类一样的方法的时候，叫重写，覆盖子类中没有和父类一样的方法的时候，方法就被继承过来，但是当子类重写了父方法，结果就是被重写的那个结果*/class A{public void show(){show2();}public void show2(){System.out.println("这是show2方法");}
}class B extends A{//    此处的方法写不写都一样，因为和继承来的相同
//    public void show(){//        show2();
//    }public void show2(){System.out.println("这是在B里面的show2方法");}
}class C extends B{public void show(){super.show();}public void show2(){System.out.println("这是在C里面的show2方法");}}public class PolymorphicTest4 {public static void main(String[] args) {A a = new B();a.show(); //结果是B的show2B b = new C();b.show(); //结果是C的show2}
}

总结

final 关键字
修饰类
该类不能被继承
修饰变量
成员变量成为常量，只能被赋值一次，不能被修改
修饰成员方法
方法不能被重写

多态
向上转型
多态就是一个典型的向上转型，指向派生类的父类引用
父类对象名 = new 派生类
可以看做是派生类的核心，外面套了一层父类的外壳
此时只能使用父类拥有的成员

向下强制转型
将被父类引用的派生类重新用派生类引用接回
派生类对象名 = （派生类）父类
可以看做是将多态时套上的外壳剥下，回归初识状态
此时可以使用子类特有的成员

day11 Java 面向对象 final 多态相关推荐

Java面向对象：多态——基于继承的向上转型、方法重写、动态绑定
Java面向对象:多态 1.多态的概念 2.向上转型和向下转型 (1)向上转型 (2)向下转型 3.方法重写 4.动态绑定与静态绑定 5.多态的优缺点 ======================== ...
JAVA面向对象-----final关键字
JAVA面向对象-–final关键字 1:定义静态方法求圆的面积 2:定义静态方法求圆的周长 3:发现方法中有重复的代码,就是PI,圆周率.1:如果需要提高计算精度,就需要修改每个方法中圆周率. 4: ...
12 Java面向对象之多态
JavaSE 基础之十二 12 Java面向对象之多态 ① 多态的概念及分类多态的概念:对象的多种表现形式和能力多态的分类 1. 静态多态:在编译期间,程序就能决定调用哪个方法.方法的重载就表现出 ...
Java 面向对象：多态的理解
Java 面向对象:多态的理解一.多态的定义一个对象的实际类型是确定的,但可以指向引用对象的类型可以有很多(父类,有关系的类) 操作符的多态 +可以作为算数运算,也可以作为字符串连接类的多态父 ...
Java面向对象之多态(来源于身边的案例)
2019年1月3日星期四 Java面向对象之多态(来源于身边的案例) 1. 为什么要用多态? 1.1 多态是面向对象的三大特性之一 1.2 多态是基于接口设计的模型 1.3 多态具有横向扩展特性 1 ...
面向小姐姐的编程——JAVA面向对象之多态
多态概述什么是多态? 多种状态,同一对象在不同情况下表现出不同的状态或行为比如你女朋友,会有多种表情,多种姿态,多种情绪,这都是多态. Java中实现多态的步骤要有继承(或实现)关系要有方法重 ...
Java面向对象-final类和final方法、final变量(常量)
为什么得需要使用final修饰符继承关系最大的弊端是破坏封装:子类能访问父类的实现细节,而且可以通过方法覆盖的形式修改实现细节. final本身的含义是"最终的,不可改变的",它 ...
Java面向对象之多态解析、final关键字
一.多态 1.简单说明 (1)同一个对象拥有多个状态,可以把不同的类型进行统一,让程序具有超强的可扩展性,简化了调用时的操作. (2)"父类=子类"向上赋值:因为子类可以当做父类看 ...
JAVA面向对象OOP多态→抽象类abstract、接口interface实现implement、final不变修饰符、样例代码
抽象类抽象类-接口关系示意图如果一个类实现接口,就要把接口中所有的抽象方法都重写. A接口继承另一个B接口时,类要重写AB两个接口的方法如果只是实现部分接口,可以用抽象类实现. 抽象类与接口不同 ...

day11 Java 面向对象 final 多态

文章目录