---恢复内容开始---
Java多态
多态是继封装，继承之后，面向对象的第三大特性
多态最终呈现为父类引用指向子类对象
多态的前提是必须有子父类继承的关系
使用多态后的父类引用变量调用方法时，会调用子类重写之后的方法
多态的定义格式和使用格式：
多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型(); 变量名.方法名();
普通类多态的定义格式：
父类 变量名 = new 子类(); 如： class Fu {} class Zi extends Fu {} //类的多态使用 Fu f = new Zi();
抽象类定义多态的格式：
抽象类 变量名 = new 抽象类子类(); 如： abstract class Fu { public abstract void method(); } class Zi extends Fu { public void method(){ System.out.println(“重写父类抽象方法”); } } //类的多态使用 Fu fu= new Zi();
接口多态的定义格式：
接口 变量名 = new 接口实现类(); 如： interface Fu { public abstract void method(); } class Zi implements Fu { public void method(){ System.out.println(“重写接口抽象方法”); } } //接口的多态使用 Fu fu = new Zi();
注意事项：同一个父类的方法会被不同的子类重写，当变量名指向不同的子类对象时，由于每个子类重写父类方法的内容不同，所以会调用不同的方法
多态成员的特点：
多态成员变量
编译时期：参考引用型变量所属的类中是否被调用的成员变量
运行时期：调用引用型变量所属的类中的成员变量
总结：编译运行看左边
多态成员方法：
编译时期：参考引用变量所属的类，如果类中没有调用的方法，编译失败
运行时期：参考引用变量所致的对象所属的类，并运行对象所属类中的成员方法
总结：编译看左边，运行看右边
instanceof关键字：
作用：用来浦安端某个对象是否属于某种类型。格式：boolean b=对象 instabceof 数据类型；
Person p1 = new Student(); boolean flag = p1 instanceof Student; //true boolean flag2 = p1 instanceof Teacher; //false
多态转型：
向上转型：子类对象赋值给父类引用就是向上转型，多态本身即是向上转型的过程
格式：父类类型 变量名=new 子类类型（）
向下转型：通过向上转型创建出来的父类对象，只能使用父类里面的方法，要想使用子类独有的方法必须强制转变为子类引用，这个过程就是向下转型，
格式：
子类类型 变量名= （子类类型）父类类型的变量；
多态的好处和弊端：
当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。
弊端，只能使用父类共性的内容，而无法使用子类特有功能，功能有限制
//描述动物类，并抽取共性eat方法 abstract class Animal { abstract void eat(); } // 描述狗类，继承动物类，重写eat方法，增加lookHome方法 class Dog extends Animal { void eat() { System.out.println("啃骨头"); } void lookHome() { System.out.println("看家"); } } // 描述猫类，继承动物类，重写eat方法，增加catchMouse方法 class Cat extends Animal { void eat() { System.out.println("吃鱼"); } void catchMouse() { System.out.println("抓老鼠"); } } public class Test { public static void main(String[] args) { Animal a = new Dog(); //多态形式，创建一个狗对象 a.eat(); // 调用对象中的方法，会执行狗类中的eat方法 // a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用 // 为了使用狗类的lookHome方法，需要向下转型 // 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常 // 那么，在转之前需要做健壮性判断 if( !a instanceof Dog){ // 判断当前对象是否是Dog类型 System.out.println("类型不匹配，不能转换"); return; } Dog d = (Dog) a; //向下转型 d.lookHome();//调用狗类的lookHome方法 } }
总结：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型
当要使用子类特有功能时，就需要使用向下转型
向下转型的好处：可以使用子类中独有的方法
弊端：向下转型的是很容易放生类型转换异常，因此需要在转化之前使用instanceof来判断一下数据类型
总结封装继承多态的作用：
封装：吧对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
继承：子类自动继承父类所有可继承的属性和方法
多态：配合继承和方法重写提高了代码的复用性和扩展型，如果没有方法重写，则多态同样没有意义
====================================================================================================================================
构造方法：在用new创建对象的同时赋给对象明确的初始值（对象创建时要执行的方法）
构造方法的格式：
修饰符 构造方法名(参数列表)
{
}
构造方法的体现：
1.构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束
2.构造方法的名称必须和类名一样
3.构造方法没有具体的返回值
构造方法代码例子：
package com.oracle.demo12; public class person { //person的成员变量 private String name; private int age; //person的构造方法 public person(String name, int age) { super(); this.name = name; this.age = age; } //person的成员方法 public void work(){ System.out.println(age+"岁的"+name+"在修车"); } }
构造方法调用：
package com.oracle.demo12; public class man { public static void main(String[] args) { //new新对象的时候同时赋值 person p1=new person("张三",20); p1.work(); } }
默认构造方法和细节：
class Person { //如果没有显示指定构造方法，编译会在编译时自动添加默认的构造方法 //Person(){} //空参数的默认构造方法 }
细节：
1.一个类中可以有多个构造方法，多个构造方法是以方法重载的形式存在的
2.构造方法是可以用private修饰的，作用是不让其他程序创建该类的对象
构造方法和一般方法的区别：
构造方法是在创建新对象的时候调用，而且只用一次
一般方法实在对象创建完后，需要使用了就调用，可以用多次
---恢复内容结束---
Java多态
多态是继封装，继承之后，面向对象的第三大特性
多态最终呈现为父类引用指向子类对象
多态的前提是必须有子父类继承的关系
使用多态后的父类引用变量调用方法时，会调用子类重写之后的方法
多态的定义格式和使用格式：
多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型(); 变量名.方法名();
普通类多态的定义格式：
父类 变量名 = new 子类(); 如： class Fu {} class Zi extends Fu {} //类的多态使用 Fu f = new Zi();
抽象类定义多态的格式：
抽象类 变量名 = new 抽象类子类(); 如： abstract class Fu { public abstract void method(); } class Zi extends Fu { public void method(){ System.out.println(“重写父类抽象方法”); } } //类的多态使用 Fu fu= new Zi();
接口多态的定义格式：
接口 变量名 = new 接口实现类(); 如： interface Fu { public abstract void method(); } class Zi implements Fu { public void method(){ System.out.println(“重写接口抽象方法”); } } //接口的多态使用 Fu fu = new Zi();
注意事项：同一个父类的方法会被不同的子类重写，当变量名指向不同的子类对象时，由于每个子类重写父类方法的内容不同，所以会调用不同的方法
多态成员的特点：
多态成员变量
编译时期：参考引用型变量所属的类中是否被调用的成员变量
运行时期：调用引用型变量所属的类中的成员变量
总结：编译运行看左边
多态成员方法：
编译时期：参考引用变量所属的类，如果类中没有调用的方法，编译失败
运行时期：参考引用变量所致的对象所属的类，并运行对象所属类中的成员方法
总结：编译看左边，运行看右边
instanceof关键字：
作用：用来浦安端某个对象是否属于某种类型。格式：boolean b=对象 instabceof 数据类型；
Person p1 = new Student(); boolean flag = p1 instanceof Student; //true boolean flag2 = p1 instanceof Teacher; //false
多态转型：
向上转型：子类对象赋值给父类引用就是向上转型，多态本身即是向上转型的过程
格式：父类类型 变量名=new 子类类型（）
向下转型：
====================================================================================================================================
构造方法：在用new创建对象的同时赋给对象明确的初始值（对象创建时要执行的方法）
构造方法的格式：
修饰符 构造方法名(参数列表)
{
}
构造方法的体现：
1.构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束
2.构造方法的名称必须和类名一样
3.构造方法没有具体的返回值
构造方法代码例子：
package com.oracle.demo12; public class person { //person的成员变量 private String name; private int age; //person的构造方法 public person(String name, int age) { super(); this.name = name; this.age = age; } //person的成员方法 public void work(){ System.out.println(age+"岁的"+name+"在修车"); } }
构造方法调用：
package com.oracle.demo12; public class man { public static void main(String[] args) { //new新对象的时候同时赋值 person p1=new person("张三",20); p1.work(); } }
默认构造方法和细节：
class Person { //如果没有显示指定构造方法，编译会在编译时自动添加默认的构造方法 //Person(){} //空参数的默认构造方法 }
细节：
1.一个类中可以有多个构造方法，多个构造方法是以方法重载的形式存在的
2.构造方法是可以用private修饰的，作用是不让其他程序创建该类的对象
构造方法和一般方法的区别：
构造方法是在创建新对象的时候调用，而且只用一次
一般方法实在对象创建完后，需要使用了就调用，可以用多次
需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常