方法重写与多态

方法重写

1.在子类和父类直接

2.方法名相同

3.参数个数和类型相同

4.返回类型相同或是其父类

5.访问权限不能严于父类

package com.hz.ch04.test01;

public abstract class Pet {
	private String name;
	private int love;
	private int health;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public Pet(String name, int love, int health) {
		this.name = name;
		this.love = love;
		this.health = health;
	}
	public abstract void print();
}

package com.hz.ch04.test01;

public class Dog extends Pet {

	public Dog(String name, int love, int health) {
		super(name, love, health);
		// TODO 自动生成的构造函数存根
	}
	public void print() {
		System.out.println("宠物的自白：");
    System.out.println("我的名字叫"+getName()+"我的健康值是"+getHealth()+"我和主人的亲密度是"+getLove());
    System.out.println("我是一只雪娜瑞犬");
}
}

Object

object类是超类（基类）

java中所有的类都直接或间接继承Object

类型转换

向上转型：子类转父类（自动转换）

向下转型：父类转子类（强制转换）

instanceof：判断是否可以转换为指定类型

package com.hz.ch04.test04;


import com.hz.ch04.test04.Dog;
import com.hz.ch04.test04.Penguin;
import com.hz.ch04.test04.Pet;

public class Master {
	public void zuo(Pet p) {
			if(p instanceof Dog) {
				Dog dog = (Dog)p;
				dog.pick();
			}else if (p instanceof Penguin) {
				Penguin penguin = (Penguin)p;
				penguin.swimming();
			}
				

		}
	public Pet lingYPet(int type) {
		if(type==1) {
			Dog dog = new Dog("张三", 40, 60, "拉布拉多");
			return dog;
		}else if(type==2) {
			Penguin penguin = new Penguin("李四", 30, 80, "Q妹");
			return penguin;
		}
		return null;
	}
}

抽象

abstract抽象类：不能被实例化，等待被继承

public abstract class Pet

abstract抽象方法：

1.抽象方法使用abstract修饰 public abstract void

2.抽象方法没有方法体

3.抽象方法必须被重写

4.抽象方法必须在抽象类中，而抽象类中可以没有抽象方法

抽象类

public abstract class Animal { 
	public abstract void run();
}

抽象类的子类

public class Cat extends Animal {
    public void run (){
    	System.out.println("小猫在墙头走~~~")；
    }
}

测试类

public class CatTest {
    public static void main(String[] args) { 
        // 创建子类对象
        Cat c = new Cat();
        // 调用run方法
        c.run();
    }
}

多态

在Java中，多态面向对象中的一个重要概念，它允许不同类型的对象对同一方法进行不同的实现。具体来说，多态性指的是通过父类的引用变量来引用子类的对象，从而实现对不同对象的统一操作。

在Java中，要实现多态性，就必须满足以下条件：

继承关系

存在继承关系的类之间才能够使用多态性。多态性通常通过一个父类用变量引用子类对象来实现。

方法重写

子类必须重写（Override）父类的方法。通过在子类中重新定义和实现父类的方法，可以根据子类的特点行为改变这个方法的行为，如猫和狗吃东西的独特行为。

父类引用指向子类对象

使用父类的引用变量来引用子类对象。这样可以实现对不同类型的对象的统一操作，而具体调用哪个子类的方法会在运行时多态决定

class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("狗发出汪汪声");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("猫发出喵喵声");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 父类引用指向子类对象
        Animal animal2 = new Cat(); // 父类引用指向子类对象

        animal1.sound(); // 输出：狗发出汪汪声
        animal2.sound(); // 输出：猫发出喵喵声
    }
}

向上转型和向下转型

向上转型（Upcasting）是指将一个子类的对象引用赋值给其父类类型的引用变量。这是在面向对象编程中的一种常见操作，用于实现多态性和灵活的对象处理。

在向上转型中，子类对象可以被视为父类对象，可以使用父类类型的引用变量来引用子类对象。这样做的好处是可以以统一的方式处理不同类型的对象，实现代码的灵活性和可扩展性。

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型
        animal.eat();  // 调用的是 Dog 类中的 eat() 方法
        // animal.bark();  // 错误：无法访问 Dog 类中独有的方法

        Dog dog = (Dog) animal;  // 向下转型
        dog.bark();  // 调用 Dog 类中的 bark() 方法
    }
}

向下转型（Downcasting）是指将一个父类类型的引用变量转换为其子类类型的引用变量。它与向上转型相反，需要进行显式的类型转换操作。

在某些情况下，当一个对象被向上转型后，它的具体类型信息会丢失，只保留了父类类型的信息。如果我们需要访问子类中特有的成员或调用子类重写的方法，就需要使用向下转型。

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型

        // 使用向下转型之前，需要先检查对象是否实际上是子类的实例
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;  // 向下转型
            dog.bark();  // 调用 Dog 类中的 bark() 方法
        } else {
            System.out.println("animal is not an instance of Dog");
        }
    }
}