Java语言基础面向对象（多态）

面向对象---------多态

面向对象的三大特征：继承、封装（类）、多态
多态：指的是一种事物在不同时期所表现出的不同状态
多态的前提：
（1）要有继承，如果继承没有继承，多态就无从谈起
（2）多态要有方法重写，当然不重写语法上来说不报错，但失去了多态的意义
多态：父类引用 指向子类对象
多态举例：

class Fu{
public void eat(){
System.out.println("==========");

}
class Zi extents Fu{
@Override
public void eat() {
System.out.println("---------");//重写
}
}
public class MyTest {
public static void main(String[] args) {
子类直接创建对象
Zi zi = new Zi();
zi.eat();
多态：父类引用指向子类对象
Fu an=new Zi();
an.eat();

}
}
在上述代码中创建子类对象时，多态的表现就是 Fu an=new Zi()，利用父类引用指向子类对象，这就是多态。

多态访问特点：

（1）采用多态形式去访问成员变量，访问的是父类的成员变量，举例如下，

public class MyTest {
public static void main(String[] args) {
Fu fu=new Zi();
System.out.println(fu.num);//输出结果为20
}
}
class Fu{
int num=20；
}

class Zi extends Fu{
int num=200;
int aa=10;
}
上述例子中就可以说明多态访问成员变量的话是访问父类的成员变量

（2）多态访问构造方法：创建子类对象的时候会访问父类的构造方法并对父类的数据进行初始化。
（3）多态的形式访问成员方法的特点：如果子类没有重写父类的方法，就以父类的方法为准，如果子类重写了父类的方法，那么就以子类重写过后的为准
（4）多态访问静态方法（static修饰的方法）：多态在访问静态方法时，访问的是父类（静态和类相关，算不上重写，所以访问的还是父类）

多态的好处与弊端

多态的好处：
1.提高代码的复用性（继承保证）
2.提高代码的扩展性（由多态保证）
多态的弊端：
不能直接调用子类的特有功能，如果要调用，我们可以向下转型
（向下转型：父类转换成子类；向上转型：子类转换成父类，多态就是向上转型）
public class MyTest {
public static void main(String[] args) {
Fu fu = new Zi();
fu.show();
错误的做法：
fu.method();//原因是因为多态不能直接访问子类的特有功能，因此如果想要访问子类特有功能的话就必须要进行向下转型
正确的做法：
Zi zi= (Zi) fu;//这就是将对象向下转型，将fu对象向下转换成zi对象
zi.method();//zi就可以访问子类特有的功能
}
}

class  Fu{
public void show(){
System.out.println("父类");
}
}

class Zi extends Fu{
@Override
public void show() {
System.out.println("重写了父类");
}

public void method(){
System.out.println("子类特有方法");//子类的一个特有功能
}
}

类型转换异常

类型转换异常会发生在多态中，利用父类创建一个子类对象时，不能直接创建一次来实现两种向下转换（一个多态对象不能直接向下转换为两种不同类型的子类对象），举例说明：
public class MyTest {
public static void main(String[] args) {
Animal an=new Cat();
an.eat();
Cat cat= ((Cat) an); //向下转型访问子类特有对象
错误的做法：
Dog dog = (Dog) an;
dog.lookDoor();//这样直接向下转型为Dog类型的话会出现错误，
//不能直接这样进行向下转型，必须要在new一个Dog类型的对象才能进行向下转型
正确的做法：
an = new Dog();
Dog dog = (Dog) an;
}
}

class Animal{
public void eat(){
System.out.println("吃饭");
}
}
class Dog extends Animal{
public void lookDoor(){
System.out.println("看门");
}
}
class Cat extends Animal{
public void catchMouse(){
System.out.println("抓老鼠");
}
}

多态运行内存图
有代码如下：

public class MyTest {
public static void main(String[] args) {
Father father = new Son();
System.out.println(father.num);  //父类引用访问成员变量，访问的是父类的成员方法100
father.show();//访问成员方法，方法被子类重写，因此应该输出子类的show方法
//向下转型
Son son= (Son) father;
System.out.println(son.num); //向下转型，已经为子类，因此访问的是子类的成员变量50
son.hehe();
}
}
class Father{
int num=100;
public void show(){
System.out.println("父类 show 方法");
}
}
class Son extends Father{
int num=50;
@Override
public void show() {
System.out.println("子类 show 方法");
}
public void hehe(){
System.out.println("子类特有的方法");
}
}
运行结果：
100
子类 show 方法
50
子类特有的方法