2019-01-20

喵星之旅-成长的雏鹰-java面向对象-4-重写与多态

方法的重写或方法的覆盖（overriding）

子类根据需求对从父类继承的方法进行重新编写
重写时，可以用super.方法的方式来保留父类的方法
构造方法不能被重写

方法重写规则

方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类
父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
父类的私有方法不能被子类覆盖
不能抛出比父类方法更多的异常

Object类

Object类是所有类的父类。

Object类被子类经常重写的方法：
toString() 返回当前对象本身的有关信息，按字符串对象返回
equals() 比较两个对象是否是同一个对象，是则返回true
hashCode() 返回该对象的哈希代码值
getClass() 获取当前对象所属的类信息，返回Class对象

抽象方法

抽象方法没有方法体
抽象方法必须在抽象类里
抽象方法必须在子类中被实现，除非子类是抽象类

public abstract class Pet {
 
	private int health = 100;// 健康值
  
	/**
	 * 无参构造方法
	 */
	public Pet() {
	}
 
	public int getHealth() {
		return health;
	}
 
	public abstract void toHospital();
	
}

类型转换

向上转型

向上转型：父类的引用指向子类对象，自动进行类型转换。

1 2	<父类型> <引用变量名> = new <子类型>();

此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法.
此时通过父类引用变量无法调用子类特有的方法.

向下转型

向下转型：将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换。

1 2	<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;

在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常

instanceof

如何减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常？
ava中提供了instanceof运算符来进行类型的判断.
使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系.

public class Test {
	public static void main(String[] args) {
		//Pet pet = new Dog();
		Pet pet=new Penguin();
		//使用instanceof判断具体宠物类型，调用特定宠物方法
		if (pet instanceof Dog) {
			Dog dog = (Dog) pet;
			dog.catchingFlyDisc();//执行狗狗特有的方法接飞盘
		} else if (pet instanceof Penguin) {
			Penguin penguin = (Penguin) pet;
			penguin.swim();//执行企鹅特有的方法在南极游泳
		}
	}
}

项目：学猫叫

import java.io.File;
import java.io.IOException;
import java.util.UUID;

public abstract class Animal {

    public Animal() {
        //System.out.println("init");
    }
    static int n = 0;

    static int file = 0;

    static {
        File f = new File("0823");
        if (f.exists()) {
            file = 1;
           // System.out.println(1);
        } else {
            try {
                f.createNewFile();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            file = 0;
           // System.out.println(2);
        }
    }


    public static Animal getInstance(){
        //System.out.println("file:" + file);
        if (file == 0) {
            return  new Kitty();
        }

        if (n == 0) {
            n++;
            return  new Kitty();
        }

        String s = UUID.randomUUID().toString();
        boolean flag = true;

        /*s = s.substring(0, 1);//16  8 0-7
        if ("01234567".contains(s)) {
            flag = false;
        }*/

        char c = s.charAt(0);
        if (c >= '0' && c <= '7') {
            flag = false;
        }

        if (flag) {
            return new Kitty();
        } else {
            return new Puppy();
        }

    }
    public abstract void foo();
}




public class Kitty extends Animal {
    private int age;

    private String name;

    public Kitty() {

    }

    @Override
    public void foo() {
        System.out.println("让我们一起学猫叫，一起喵喵喵喵喵~~");
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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




public class Puppy extends Animal {
    private int age;

    private String name;

    public Puppy(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public Puppy() {

    }

    @Override
    public void foo() {
        System.out.println("让我们一起学汪叫，一起汪汪汪汪汪~~");
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    public int getAge() {

        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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


public class Demo03 {
    public static void main(String[] args) throws IOException {

        Animal a1 = Animal.getInstance();
        Animal a2 = Animal.getInstance();
        Animal a3 = Animal.getInstance();
        Animal a4 = Animal.getInstance();
        Animal a5 = Animal.getInstance();
        a1.foo();
        a2.foo();
        a3.foo();
        a4.foo();
        a5.foo();

    }
}