一、多态

1.1、多态概念

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

例：动物中猫，狗。
猫这个对象对应的类型是猫类型：猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物：动物 y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。
父类型引用指向了子类对象。

体现：
父类或者接口的引用指向或者接收自己的子类对象。

作用：
多态的存在提高了程序的扩展性和后期可维护性。

前提：
1. 需要存在继承或者实现关系。
2. 需要有覆盖操作。

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

1.2、2种类型

向上转型和向下转型

1.3、向上转型

声明时为父类的类型，如动物小鸟=new 小鸟();

但运行时为子类的类行

任何子类存在的地方都可以用父类来替代

JAVA基础学习(八)---多态、简单工厂、Object类equals和toString

package com.day08.doutai.demo1;

public abstract class Animal {

private String name;
private String gender;

/**
     * 吃饭方法
*/
public abstract void eat();

public String getName() {

return name;
    }


public void setName(String name) {
this.name = name;
    }


public String getGender() {
return gender;
    }


public void setGender(String gender) {
this.gender = gender;
    }


}

package com.day08.doutai.demo1;
/**
 * 小鸟吃虫子
 * @author denny
 *
*/
public class Bird extends Animal {

    @Override
public void eat() {
        System.out.println("小鸟吃虫子");
    }
public void fly(){
        System.out.println("小鸟在天上飞");
    }

}

package com.day08.doutai.demo1;
/**
 * 小狗吃骨头
 * @author denny
 *
*/
public class Dog extends Animal {

    @Override
public void eat() {
    System.out.println("小狗吃骨头");
    }

public void run(){
        System.out.println("小狗在地上跑!");
    }
}

package com.day08.doutai.demo1;
/**
 * 小猪类
 * @author denny
 *
*/
public class Pig extends Animal {

    @Override
public void eat() {
        System.out.println("小猪吃杂食!");

    }

public void sleep(){
        System.out.println("小猪在睡觉!");

    }
}

测试类

package com.day08.doutai.demo1;
/**
 * 多态向上转型 
 * 声明状态进为父类
 * 运行时状态为子类
 *  @author denny
*/
public class AnimalTest1 {

public static void main(String[] args) {
//声明小狗
        Animal dog=new Dog();
//声明小猪
        Animal pig=new Pig();
//声明小鸟
        Animal bird=new Bird();

        getAnimal(dog);
        getAnimal(pig);
        getAnimal(bird);
    }

public static void getAnimal(Animal a){
        a.eat();
    }
}

结果：

小狗吃骨头
小猪吃杂食!
小鸟吃虫子

1.4、向下转型

判断是不是子类，是就强制类型转换

intanceof 关键字来判断

以上类不变

package com.day08.doutai.demo1;
/**
 * 多态向上转型 
 * 声明状态进为父类
 * 运行时状态为子类
 *  @author denny
*/
public class AnimalTest1 {

public static void main(String[] args) {
//声明小狗
        Animal dog=new Dog();
//声明小猪
        Animal pig=new Pig();
//声明小鸟
        Animal bird=new Bird();

        getAnimal(dog);
        getAnimal(pig);
        getAnimal(bird);
    }

public static void getAnimal(Animal animal){
//判断是不是 小狗类
if(animal instanceof Dog){
            Dog dog=(Dog)animal;
            dog.run();
//判断 是不是小鸟
        }else if(animal instanceof Bird){
            Bird bird=(Bird)animal;
            bird.fly();
        }else if(animal instanceof Pig){
            Pig pig=(Pig)animal;
            pig.sleep();
        }

    }


}

结果：

小狗在地上跑!
小猪在睡觉!
小鸟在天上飞

1.5、简单工厂

package com.day08.doutai.demo1;

public class AnimalFactory {
    Animal an;
public  Animal getAmincal(String  animal){
if(animal.equalsIgnoreCase("bird")){
            an=new Bird();
        }else if(animal.equalsIgnoreCase("pig")){
            an=new Pig();
        }else if(animal.equalsIgnoreCase("dog")){
            an=new Dog();
        }else{
            System.out.println("没这个动物");
        }

return an;

    }

}

测试类

package com.day08.doutai.demo1;

public class Test1 {

public static void main(String[] args) {


//声明一个工厂类
                AnimalFactory factory=new AnimalFactory();
                Animal animal =factory.getAmincal("dog");
                animal.eat();
    }

}

结果：

小狗吃骨头

1.6、多态中成员变量的特点

成员函数特点：

在编译时期：参阅引用类型变量所属类中是否有这个调用方法，如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用这个方法。

简单：成员函数在多态调用时，编译看左边，运行持右边

无论编译和运行，都参考左边（引用类型变量所属的类）。

静态成员，也是都参考左边

package com.day08.demo1;
/**
 * 父类
 * @author Denny
 *
*/
public class Fu {

//成员变量
int num=5;


}


package com.day08.demo1;

public class Zi extends Fu {
int num=8;

}
package com.day08.demo1;

public class Test1 {

public static void main(String[] args) {
        Fu f=new Zi();
        System.out.println(f.num);  //5
        Zi z=new Zi();
        System.out.println(z.num); //8
 
    }

}

结果：

二、Object类

2.1、Object类

Object类是所有类的根类(间接父类)，Java对象中最*的类。

这个类中定义了所有对象都具备的功能

2.2、equalse()方法

package com.day08.objec.demo1;
/**
 * 人类
 * @author Administrator
 *
*/
public class Person {
/**
     * 姓名
     * 年龄
     * 性别
*/
private String name;
private int age;
private String gender;




/**
     * getter和setter方法
     * @return
*/
public String getName() {
return name;
    }

public void setName(String name) {
this.name = name;
    }
public int getAge() {
return age;
    }
public void setAge(int age) {
this.age = age;
    }
public String getGender() {
return gender;
    }
public void setGender(String gender) {
this.gender = gender;
    }

}

测试类

package com.day08.objec.demo1;

public class Test1 {

public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        Person p3 = p1;
        System.out.println(p1 == p2);
        System.out.println(p1.equals(p2));
        System.out.println(p1 == p3);
        System.out.println(p1.equals(p3));

    }

}

结果：

false
false
true
true

重写equals方法

    
/**
     * 重写equalse方法
*/
    @Override
public boolean equals(Object obj) {
//判断是不是这个对象
if(this==obj){
return true;
        }
//判断 如果是空值就返回false
if(null==obj){
return false;
        }
if(obj instanceof Person){
        Person p=(Person)obj;
return name.equals(p.getName())&&age==p.getAge()&&gender.equals(p.getGender());
        }else{
return false;
        }

    }

测试

package com.day08.objec.demo1;

public class Test1 {

public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("张三");
        p1.setAge(20);
        p1.setGender("男");
        Person p2 = new Person();
        p2.setName("李四");
        p2.setAge(21);
        p2.setGender("女");
        Person p3 = p1;
        p3.setName("张三");
        p3.setAge(20);
        p3.setGender("男");
        System.out.println(p1.equals(p2));
        System.out.println(p1.equals(p3));
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());

    }

}

结果：

false
true
705927765
366712642
705927765

2.3、toString()类

toString=getClass().getName+@+Integer.toHexString(hasCode())

还是上面的Person类

package com.day08.objec.demo1;

public class Test2 {

public static void main(String[] args) {
        Person p1 = new Person();

        System.out.println(p1.toString()); //默认为十六进制
        System.out.println(p1.hashCode());//默认为10进制
        System.out.println(Integer.toHexString(p1.hashCode())); //转换为十六进制
        System.out.println(p1.getClass().getName()+"@"+Integer.toHexString(p1.hashCode()));


    }

}

结果：

com.day08.objec.demo1.Person@2a139a55
705927765
2a139a55
com.day08.objec.demo1.Person@2a139a55

秒客网

JAVA基础学习(八)---多态、简单工厂、Object类equals和toString

一、多态

相关文章