Java的多态性和final用法

学习目标：

Java的多态性和final关键字的几种用法

---

学习内容：

1、多态概述
2、final关键字的几种用法

---

学习步骤：

1、多态概述

引入

多态式继封装、继承之后、面向对象的第三大特性。
生活中，比如跑的动作，小猫，小狗和大象，跑起来是不一样的，再比如飞的动作，昆虫、鸟类和飞机。飞起来也是不一样的。可见，同一行为，通过不同的事物。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如student类继承了person类，一个student的对象便既是student，又是person。

定义

是指同一行为，具有多个不同变现形式。
多态体现为父类应用变量可以指向子类对象。

注意：

前提条件：必须由子父类关系。
在使用多态后的父类引用变量调用方法时；会调用子类重写后的方法。

2、final关键字几种用法

(1)修饰变量

#用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。final修饰的变量可以先声明，后赋值。# final修饰基本类型时，起到常量的作用，基本类型的值不可变。final修饰引用类型时,不能再指向其他的对象,但被引用的对象的值是可以改变的(引用变量的值 实际上是它所引用的对象的地址)。

#当用final作用于类的成员变量时，成员变量(局部变量只需要保证在使用之前被初始化赋值即可)必须在定又时或者构造器中进行初始化赋值。

( 2 )修饰方法参数

编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，不会(实际上是不能)改变参数的值，具体类似于修饰数据。即不能改变参数的值,但是可以改变引用类型参数的对象的值。同时，即使没有final的修饰，参数的改变也不会影响到方法外的变量。

(3)修饰方法

final关键字修饰方法，它表示该方法不能被覆盖(重写)。另外，类中所有的private方法都隐式地指定为是final的，由于无法在类外使用private方法,所以也就无法覆盖它。此时可以在子类中定又相同的方法名和参数，这种情况不再产生重写与final的矛盾，而是在子类中重新定又了新的方法。可以对private方法添加final修饰符, 但并没有添加任何额外意义。

(4)修饰类

用final修饰的类是无法被继承的。且final 类中的所有成员方法都会被隐式地指定为final方法。

例题1：

package com.hg.day11.demo02;

public class Fu {
    int num=10;

    public void showNum() {
        System.out.println("父类方法"+num);
    }
    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}

package com.hg.day11.demo02;

public class Zi extends Fu{
    int num=20;
    int age=16;

    public void showNum() {
        System.out.println("子类方法"+num);
    }

    public void method() {
        System.out.println("子类方法");
    }

    public void methodZi() {
        System.out.println("子类特有方法");
    }
}

package com.hg.day11.demo02;


//访问成员变量的两种方式
//1、直接通过对象名称访问
//2、通过成员方法间接访问
public class Demo02MultiField {
    public static void main(String[] args) {

        //直接访问 看等号左边的是谁就用谁 没有则向上找
        Fu obj =new Zi();
        System.out.println(obj.num);//父类 10

        //System.out.println(obj.age);错误用法

        System.out.println("===============");

        //成员方法访问 看该方法属于谁 就用谁
        obj.showNum();//子类方法20

    }
}

运行结果：

package com.hg.day11.demo02;

//成员方法
//new的是谁 就先使用谁

//对比
//成员变量  编译看左边  运行看左边
//成员方法  编译看左边  运行看右边
public class Demo02MultiMethod {
    public static void main(String[] args) {

        Fu obj = new Zi();

        obj.method();
        obj.methodFu();



    }
}

运行结果：

例题2：

package com.hg.day11.demo03;

public abstract class Animal {
    public abstract void eat();
}

package com.hg.day11.demo03;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }

}

package com.hg.day11.demo03;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void watchHouse() {
        System.out.println("狗看门");
    }
}

package com.hg.day11.demo03;

//向上类型转换 总是安全的 但是也有缺陷 原来子类的特有功能不能使用
public class Demo03Main {
    public static void main(String[] args) {
        //向上类型转换 类似于 隐式类型转换
        Animal animal = new Cat();
        animal.eat();

        //animal.CatchMouse();错误

        //向下类型转换 由父类型 转换成子类型
        Cat cat = (Cat) animal;//强制类型转换 还原
        cat.catchMouse();

        //Dog dog=(Dog) animal;
    }
}

运行结果：

package com.hg.day11.demo03;

public class Demo03Instancof {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();
        giveMeAPet(animal);
    }
        public static void giveMeAPet(Animal animal) {
        if(animal instanceof Dog)
        {
            Dog dog=(Dog) animal;
            dog.watchHouse();
        }

        if(animal instanceof Cat)
        {
            Cat cat=(Cat) animal;
            cat.catchMouse();
        }
    }
}

运行结果：

例题3：

package com.hg.day11.demo04;

//final修饰方法的时候 该方法就是最终方法 不能被覆盖重写
public abstract class Fu {
    public final void method() {
        System.out.println("父类方法");
    }

    public abstract /*final*/ void methodAbs();
}

package com.hg.day11.demo04;

public class Zi extends Fu{
    //@Override
    //public void method() {
    //    System.out.println("子类方法");
    //}

    public void methodAbs(){}
}

package com.hg.day11.demo04;

public class Student {
    public String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student() {
    }

    public Student(String name) {
        this.name = name;
    }
}

package com.hg.day11.demo04;


//final 修饰成员变量
//      同样该值不变
//      1、由于成员变量具有默认值，所以使用final后 必须手动赋值。
//      2、对于final成员变量，要么直接赋值，要么通过构造函数进行赋值。
public class Person {
    public final String name;

    public Person() {
        name="关晓彤";
    }

    public String getName() {
        return name;
    }

    //public void setName(String name) {
     //   this.name = name;
    //}

    public Person(String name) {
        this.name = name;
    }
}

package com.hg.day11.demo04;

//被final修饰的类 是一个最终的类 （太监类） 没有儿子
//如果一个类被final修饰 所有成员方法都无法进行覆盖重写
public final class MyClass {
    public void method() {
        System.out.println("方法执行");
    }
}

package com.hg.day11.demo04;

public class MySubClass /*extends MyClass*/{

}

package com.hg.day11.demo04;

//final
//1、用来修饰一个类
//   用来修饰一个方法
//   用来修饰一个局部变量
//   用来修饰一个成员变量
//
//
public class Demo04Final {
    public static void main(String[] args) {

        int num1=10;
        System.out.println(num1);
        num1=100;
        System.out.println(num1);

        final int num2=200;
        System.out.println(num2);
        //num2=2000;错误写法

        final int num3;
        num3=300;
        System.out.println(num3);

        System.out.println("=================");

        Student stu1=new Student("程琪");
        System.out.println(stu1);
        System.out.println(stu1.getName());

        stu1=new Student("赵丽颖");
        System.out.println(stu1);
        System.out.println(stu1.getName());

        System.out.println("======================");

        final Student stu2=new Student("赵又廷");
        System.out.println(stu2);
        System.out.println(stu2.getName());

        //stu2=new Student("高圆圆");错误的写法

        stu2.setName("高圆圆");
        System.out.println(stu2);
        System.out.println(stu2.getName());

        System.out.println("======================");

        Person person=new Person("鹿晗");
        System.out.println(person.getName());
    }
}

运行结果：