方法重写
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 Petabstract抽象方法：
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 {@Overridepublic void sound() {System.out.println("狗发出汪汪声");}
}class Cat extends Animal {@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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");}}
}
