（1）方法重写概念：子类根据需求对从父类继承的方法进行重新编写。重写时，可以用super.方法的方式来保留父类的方法。构造方法不能被重写
（2）方法重写规则
1）方法名相同
2）参数列表相同
3）返回值类型相同或者是其子类
4）访问权限不能严于父类
5）父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法
6）子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)
7）父类的私有方法不能被子类覆盖
8）不能抛出比父类方法更多的异常
（3）方法重写与方法重载比较
1）概念比较：
方法重载：在同一个类中，可以定义多个方法名相同，参数列表不同的方法，与方法的返回值和访问权限没有无关
方法重写：子类根据需求对从父类继承的方法进行重新编写。
2）
| 位置 | 方法名 | 参数列表 | 返回值 | 访问修饰符 | |
| 方法重写 | 子类 | 相同 | 相同 | 相同或是其子类 | 不能比父类更严格 |
| 方法重载 | 同类 | 相同 | 不同 | 无关 | 无关 |
（4）重写的原因：父类方法不满足子类的需求，所以要重写
（5）举例
Animal类：
public class Animal {
private String name;
private int health;
private int love;
public Animal() {
super();//调用父类Object类里的无参构造方法
}
public Animal(String name, int health, int love) {
super();//调用父类Object类里的无参构造方法
this.name = name;
this.health = health;
this.love = love;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
// 定义一个输出动物信息的方法
public void print() {
System.out.println("动物昵称：" + this.name + "，健康值：" + this.health
+ "，亲密度：" + this.love);
}
}
Cat类：
public class Cat extends Animal {
private String color;
public Cat() {
super();
}
public Cat(String name, int health, int love, String color) {
super(name, health, love);
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//重写父类里的print()方法
public void print(){
//输出宠物的所有信息
super.print();
System.out.println("宠物颜色："+this.color);
}
}
Dog类：
public class Dog extends Animal {
private String strain;
public Dog() {
super();// 调用Animal类里的无参构造方法
}
public Dog(String name, int health, int love, String strain) {
super(name, health, love);// 调用Animal类里的有参构造方法
this.strain = strain;
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
//重写print()类
public void print(){
super.print();
System.out.println("宠物品种："+this.strain);
}
}
Penguin类：
public class Penguin extends Animal {
private String sex;
public Penguin() {
super();// 调用父类Animal类里的无参构造方法
}
public Penguin(String name, int health, int love, String sex) {
super(name, health, love);// 调用父类Animal类中的有参构造方法
this.sex = sex;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//重写父类里的print()方法
public void print(){
super.print();
System.out.println("宠物性别："+this.sex);
}
}
Test类：
public class Test {
public static void main(String[] args) {
Cat cat1 = new Cat("敦敦", 88, 99, "黄色");
cat1.print();
Dog dog1 = new Dog("来福", 99, 90, "泰迪");
dog1.print();
Penguin penguin1 = new Penguin("QQ", 90, 91, "Q妹");
penguin1.print();
}
}
2、Object类被子类经常重写的方法
（1）toString()：返回当前对象本身的有关信息，按字符串对象返回
1）Object类里的toString()方法输出的是对象的地址值
2）子类中直接输出对象和通过对象调用toString()方法，都是按照Object类中的toString()方法输出地址值
3）在应用中输出地址值没有具体的意义，所以在子类中都会重写Object类中的toString()方法
4）举例：
Student类：
public class Student {
private String name;
private int age;
public Student() {
super();// 调用父类Object类里的无参构造方法
}
public Student(String name, int age) {
super();// 调用父类Object类里的无参构造方法
this.name = name;
this.age = age;
}
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;
}
//父类Objec类中的toString()不能满足Student类的使用，那么就重写Object类中的toString()方法
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
StudentTest类：
import java.util.Arrays;
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
Student student1 = new Student("张三", 15);
System.out.println(student1);//
String result =student1.toString();
System.out.println(result);//
int[] nums = {};
System.out.println(Arrays.toString(nums));//"[11, 2, 33, 56, 367]"
}
}
}
（2）equals()：比较两个对象是否是同一个对象，是则返回true
1） Object类里的equals()方法比较的对象的地址值
2）子类在进行比较的时候比较地址值没有具体的应用意义，所以在子类中可以重写Object类里的equals()方法实现对象的具体比较
3）举例
Student类：
public class Student {
private String name;
private int age;
public Student() {
super();// 调用父类Object类里的无参构造方法
}
public Student(String name, int age) {
super();// 调用父类Object类里的无参构造方法
this.name = name;
this.age = age;
}
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;
}
//父类Objec类中的toString()不能满足Student类的使用，那么就重写Object类中的toString()方法
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
//重写Object类中的equals()方法：如果两个对象的name和age值一样，就认为两个对象是同一个对象
public boolean equals(Student stu) {
//自己跟自己进行比较
if(this==stu){
return true;
}
//两个对象进行比较,比较姓名和年龄，姓名是String类型，比较内容，采用String里的equals()方法，比较年龄，采用==比较
if(this.name.equals(stu.name)&&this.age==stu.age){
return true;
}
return false;
}
}
Test类：
public class Test {
public static void main(String[] args) {
String str = "abc";
boolean result=str.equals("qwe");
System.out.println(result);
//创建两个学生对象
Student stu1 = new Student("张三", 22);
Student stu2 = new Student("张三", 22);
boolean result2 =stu1.equals(stu2);
System.out.println(result2);//true
}
}
（3）hashCode()：返回该对象的哈希代码值
（4）getClass()：获取当前对象所属的类信息，返回Class对象
3、多态（1）多态概念：同一个引用类型，使用不同的实例而执行不同操作
（同一个父类引用，指向不同子类实例）
（2）举例
使用多态前：
Animal类：
public class Animal {
private String name;
private int health;
private int love;
public Animal() {
super();//调用父类Object类里的无参构造方法
}
public Animal(String name, int health, int love) {
super();//调用父类Object类里的有参构造方法
this.name = name;
this.health = health;
this.love = love;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
// 定义一个输出动物信息的方法
public void print() {
System.out.println("动物昵称：" + this.name + "，健康值：" + this.health
+ "，亲密度：" + this.love);
}
}
Cat类：
public class Cat extends Animal {
private String color;
public Cat() {
super();
}
public Cat(String name, int health, int love, String color) {
super(name, health, love);
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//重新定义父类里的print()方法
public void print(){
//输出宠物的所有信息
super.print();
System.out.println("宠物颜色："+this.color);
}
}
Dog类：
public class Dog extends Animal {
private String strain;
public Dog() {
super();// 调用Animal类里的无参构造方法
}
public Dog(String name, int health, int love, String strain) {
super(name, health, love);// 调用Animal类里的有参构造方法
this.strain = strain;
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public void print(){
super.print();
System.out.println("宠物品种："+this.strain);
}
}
Penguin类：
public class Penguin extends Animal {
private String sex;
public Penguin() {
super();// 调用父类Animal类里的无参构造方法
}
public Penguin(String name, int health, int love, String sex) {
super(name, health, love);// 调用父类Animal类中的有参构造方法
this.sex = sex;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void print(){
super.print();
System.out.println("宠物性别："+this.sex);
}
}
Master类：
public class Master {
// 定义给Cat看病的方法
public void cure(Cat cat) {
// 传递过来的cat对象在健康值小于60的时候需要看病
if (cat.getHealth() < 60) {
System.out.println("打针.....");
cat.setHealth(75);
}
}
// 定义给Dog看病的方法
public void cure(Dog dog) {
// 传递过来的dog对象在健康值小于60的时候需要看病
if (dog.getHealth() < 60) {
System.out.println("吃药.....");
dog.setHealth(80);
}
}
//给Penguin看病
public void cure(Penguin penguin) {
// 传递过来的penguin对象在健康值小于60的时候需要看病
if (penguin.getHealth() < 60) {
System.out.println("打针，吃药.....");
penguin.setHealth(85);
}
}
//一会你又养了其它的100种动物，那么你就需要不断来到Master类中添加相应动物的看病的方法
}
Test类：
public class Test {
public static void main(String[] args) {
//创建Master类对象
Master master = new Master();
//创建Cat类、Dog类、Penguin类对象
Cat cat1 = new Cat("咪咪", 50, 90, "黑色");
master.cure(cat1);
System.out.println(cat1.getHealth());
Dog dog1 = new Dog("旺财", 30, 88, "金毛");
master.cure(dog1);
System.out.println(dog1.getHealth());
Penguin penguin1 = new Penguin("QQ", 40, 90, "公");
master.cure(penguin1);
System.out.println(penguin1.getHealth());
}
}
使用多态后：toHospital()方法
Animal类：
public class Animal {
private String name;
private int health;
private int love;
public Animal() {
super();//调用父类Object类里的无参构造方法
}
public Animal(String name, int health, int love) {
super();//调用父类Object类里的无参构造方法
this.name = name;
this.health = health;
this.love = love;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
// 定义一个输出动物信息的方法
public void print() {
System.out.println("动物昵称：" + this.name + "，健康值：" + this.health
+ "，亲密度：" + this.love);
}
//定义一个Animal去医院看病的方法
public void toHospital(){
System.out.println("去医院找医生看病.....");
}
}
Cat类：
public class Cat extends Animal {
private String color;
public Cat() {
super();
}
public Cat(String name, int health, int love, String color) {
super(name, health, love);
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//重新定义父类里的print()方法
public void print(){
//输出宠物的所有信息
super.print();
System.out.println("宠物颜色："+this.color);
}
public void toHospital(){
System.out.println("(猫)打针......");
this.setHealth(70);
}
}
Dog类：
public class Dog extends Animal {
private String strain;
public Dog() {
super();// 调用Animal类里的无参构造方法
}
public Dog(String name, int health, int love, String strain) {
super(name, health, love);// 调用Animal类里的有参构造方法
this.strain = strain;
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public void print(){
super.print();
System.out.println("宠物品种："+this.strain);
}
public void toHospital(){
System.out.println("（狗）吃药......");
this.setHealth(88);
}
}
Penguin类：
public class Penguin extends Animal {
private String sex;
public Penguin() {
super();// 调用父类Animal类里的无参构造方法
}
public Penguin(String name, int health, int love, String sex) {
super(name, health, love);// 调用父类Animal类中的有参构造方法
this.sex = sex;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void print(){
super.print();
System.out.println("宠物性别："+this.sex);
}
public void toHospital(){
System.out.println("（企鹅）打针，吃药......");
this.setHealth(90);
}
}
Master类：
public class Master {
//带宠物去看病
public void cure(Animal animal){
//宠物健康值小于60，看病
if(animal.getHealth()<60){
animal.toHospital();
}
}
}
Test类：
public class Test {
public static void main(String[] args) {
//创建Master类对象
Master master = new Master();
//创建宠物类对象
Cat cat = new Cat("咪咪", 40, 80, "白色");
master.cure(cat);
System.out.println(cat.getHealth());
//向上转型：父类的引用指向了子类的实例（对象）
Animal animal = new Dog("旺财", 50, 80, "哈士奇");
master.cure(animal);
}
}
5、抽象方法
（1）抽象方法：
1）使用abstract修饰的方法为抽象方法
2）抽象方法没有方法体，即不写花括号
3）抽象方法所在的类要声明为抽象类
4）子类必须重写父类中所有的抽象方法，如果不重写，子类也要定义成抽象类
（2）抽象类：
1）使用abstract修饰的类为抽象类
2）抽象类中可以有普通方法，也可以有抽象方法，也可以没有抽象方法
3）抽象类不能实例化，实例化没有任何意义
6、向上/向下转型（1）向上转型
1）语法结构：
<父类型> <引用变量名> = new <子类型>();
2）此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法；此时通过父类引用变量无法调用子类特有的方法
（2）向下转型
1）语法结构：
<子类型> <引用变量名> = (<子类型> )<父类型的引用变量>;
2）在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常
7、instanceofinstanceof:判断某一个引用指向的是哪一个实例
Java中提供了instanceof运算符来进行类型的判断，使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系
8、举例Animal类：
public abstract class Animal {
private String name;
private int health;
private int love;
public Animal() {
super();//调用父类Object类里的无参构造方法
}
public Animal(String name, int health, int love) {
super();//调用父类Object类里的无参构造方法
this.name = name;
this.health = health;
this.love = love;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
// 定义一个输出动物信息的方法
public void print() {
System.out.println("动物昵称：" + this.name + "，健康值：" + this.health
+ "，亲密度：" + this.love);
}
//定义一个Animal去医院看病的方法（抽象方法）
public abstract void toHospital();
}
Cat类：
public class Cat extends Animal {
private String color;
public Cat() {
super();
}
public Cat(String name, int health, int love, String color) {
super(name, health, love);
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
//重新定义父类里的print()方法
public void print(){
//输出宠物的所有信息
super.print();
System.out.println("宠物颜色："+this.color);
}
@Override
public void toHospital() {
System.out.println("(猫)打针......");
this.setHealth(70);
}
//定义一个Cat类自己的方法
public void play(){
System.out.println("猫咪喜欢粘人，喜欢完球");
}
}
public class Dog extends Animal {
private String strain;
public Dog() {
super();// 调用Animal类里的无参构造方法
}
public Dog(String name, int health, int love, String strain) {
super(name, health, love);// 调用Animal类里的有参构造方法
this.strain = strain;
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public void print(){
super.print();
System.out.println("宠物品种："+this.strain);
}
public void toHospital(){
System.out.println("（狗）吃药......");
this.setHealth(88);
}
public void eat(){
System.out.println("狗吃狗粮和骨头.....");
}
}
Test类：
public class Test {
public static void main(String[] args) {
// Animal animal = new Animal(); //抽象类不能实例化
//向上转型：父类的引用指向子类的实例----》 子---->父
Animal animal = new Cat("咪咪", 50, 80, "白色");
animal.toHospital();
//animal.play(); //父类的引用不能调用子类里独有的方法，要想使用子类特有的方法，需要将父类引用转换成子类对象
// animal = new Dog("旺财", 40, 68, "金毛");
// animal.toHospital();
//instanceof:判断某一个引用指向的是哪一个实例
if(animal instanceof Cat){
//向下转型（引用数据类型的强制转换）：子类的引用指向父类的对象名---->父-->子
Cat cat = (Cat)animal;
cat.play();
}else if(animal instanceof Dog){
Dog dog = (Dog)animal;
dog.eat();
}
}
}
