面向对象（五）
一、final
1.继承的代码实现：
由于继承中方法有一个现象：方法重写。
所以，父类的功能，就会被子类给覆盖掉
有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
这个时候，针对这种情况，java就提供了一个关键字：final
final："最终"的意思，常见的是它可以修饰类，方法，变量。
class Fu{
// Zi中的show()无法覆盖Fu中的show()
public final void show(){
System.out.println("绝密文件，任何人都不能修改");
}
}
class Zi extends Fu{
public void show(){
System.out.println("这是一堆垃圾");
}
}
class FinalDemo{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}2.final修饰类，方法，变量
final可以修饰类，方法，变量
特点：
final可以修饰类：该类不能被继承。
final可以修饰方法：该方法不能被重写（覆盖，复写）
final可以修饰变量：该变量不能被重新赋值，因为这个变量其实就是常量。
常量：
A、字面值常量
"hello"、10、true
B、自定义常量
final int x = 10
class Fu{
public final int num= 100;
}
class Zi extends Fu{
public void show(){
//无法为最终变量num分配值
num = 10;
System.out.println(num);
}
}
class FinalDemo{
public static void main(String[] args){
Zi z = new Zi();
z.show();
}
}
3.final修饰局部变量的问题
基本类型：基本类型的值不能发生改变
引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。
比如：教室的地址不能变，但是教室里面的学生可以改变。
class Student{
int age = 10;
}
class FinalDemo{
public static void main(String[] args){
//局部变量是基本数据类型
int x = 10;
x = 100;
System.out.println(x);
final int y = 10;
//错误: 无法为最终变量y分配值
//y = 10;
System.out.println(y);
System.out.println("------------");
//局部变量是引用数据类型
Student s = new Student();
System.out.println(s.age);
s.age = 100;
System.out.println(s.age);
System.out.println("-------------");
final Student ss = new Student();
System.out.println(ss.age);
ss.age = 100;
System.out.println(ss.age);
System.out.println("-----------");
//不能这样写，因为引用变量传递是地址值，
//我们这样做，是在重新开辟一个空间
//而final修饰的引用变量是无法重新开辟空间的。
//重新分配内存空间
//错误: 无法为最终变量ss分配值
ss = new Student();
}
}
4.final修饰变量的初始化时机
A:被final修饰的变量只能赋值一次
B:在构造方法完毕前（非静态的常量）
class Demo{
//int num = 10;
//final int num2 = 20;
int num;
final int num2;
public Demo(){
num = 100;
num2 = 200;
}
}
class FinalDemo{
public static void main(String[] args){
Demo d = new Demo();
System.out.println(d.num);
}
}二、多态
1.概述和前提条件
多态：同一个对象（事物），在不同时刻体现出来的不同状态。
举例：
猫是猫，猫是动物。
水（液态，固态，气态）。
多态的前提：
A:要有继承关系
B:要有方法重写。
其实没有也是可以的，但是如果没有这个就没有意义。
C:要有父类引用指向子类对象。
父 f = new 子();
用代码体现一下
多态中的成员访问特点：
A:成员变量:编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。（因为方法存在方法覆盖）
**如果子类中存在方法重写，那么
父类 f = new 子类
中f调用的就是子类中的方法，如果调用的方法子类中没有，那么就调用父类中的方法
D:静态方法
编译看左边，运行看左边
（静态和类相关，算不上重写，所以，访问还是左边的）
由于成员方法存在方法重写，所以它运行看右边。
class Fu{
public int num = 100;
public void show(){
System.out.println("showFu");
}
}
class Zi extends Fu{
public int num = 1000;
public int num2 = 200;
public void show(){
System.out.println("showZi");
}
public void method(){
System.out.println("method");
}
}
class DuoTaiDemo{
public static void main(String[] args){
//要有父类引用指向子类对象。
//父 f = new 子();
Fu f = new Zi();
System.out.println(f.num);
//结果是100
// 错误: 找不到符号
//System.out.println(f.num2);
f.show();
// 错误: 找不到符号
//f.method();
}
}2.多态的好处
A:提高了代码的维护性（继承保证）
B:提高了代码的维护性
猫狗案例代码
class Animal{
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
class Dog extends 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 Pig extends Animal{
public void eat(){
System.out.println("猪吃白菜");
}
public void sleep(){
System.out.println("猪侧着睡觉");
}
}
//针对动物操作的工具类
class AnimalTool{
//私有化工具类构造方法，别人无法创建对象
private AnimalTool(){}
/*
//调用猫的功能
public static void useCat(Cat c){
c.eat();
c.sleep();
}
//调用狗的功能
public static void useDog(Dog d){
d.eat();
d.sleep();
}
//调用猪的功能
public static void usePig(Pig p){
p.eat();
p.sleep();
}
*/
public static void useAnimal(Animal a){
a.eat();
a.sleep();
}
}
class DuoTaiDemo{
public static void main(String[] args){
//我喜欢猫，就养了一只
Cat c = new Cat();
c.eat();
c.sleep();
//我很喜欢猫，所以，又养了一只
Cat c2 = new Cat();
c2.eat();
c2.sleep();
//我特别喜欢猫，又养了一只
Cat c3 = new Cat();
c3.eat();
c3.sleep();
System.out.println("---------------");
//问题来了，我养了很多只猫，每次创建对象是可以接受的
//但是呢？调用方法，你不觉得很相似吗？仅仅是对象名不一样。
//我们准备用方法改进
//调用方式
/*
useCat(c1);
useCat(c2);
useCat(c3);
*/
//AnimalTool.useCat(c);
//AnimalTool.useCat(c2);
//AnimalTool.useCat(c3);
AnimalTool.useAnimal(c);
AnimalTool.useAnimal(c2);
AnimalTool.useAnimal(c3);
System.out.println("---------------");
//我喜欢狗
Dog d = new Dog();
Dog d2 = new Dog();
Dog d3 = new Dog();
//AnimalTool.useDog(d);
//AnimalTool.useDog(d2);
//AnimalTool.useDog(d3);
AnimalTool.useAnimal(d);
AnimalTool.useAnimal(d2);
AnimalTool.useAnimal(d3);
System.out.println("---------------");
//我喜欢宠物猪
//定义一个猪类，她要继承自动物，提供两个方法，并且还要在工具类中添加该类的调用
Pig p = new Pig();
Pig p2 = new Pig();
Pig p3 = new Pig();
//AnimalTool.usePig(p);
//AnimalTool.usePig(p2);
//AnimalTool.usePig(p3);
AnimalTool.useAnimal(p);
AnimalTool.useAnimal(p2);
AnimalTool.useAnimal(p3);
System.out.println("---------------");
//我喜欢宠物狼，老虎，豹子...
//定义对应的类，继承自动物，提供对应的方法重写，并在工具类添加方法调用
//前面几个必须写，但是，工具类每次都改，我就想，能不能不改了？
//所以改用另一种解决方案。
//
}
/*
//调用猫的功能
public static void useCat(Cat c){
c.eat();
c.sleep();
}
//调用狗的功能
public static void useDog(Dog d){
d.eat();
d.sleep();
}
*/
}3.多态的弊端
不能使用子类的特有功能
class Fu{
public void show(){
System.out.println("show Fu");
}
}
class Zi extends Fu{
public void show(){
System.out.println("show Zi");
}
public void method(){
System.out.println("method");
}
}
class DuoTaiDemo{
public static void main(String[] args){
Fu fu = new Zi();
fu.show();
//错误: 找不到符号
fu.method();
}
}4.多态中向上转型和向下转型
多态的弊端：
不能使用子类的特有功能
我就想使用子类的特有功能？行不行？
行。
怎么用呢？
A：创建子类对象调用方法即可。(可以，但是很多时候不合理，而且，太占内存了)
B：把父类的引用强制转换为子类的引用。（向下转型）
对象间的转换问题：
向上转型：
Fu f = new zi();
向下转型：
Zi z = (Zi)f;//要求这里的f必须是能够转换为子的。
class Fu{
public void show(){
System.out.println("show Fu");
}
}
class Zi extends Fu{
public void show(){
System.out.println("show Zi");
}
public void method(){
System.out.println("method");
}
}
class DuoTaiDemo{
public static void main(String[] args){
Fu fu = new Zi();
fu.show();
//错误: 找不到符号
//fu.method();
//创建子类对象
//方式1：使用这种方法，内存是两个对象
//Zi z = new Zi();
//z.show();
//z.method();
//方式2：使用这种方法，内存中是一个对象。
//你能够把子的对象赋值给父亲，那么我能不能
//把父的引用赋值给子的引用呢？
Zi z = (Zi)fu;
z.show();
z.method();
}
}4.多态问题理解——孔子装爹案例
class 孔子爹 {
public int age = 40;
public void teach(){
System.out.println("讲解javase");
}
}
class 孔子 extends 孔子爹 {
public int age = 20;
public void teach(){
System.out.println("讲解javase");
}
public void playGame(){
System.out.println("英雄联盟");
}
}
//java培训特别火，很多人来请孔子爹去讲课，这一天孔子爹被请走了，
//但是还有人来请，就剩孔子在家，价格还挺高，孔子一想，我是不是可以考虑去呢？
//然互就穿上爹的衣服，带上爹的眼镜，粘上爹的胡子。就开始装爹。
//向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age);
k爹.teach();
k爹.playGame();//这是儿子才能做的
//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
孔子 K = （孔子）k爹；
System.out.println(k.age);//20
k.teach();//讲解论语
k.playGame();//英雄联盟5.多态的内存图解
6.多态中的对象变化内存图解
/*
ClassCastException:类型转换异常
一般在多态的向下转型中容易出现
*/
class Animal{
public void eat(){}
}
class Dog extends Animal{
public void eat(){}
public void lookDoor(){}
}
class Cat extends Animal{
public void eat(){}
public void playGame(){}
}
class DuoTaiDemo{
public static void main(String[] args){
//内存中的是狗
Animal a = new Dog();
Dog d = (Dog)a;
//内存中的是猫
a = new Cat();
Cat c = (Cat)a;
//内存中的是猫
Dog dd = (Dog)a;//.ClassCastException
//java中类型转换不匹配的错误
}
}7.面试题
/*
看程序写结果：先判断有没有问题，如果没有，写出结果
多态的成员访问特点：
方法：编译看左边，运行看 右边
继承的时候：
子类中有和父类中一样的方法，叫重写。
子类中没有和父亲中出现过的方法，方法就被继承
*/
class A{
public void show(){
show2();
}
public void show2(){
System.out.println("我");
}
}
class B extends A{
/*
public void show(){
show2();
}
*/
public void show2(){
System.out.println("爱");
}
}
class C extends B{
public void show(){
super.show();
}
public void show2(){
System.out.println("你");
}
}
public class DuoTaiTest2{
public static void main(String[] args){
A a = new B();
a.show();
B b = new C();
b.show();
}
}
/*
结果：爱你
*/