在上海乐字节学习Java的第十五天

Java多态（上）

多态意味着允许不同类的对象对同一消息做出不同的响应

编译时多态（设计时多态，一般为方法重载）

运行时多态（程序运行时动态决定调用哪个方法）

必要条件：
满足继承关系
父类引用指向子类对象
从一定角度来看，封装和继承几乎都是为多态准备的
现实中，多态的例子数不胜数
动物们都有吃东西、跑、跳、叫的方法，不同的动物表现方式不同

类型转换向上转型（Upcast）：将子类型转换为父类型
隐式/自动类型转换，是小类型到大类型的转换
对于向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名
向下转型（Downcast）：将父类型转换为子类型
将一个指向子类对象的父类引用赋值给一个子类的引用
强制类型转换，是大类型到小类型
父类型的引用必须指向转型的子类的对象，即指向谁才能转换谁。不然也会编译出错
通过instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题，提高代码的强壮性

注意
父类引用指向子类实例时，可以调用子类重写父类的方法以及直接继承父类的方法，无法调用子类的特有的方法
静态static方法属于特殊情况，静态方法只能继承，不能重写。调用的时候用谁的引用，则调用谁的版本
代码实现

Animal类

package com.SH.animal;

//抽象类：不允许实例化，可以通过向上转型，指向子类实例
public abstract class Animal {
    //属性：昵称、年龄
    private String name;
    private int month;
    
    public Animal(){
        
    }
    
    public Animal(String name,int month){
        this.name=name;
        this.month=month;
    }

    public String getName() {
        return name;
    }

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

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }
    
    //方法：吃东西
    //抽象方法：不允许包含方法体；子类中需要重写父类的抽象方法,否则，子类也是抽象类
    //static final private不能与abstract并存
    public abstract void eat();
    
    public static void say(){
        System.out.println("动物间打招呼");
    }
}

Cat类


package com.SH.animal;

public class Cat extends Animal {
    //属性：体重
    private double weight;
    
    public Cat(){
        
    }
    
    public Cat(String name,int month,double weight){
        super(name,month);
//        this.setMonth(month);
        this.weight=weight;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
    
    
    //方法：跑动
    public void run(){
        System.out.println("小猫快乐的奔跑");
    }
    
    
    //方法：吃东西（重写父类方法）
    @Override
    public void eat() {
        System.out.println("猫吃鱼~~");
    }
    
    public static void say(){
        System.out.println("小猫碰胡须");
    }

    public void playBall() {
        // TODO Auto-generated method stub
        System.out.println("小猫喜欢玩线球");
    }

Dog类

package com.SH.animal;

public class Dog extends Animal{
    //属性：性别
    private String sex;
    
    public Dog(){
        
    }
    
    public Dog(String name,int month,String sex){
        this.setMonth(month);
        this.setName(name);
        this.setSex(sex);
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    
    
    //方法：睡觉
    public void sleep(){
        System.out.println("小狗有午睡的习惯");
    }
    
    
    //方法：吃东西（重写父类方法）
    @Override
    public void eat() {
        System.out.println("狗吃肉~~");
        
    }
}

Test类


package com.SH.test;

import com.SH.animal.Animal;
import com.SH.animal.Cat;
import com.SH.animal.Dog;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//        Animal one=new Animal();//1

向上转型、隐式转型、自动转型
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法

注意：父类中的静态方法无法被子类重写，所以向上转型之后，只能调用到父类原有的静态方法
小类转型为大类

        */
        Animal two=new Cat();//2
        two.say();
        Cat cat=(Cat)two;
        cat.say();

        Cat cat=new Cat();
        two=cat;
        Animal three=new Dog();//3
        
        one.eat();
        two.eat();
        two.setMonth(2);
        two.getMonth();
        two.run();
        three.eat();
        System.out.println("=================");
        /*向下转型、强制类型转换
         * 子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法
         * 必须满足转型条件才能进行强转
         * instanceof运算符：返回true/false
         */
    if(two instanceof Cat){
            Cat temp=(Cat)two;
            temp.eat();
            temp.run();
            temp.getMonth();
            System.out.println("two可以转换为Cat类型");
        }
    
        if(two instanceof Dog){
            Dog temp2=(Dog)two;
            temp2.eat();
        temp2.sleep();
            temp2.getSex();
            System.out.println("two可以转换为Dog类型");
    }

        if(two instanceof Animal){
            System.out.println("Animal");
        }
    
        if(two instanceof Object){
            System.out.println("Object");
    }

类型转换案例
Master类


package com.SH.animal;

public class Master {
喂宠物
喂猫咪：吃完东西后，主人会带着去玩线球
喂狗狗：吃完东西后，主人会带着狗狗去睡觉
养兔子、养鹦鹉、养乌龟

方案1：编写方法，传入不同类型的动物，调用各自的方法

public void feed(Cat cat){
cat.eat();
cat.playBall();
public void feed(Dog dog){
dog.eat();
dog.sleep();

方案2：编写方法传入动物的父类，方法中通过类型转换，调用指定子类的方法

public void feed(Animal obj){
obj.eat();
if(obj instanceof Cat){
Cat temp=(Cat)obj;
temp.playBall();
}else if(obj instanceof Dog){
Dog temp=(Dog)obj;
temp.sleep();
}

饲养何种宠物
空闲时间多：养狗狗

空闲时间不多:养猫咪

方案1：

public Dog hasManyTime(){
System.out.println("主人休闲时间比较充足，适合养狗狗");
return new Dog();
public Cat hasLittleTime(){
System.out.println("主人平时比较忙碌，适合养猫咪");
return new Cat();

方案2：

public Animal raise(boolean isManyTime){
if(isManyTime){
System.out.println("主人休闲时间比较充足，适合养狗狗");
return new Dog();
}else{
System.out.println("主人平时比较忙碌，适合养猫咪");
return new Cat();
}

MasterTest类

package com.SH.test;
import com.SH.animal.Animal;
import com.SH.animal.Cat;
import com.SH.animal.Dog;
import com.SH.animal.Master;
public class MasterTest {
public static void main(String[] args) {
Master master=new Master();
Cat one=new Cat();
Dog two=new Dog();
master.feed(one);
master.feed(two);
System.out.println("=============");
boolean isManyTime=false;
Animal temp=master.raise(isManyTime);
if(isManyTime){
temp=master.hasManyTime();
}else{
temp=master.hasLittleTime();
System.out.println(temp);
}

抽象类&抽象方法
应用场景：
某个父类只是知道其他子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

abstract定义抽象类
抽象类不能直接实例化，只能被继承，可以通过向上转型完成对象实例
abstract定义抽象方法，不需要具体实现
包含抽象方法的类是抽象类
抽象类中可以没有抽象方法
子类如果没有重写父类所以抽象方法，则也要定义为抽象类
abstract不能与 static、final、private共存
抽象方法在子类实现时访问权限必须大于等于父类方法

Andriod第三方源码分析

Android进阶之旅-(Framework源码分析)

热门文章