30岁开始学java，第一次记录

今年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.输出结果
拉二胡
弹钢琴
拉小提琴
"----------我是分割线--------"
拉二胡
弹钢琴
拉小提琴

标签：instanceof,java,apple,peach,记录,void,30,new,public
来源： https://www.cnblogs.com/wzd19901129/p/14379812.html