day13_多态 类型转换 final关键字

今日内容

• 多态

• 类型转换（向上转换，向下转换）

• final关键字

1.多态

　　1.1多态的定义

　　　　同一行为具有多个不同的表现形态。这就是多态。举例：跑的动作，猫狗大象跑的都不一样。

　　^{1.2多态的前提}

　　　　1.继承或者实现【二选其一】
　　　　2.父类的引用指向了子类的对象【多态的格式体现】
　　　　3.方法的冲写【如果不重写，多态就没有意义】

　　1.3多态的格式

父类类型   变量名  =   new  子类对象;
变量名。方法名（）；

　　1.4多态的表现

父类类型指的是子类对象继承的父类类型，或者实现的父类接口类型

public class FU {
public void method() {
System . out . println("这是父类的method方法" );
}
public class Zi extends FU {
    @Override
    public void method(){
        System.out.println("子类的构造方法被执行");
    }
}
// polymorphism 多态
public class TestPolyDemo01 {
public static void main(string[] args) {
    //多态的格式
    /*
    父类类型   变量名   =  new    子类对象;
    变量名.方法名();
    */
    //父类的引用指向了子类的对象
    Fu fu = new Zi();
    fu.method();//本质调用的是子类当中重写之后的method方法
}
}

如果在使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译报错，如果有，执行子类重写后的方法

　　1.5多态的好处

　　

 在实际开发中，父类类型作为方法的形式参数(不同于实际参数)，传递子类对象(实参)给方法，进行方法的调用，更能体现出多态的扩展性和便利性。代码如下:

// 定义抽象的父类
public abstract class Animal{
    // 定义一个抽象的方法
    public abstract void eat();
    public void run(){
        System.out.println("用脚跑。。。");
    }
}
// 定义子类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}
public class Bird extends Animal {
    @Override
    public void eat(){
        System.out.println("鸟吃虫");
    }
}
// 定义测试类
public class TestDemo03 {
    public static void main(String[] args) {
        // 根据不同的对象，来表现不同的吃的内容
        Cat c = new Cat();
        showCatEat(c);// 猫吃鱼
        
        Dog dog = new Dog();
        showDogEat(dog);// 狗啃骨头
        
        Bird bird = new Bird();
        bird.eat();// 鸟吃虫子。。
        
        Cat c2 = new Cat();
        showAnimalEat(c2);
        
        // 
        Dog dog2 = new Dog();
        showAnimalEat(dog2);
        
    }
   /* public static void showCatEat(Cat cat) {
        cat.eat();// 猫吃鱼
    }
    public static void showDogEat(Dog dog) {
        dog.eat();
    }
    public static void showBirdEat(Bird bird) {
        bird.eat();
    }*/
    
    /*
       以上三个方法可以用来多态进行优化,可以被showAnimalEat方法所替代
    */
    public static void showAnimalEat(Animal animal) {
        animal.eat();
        animal.run();
    }
}

由于多态特性的支持，showAnimalEat方法当中的Animal类型，是Cat和Dog的父类类型，父类类型接受子类对象，当然可以把cat对象和dog对象传递给方法。
当程序执行过程中，执行eat方法实际执行的是各自子类对象重写之后的eat方法不仅仅可以做到替代，在扩展性方面，无论之后出现多个子类，
都不需要编写showXxxeat方法了，直接使用showAnimalEat（）方法了。所以多态的好处，体现在可以使程序编写更简单并且具有良好的扩展性。

　　1.6 访问类中的成员变量有两种方式：

1.直接通过对象名访问成员变量：看等号左边是谁，优先用谁，没有就继续网上找
2.间接通过成员方法访问成员变量：看该方法属于谁，就优先用谁，没有则继续往上找

//定义一个父类
public class Fu{
    int  num = 10;
//定义一个成员方法
    public void showNum(){
        System.out.println(num);
    }
}

//定义一个子类
public class Zi extends Fu{
int num  = 20;
@Override
public void showNum(){
　　System.out.println(num);
}
}
//定义测试类
public class TestPolyFieldDemo01{
public static void main(String[] args){
//多态的表示形式
//父类类型  变量名 = new 子类类型;
//变量名.成员变量名
Fu fu=new Zi();
System.out.println(fu.num);//10 這個是直接通过对象访问，等号左边时fu所以结果是10
fu.shownum();//20  这个是通过成员方法访问成员变量，因为之前是向上转型了，所以这里是从子类开始查找，子类的num=20，所以这个num=20


}
}

2.引用数据类型的转型

多态的转型分为向上转型和向下转型

　　2.1向上转型

向上转型：多态本身就是子类类型向父类类型向上转型的过程，这个过程是默认的。当一个父类类型引用指向了一个子类对象，便是向上转型
格式：

父类类型  变量名  =   new  子类类型（）；
比如： Animal  animal = new  Cat();

　　2.2向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的
一个已经向上转型的子类对象，将弗雷德引用转换为子类应用，可以使用强转的格式。

子类类型   变量名  = (子类类型)父类变量名;
比如：Cat   cat  =   (Cat)animal;

3.转型异常（instanceof关键字）

在进行向下转换的过程中，如果=转换类型不正确就会出现java.lang.ClassCastException类型转换异常
为了避免这种类型转换异常的发生，Java提供了instanceof关键字，给引用变量做类型的校验。
格式如下：

变量名   instanceof  数据类型
如果变量属于该数据类型，则返回true，通过if
如果变量不属于该数据类型，则返回false

例子：

public class Test{
    public static void main(String[] args){
    //向上转型
    Animal animal = new Cat();
    //向下转型
    //判断 
    //表明你就是一只猫
    if(animal instanceof Cat){
    Cat cat =(Cat) animal;
    cat.eat();//吃鱼
    cat.catchMouse();//逮老鼠
    }else if(animal instanceof Dog){
    //表明你就是一只狗
    Dog dog=(Dog) animal;
    dog.lookDoor();
    }
    }
}

public class DemoInstanceof {
public static void main(String[] args) {
//我给你什么什么 样的动物，然后让它执行该动物独有的功能
//创建一个狗动物
Animal animal = new Dog();
giveAnimal(animal);//狗咬人
}
public static void giveAnimal(Animal animal) {
//先进行引用变量的类型判断
//如果希望用到子类中独有的方法，需要向下转型
//判断一下父类引用animal到底是cat还是dog [还原
if (animal instanceof Cat) {
Cat cat = (Cat) animal ;
cat. catchPeople();//猫抓人
} else if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog. bite();//狗咬人

3.final关键字

　　　　防止更改API当中的类，所以有final关健字，用于修饰不可改变的内容

　　3.1修饰类格式

public final class 类名{
       //类信息 
}

String,Math,Scanner等API类都是被final修饰的，目的是让我们仅仅使用，而不能修改

　　3.2修饰方法

修饰符  final   返回值类型   方法名(参数列表){
        //方法体内容....
}

不能重写final修饰的方法，编译无法通过

　　3.3修饰变量

　　　　3.31局部变量--基本类型

基本类型的局部变量，被final修饰后，只能赋值一次，不能被更改。

public class Demo {
  public static void main(String[] args){
        //声明局部变量
         final  int   num;
        //第一次赋值
         num = 10;  
        //第二次赋值
         num  = 20；//编译报错
}  
}

　　　　3.32局部变量--引用类型

引用类型的局部变量被final修饰后，只能指向一个对象，地址值不能发生改变，但是不影响对象内部的成员变量的修改。(set修改)

public class FinalDemo2 {
    public static void main(String[] args) {
        // 构建一个对象
        final   People  p1 = new People();
        p1 = new People();// 报错，编译无法通过
        // 调用setName()方法
        p1.setName("小王");// 可以修改
    }
}

　　　　3.33成员变量

成员变量涉及到【初始化】的问题，初始化方式有两种，二选其一：

直接初始化：
public class People {
    final String NAME = "小王";
     private int age;
}

构造方法初始化。
public class People {
    final String NAME;
    private int age;
    public People(String name) {
        this.name = name;
    }
}

被final修饰的常量名称，一般都有书写规范，所有字母均为【大写】。