我的第一个博客

今年30岁整，之所以学习代码有两个原因：
1.工作不带有编制，并不稳定，学java想给自己留条后路（最根本的原因）；
2.全球信息化时代，代码已经开始步入“从娃娃抓起”的阶段，为了未来的的十年或是二十年不被人称为“旧时代的文盲”而开始学习javaSE；
3.多个技能；
2021年1月14日零基础（文科）开始学习在bilibili的视频自学JavaSe至今，2021年2月5日，开始记录。
今天学习了面向对象（封装—>继承—>多态）中的多态(Polymorphism)。
下面是课堂笔记：
多态的基础语法：
1.学习多态语法之前，需要普及两个概念：
第一个：向上转型
子—>父（自动类型转换）
第二个：向下转型
父—>子（强制类型转换，需要加强制类型转换符）
注意：Java中允许向上转型，也允许向下转型。
无论是向上转型还是向下转型，两种类型之间必须有继承关系（extends），
没有继承关系，编译器报错。
2.多态指的是：
父类型引用指向子类型对象。
包括编译阶段和运行阶段。
编译阶段：绑定父类的方法
运行阶段：动态绑定子类型对象的方法
这种既包括编译阶段，又包括运行阶段的形态，我们称之为多态（Polymorphism）
3.向下转型，强制类型转换时：必须加instanceof。
为了防止：java.lang.ClassCastException类型转换异常
4.调用子类特有的方法时才进行向下转换（强制类型转换）
5.为了避免类型转换异常，必须加instanceof
运算符：instanceof：运行阶段动态判断
第一：instanceof可以在运行阶段动态判断引用指向的对象的类型
第二：instanceof的语法：(引用 instanceof 类型)
第三：instanceof运算符的运算结果只能是：true/false
第四：c是一个引用，c变量保存了内存地址指向了堆中的对象。
假设(c instanceof Cat)为true表示：
c引用指向的堆内存中的java对象是一个Cat
假设(c instanceof Cat)为false表示：
c引用指向的堆内存中的java对象不是一个Cat
6.程序员要养成一个好习惯：
任何时候进行向下转换时，一定要使用instanceof运算符进行判断（java规范中要求的）
这样可以避免ClassCastException类型转换异常
7.多态在开发中的作用：
降低程序的耦合度，提高程序的扩展力
代码演示1：
1.建Fruit类

public class Fruit {
    private String FruitName;
    private String Source;
    public Fruit(){

    }
    public Fruit(String FruitName , String Source){
        this.FruitName = FruitName;
        this.Source = Source;
    }
    public void setFruitName(String FruitName){
        this.FruitName = FruitName;
    }
    public String getFruitName(){
        return FruitName;
    }
    public void setSource(String Source){
        this.Source = Source;
    }
    public String getSource(){
        return Source;
    }
    public void eat(){
        System.out.println("我想吃水果");
    }

}
2.建apple类

public class apple extends Fruit{
    public void eat(){
        System.out.println("我想吃苹果");
    }
    public void applepai(){
        System.out.println("苹果派");
    }
}

3.建peach类

public class peach extends Fruit {
    public void eat(){
        System.out.println("你在想peach");
    }
    public void eatPeach(){
        System.out.println("吃屁");
    }
}

4.建测试类

public class Polymorphism {
    public static void main(String[] args) {
        Fruit fru1 = new Fruit();
        fru1.eat();
       apple a = new apple();
        a.eat();
        peach p = new peach();
        p.eat();
        System.out.println("--------我是分割线---------");
        //多态演示
        Fruit fru2 = new apple();
        fru2.eat();                 //向上转型
        Fruit fru3 = new peach();
        fru3.eat();
        System.out.println("--------我是分割线---------");
        Fruit fru4 = new apple();
        apple x = (apple)fru4;     //向下转型，强制类型转换,调用子类型中特有的方法
        x.applepai();
        System.out.println("--------我是分割线---------");
        Fruit fru5 = new peach();
        if (fru5 instanceof apple){     //instanceof 判断向下类型转换
            apple y =(apple)fru5;
            y.applepai();
        }else if (fru5 instanceof peach) {
            peach y = (peach)fru5;
            y.eatPeach();
        }
        Fruit fru6 = new apple();
        if (fru6 instanceof apple){
            apple z = (apple)fru6;
            z.applepai();
        }else if (fru6 instanceof peach) {
            peach z = (peach)fru6;
            z.eatPeach();
        }
    }
}

5.输出结果
我想吃水果
我想吃苹果
你在想peach
--------我是分割线---------
我想吃苹果
你在想peach
--------我是分割线---------
苹果派
--------我是分割线---------
吃屁
苹果派
代码演示2：
1.建Musician类

 public class Musician {
   //第一种方法
    /*
    Instrument i;
    public Musician(){

    }
    public Musician(Instrument i){
        this.i = i;
    }
    public void play(){
        i.makeSound();
    }
    */
    //第二种方法
    public void play(Instrument i) {
        i.makeSound();
    }
}

2.建Instrument类

public class Instrument {
    public void makeSound(){

    }
}

3.建Erhu类

public class Erhu extends Instrument {
    public void makeSound(){
        System.out.println("拉二胡");
    }
}

4.建Piano类

public class Piano extends Instrument {
    public void makeSound(){
        System.out.println("弹钢琴");
    }
}

5.建Violin类

public class Violin extends Instrument {
    public void makeSound(){
        System.out.println("拉小提琴");
    }
}

6.建测试类

public class PolymorphismDemo01 {
    public static void main(String[] args) {
        Musician mus1 = new Musician();
        Instrument ins1 = new Erhu();
        ins1.makeSound();
        Instrument ins2 = new Piano();
        ins2.makeSound();
        Instrument ins3 = new Violin();
        ins3.makeSound();
        System.out.println("----------我是分割线--------");
        Erhu erhu = new Erhu();
        Piano piano = new Piano();
        Violin violin = new Violin();
        mus1.play(erhu);
        mus1.play(piano);
        mus1.play(violin);
    }
}

7.输出结果
拉二胡
弹钢琴
拉小提琴
“----------我是分割线--------”
拉二胡
弹钢琴
拉小提琴