多态

多态-概述

定义：某一类事物的多种存在形态。

1， 例：动物中猫,狗。

2，猫这个对象对应的类型是猫类型
a: 猫  x=new 猫();

3,同时猫也是动物中的一种，也可以把猫称为
动物。

a:动物  y=new 猫();
b:动物是猫和狗具体事物中抽取出来的父类型。
c:父类型引用指向了子类对象。

对象的多态性。

class 动物{}

class 猫 extends 动物{}

class 狗 extends 动物{}

猫  x =new 猫();

动物  x =new 猫();//一个对象，两种形态。

猫这类事物即具备猫的形态，又具备着动物的形态。
这就是对象的多态性。

简单说：就是一个对象对应着不同的类型。

多态在代码中的体现。
父类或者接口的引用指向其子类的对象。

多态的好处：

提高了代码的扩展性。前期定义的代码可以使用后期的内容。

abstract class Animal{
abstract void eat();
}

class Dog extends Animal{
void eat(){
System.out.println("啃骨头");
}
void lookHome(){
System.out.println("看家");
}
}

class Cat extends Animal{
void eat(){
System.out.println("吃鱼");
}

void catchMouse(){
System.out.println("抓老鼠");
}
}

class Pig extends Animal{
void eat(){
System.out.println("饲料");
}

void gongdi(){
System.out.println("供地");
}
}

public class Three1 {
public static void main(String[] args) {
Cat c=new Cat();
method(c);
}

/*
public static void method(Cat c){
c.eat();
}
public static void method(Dog c){
c.eat();
}
我们发现如果有很多动物需要吃东西，一个个方法的创建会很麻烦。后期不容易维护。
*/

//所以我们不传递具体的对象进行，而是传递其父类
//只要继承了这个方法，我们就可以把吃东西。叫做小动物吃饭。而不是一个个的叫了。
public static void method(Animal a){
a.eat();
}
}

多态的弊端：

前期定义的内容不能使用（调用）后期子类的特有功能。

多态的前提：

1。必须有关系，继承，实现。

2。要有覆盖。

多态-转型

案例1

abstract class Animal{
abstract void eat();
}

class Dog extends Animal{
void eat(){
System.out.println("啃骨头");
}
void lookHome(){
System.out.println("看家");
}
}

class Cat extends Animal{
void eat(){
System.out.println("吃鱼");
}

void catchMouse(){
System.out.println("抓老鼠");
}
}

class Pig extends Animal{
void eat(){
System.out.println("饲料");
}

void gongdi(){
System.out.println("供地");
}
}

public class Five1 {
public static void main(String[] args) {
Animal a =new Cat();//自动类型提升，猫对象提升了动物类型。但是特有功能无法访问
//作用就是限制特有功能的访问。
//专业讲：向上转型。将子类型隐藏。就不能使用子类的特有方法。

a.eat();

//如果还想用具体动物猫的特有功能。
//你可以将该对象进行向下转型。
Cat c=(Cat)a;
c.eat();
c.catchMouse();

//注意：对于转型，自始自终都是子类对象在做着类型的变化。
//  Animal a1=new Dog();
//  Cat  c1= (Cat)a1;  //ClassCastException
}
}

案例2

class 毕姥爷{
void 讲课(){
System.out.println("管理");
}
void 钓鱼(){
System.out.println("钓鱼");
}
}

class 毕老师 extends 毕姥爷{
void 讲课(){
System.out.println("Java");
}

void 看电影(){
System.out.println("看电影");
}
}
public class Six1 {
public static void main(String[] args) {
毕姥爷 c=new 毕老师();
c.讲课();
c.钓鱼();
毕老师  y=(毕老师)c;
y.看电影();
}
}

多态-类型判断-instanceof

abstract class Animal{
abstract void eat();
}

class Dog extends Animal{
void eat(){
System.out.println("啃骨头");
}
void lookHome(){
System.out.println("看家");
}
}

class Cat extends Animal{
void eat(){
System.out.println("吃鱼");
}

void catchMouse(){
System.out.println("抓老鼠");
}
}

class Pig extends Animal{
void eat(){
System.out.println("饲料");
}

void gongdi(){
System.out.println("供地");
}
}

public class Seven1 {
public static void main(String[] args) {

Seven1.method(new Cat());
}

public static void method(Animal a){
a.eat();

if(a instanceof Cat){//instanceof ：用于判断对象的具体类型。只能用于数据类型判断。
Cat c=(Cat)a;      //通常在向下转型前用于健壮性的判断。
c.catchMouse();
}
else if(a instanceof Dog){
Dog d=(Dog)a;
d.lookHome();
}
}
}

多态-成员变量

多态的特点：
1:成员函数：
a:编译时：要查看引用变量所属的类中是否有所
调用的成员。
b:在运行是:要查看对象所属的类中是否有所调用的
成员

2：成员变量:
a:只看引用变量所属的类。

多态时，

成员的特点：
1.成员变量。
编译时：参考引用型变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败。
运行是：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号左边。←

2.成员函数（非静态）。
编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过，没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译时看左边，运行看右边→。(编译时看父类,运行时看子类)

3.静态函数。
编译时：参考引用型变量所属的类中是否有调用的静态函数。
运行时：参考引用型变量所属的类中是否有调用的静态函数。
简单说：编译和运行都看左边。

其实对于静态方法，是不需要对象的，直接用类名调用就可以。

class Fu{
int  num=3;

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

static void method(){
System.out.println("fu static method");
}
}

class Zi extends Fu{
int num=4;

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

static void method(){
System.out.println("zi static method");
}
}
public class Eight1 {
public static void main(String[] args) {
Fu f=new Zi();
System.out.println(f.num);
f.show();

f.method();

}
}