基础学习day08---多态、简单工厂、Object类equals和toString

一、多态

1.1、多态概念

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

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

    作用：
    多态的存在提高了程序的扩展性和后期可维护性。
    
    前提：
    1. 需要存在继承或者实现关系。
    2. 需要有覆盖操作。

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

1.2、2种类型

向上转型和向下转型

 

1.3、向上转型

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

但运行时为子类的类行

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

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
 
    }

}

结果：

5

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