java-day10-多态

10.1 练习

毕姥爷:

1. 讲课
2. 钓鱼

毕老师 extends 毕姥爷

1. 讲课
2. 钓鱼

要求看到向上转型，向下转型

package day09;


class BiLaoYe{
    public void lecture(){
        System.out.println("1毕姥爷讲课");
    }
    public void fish(){
        System.out.println("2毕姥爷钓鱼");
    }
}

class BiLaoShi extends BiLaoYe {
    public void lecture(){
        System.out.println("3毕老师讲课");
    }
    public void watchMovie(){
        System.out.println("4毕老师看电影");
    }
}
public class DuoTaiTest {

    public static void main(String[] args){

        BiLaoYe ly = new BiLaoShi(); //向上转型
        ly.fish();
        ly.lecture();

	   // 想使用子类的具体方法的时候，向下转型
        BiLaoShi ls = (BiLaoShi)ly;  //只能让父类引用转型
        ls.fish();
        ls.lecture();
        ls.watchMovie();  
        // 向上或向下转型过程中，始终只有子类对象在做着类型的变化
    }
}

结果：

2毕姥爷钓鱼
3毕老师讲课
2毕姥爷钓鱼
3毕老师讲课
4毕老师看电影

10.2 USB接口练习

阶段一：描述笔记本电脑

class NoteBook{
    public void run(){
        System.out.println("run");
    }
    }
}

public class Test {
    public static void main(String[] args){
        NoteBook nb = new NoteBook();
        nb.run();
    }

}

阶段二：需要一个鼠标。说明笔记本电脑多了一个使用鼠标的功能。

package day10;

class NoteBook{
    public void run(){
        System.out.println("run");
    }
    //定义使用鼠标的功能，鼠标不确定
    public void useMouse(Mouse m){

        //判断一下，m必须指向鼠标对象才可以调用
        if(m != null){
            m.open();
            m.close();
        }
    }
}

//多一个对象，鼠标
class Mouse{

    //开启功能
    public void open(){

        System.out.println("open");
    }

    //关闭功能
    public void close(){
        System.out.println("close");
    }
}

public class Test {
    public static void main(String[] args){
        NoteBook nb = new NoteBook();
        Mouse m = new Mouse();
        nb.run();
        nb.useMouse(m);
    }

}

阶段三：如果还想使用其他设备，比如键盘，外置硬盘。

1. 可以通过在笔记本对象那个中继续定义useKey（）等方法来完成。
2. 但是出现问题：每增加一个设备都需要不断的改动笔记本类中的内容。拓展性太差，维护性也不好。
3. 咋办？后期的设备是不确定的，每增加一个设备就要增加一个功能，就说明设备和笔记本的耦合性太强。
4. 我不要每次都面对具体的烈性，只要定义一个规则，让后期的设备都符合这个规则。这样只要面对规则就可以了。
5. Java可以通过接口的形式来完成规则的定义，进行解耦。Java可以通过接口的形式来完成规则的定义，进行解耦。

重新设计：

package day10;

/*
class NoteBook{
    public void run(){
        System.out.println("run");
    }
    //定义使用鼠标的功能，鼠标不确定
    public void useMouse(Mouse m){

        //判断一下，m必须指向鼠标对象才可以调用
        if(m != null){
            m.open();
            m.close();
        }
    }
}

//多一个对象，鼠标
class Mouse{

    //开启功能
    public void open(){

        System.out.println("open");
    }

    //关闭功能
    public void close(){
        System.out.println("close");
    }
}
*/

import jdk.dynalink.NamedOperation;

//1.先设计规则
interface USB{

    //设备开启
    public void open();

    //设备关闭
    public void close();
}

//描述笔记本
class NoteBook{

    public void run(){
        System.out.println("book run");
    }

    //使用符合规则的外围设备
    public void useUSB(USB usb){ //定义一个接口类型的引用
        if(usb != null){
            usb.open();
            usb.close();
        }

    }
}

//一年后想买鼠标，只要买符合规则的鼠标，笔记本电脑就可以用
class MouseByUSB implements USB{
    public void open(){
        System.out.println("mouse open");
    }
    public void close(){
        System.out.println("mouse close");
    }
}

//想要键盘
class KeyByUSB implements USB{
    public void open(){
        System.out.println("key open");
    }
    public void close(){
        System.out.println("key close");
    }
}
public class Test {
    public static void main(String[] args){

        NoteBook book = new NoteBook();
        book.run();
        book.useUSB(new MouseByUSB());  //多态,提高笔记本的拓展性
        book.useUSB(new KeyByUSB());
    }

}

10.3 多态中成员变量的调用

多态中成员变量的调用

1. 成员变量
2. 成员函数
3. 静态函数

成员变量
当子父类出现同名成员变量时，

1. 多态调用时，只看调用该成员变量的引用所属的类中的成员变量
2. 简答说，无论编译或者运行，都看等号的左边。

class Fu{
    int num = 4;
}

class Zi extends Fu{
    int num = 6;
}
public class Test {
    public static void main(String[] args){

       Fu fu = new Zi();
       System.out.println(fu.num); //输出4

    }

}

10.4 多态中成员函数的调用

成员函数
出现一模一样函数时，
编译时，看的是引用变量所属的类中的方法
运行时，看的是对象所属的类中方法（运行时候，子类覆盖了父类的方法）

简单说：编译看左边，运行看右边

class Fu{
    int num = 4;
    void show(){
        System.out.println("fu show");
    }
}

class Zi extends Fu{
    int num = 6;

    void show(){
        System.out.println("zi show");
    }
}
public class Test {
    public static void main(String[] args){

       /*Fu fu = new Fu();
       fu.num = 8;*/
       Fu fu = new Zi();
       fu.show(); //输出zi show

    }

}

10.5 多态中静态函数&练习

静态函数
出现一模一样函数时，多态调用
编译和运行是看引用变量所属的类中的方法。
静态函数的调用只看类，不看对象
简单说：只看左边

其实大家知道，真正调用静态方法是不需要对象的，直接类型调用，因为静态方法绑定到类上。所以上述情况，多用于面试。

class Fu{
    int num = 4;
    void show(){
        System.out.println("fu show");
    }
    static void  staticMethod(){
        System.out.println("fu static method");
    }
}

class Zi extends Fu{
    int num = 6;

    void show(){
        System.out.println("zi show");
    }

    static void  staticMethod(){
        System.out.println("zi static method");
    }
}
public class Test {
    public static void main(String[] args){

       /*Fu fu = new Fu();
       fu.num = 8;*/
       Fu fu = new Zi();
       fu.staticMethod(); // 输出fu static method

    }

}

练习

this代表本类引用，具体说是本类型的引用。
例一

class Fu{
    int num = 4;
    void show(){
        System.out.println("fu show:"+this.num);
    }
}

class Zi extends Fu{
    int num = 6;
}
public class Test {
    public static void main(String[] args){
        
       Fu fu = new Zi();
       fu.show();//输出fu show:4
    }

}

例二

class Fu{
    int num = 4;
    void show(){
        System.out.println("fu show:"+this.num);
    }
}

class Zi extends Fu{
    int num = 6;
    void show(){
        System.out.println("zi show:"+this.num);
    }
}
public class Test {
    public static void main(String[] args){

       Fu fu = new Zi();
       fu.show();  //输出zi show:6
    }

}