Java 方法重写

Java 方法重写

一、什么是方法重写或方法覆盖（override）

① 子类根据需求对从父类继承的方法进行重新编写。

② 重写时，可以用super.方法的方式来保留父类的方法。

③ 构造方法不能被重写。

二、重写规则

① 方法名相同

② 参数列表相同

③ 返回值类型相同或者是其子类

④ 访问权限不能严于父类

⑤ 父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法不能被子类覆盖为静态方法

⑥ 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法(注：静态方法中无法使用super)

⑦ 父类的私有方法不能被子类覆盖

⑧ 不能抛出比父类方法更多的异常

三、方法重写与方法重载的区别

比较项	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

方法重写：同名同参

方法重载：同名不同参

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);
	}

}

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 class Test {

	public static void main(String[] args) {
		Cat cat1 = new Cat("敦敦", 88, 99, "黄色");
		cat1.print();
	}

}

四、重写toString()方法和equals()方法

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;
	 }

}

public class Demo01 {

	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
		
		/*
		 * Object类里的toString()方法输出的是对象的地址值
		 * 子类中直接输出对象和通过对象调用toString()方法，都是按照Object类中的toString()方法输出地址值
		 * 在应用中输出地址值没有具体的意义，所以在子类中都会重写Object类中的toString()方法
		 * 
		 * Object类里的equals()方法比较的对象的地址值
		 * 	子类在进行比较的时候比较地址值没有具体的应用意义，所以在子类中可以重写Object类里的equals()方法实现对象的具体比较
		 * 
		 * 重写的原因：父类方法不满足子类的需求，所以要重写
		 */
		
	
	}

}