继承和方法重写

一、继承 

定义：在类中创建子类，子类会自动拥有父类所有可继承的方法和属性。

作用：继承使得代码可重用，增加软件的可扩充性。

语法格式：

        package 包名；

        修饰符 class 子类名 extends 父类名{

                方法体

        }

特点：

（1）父类和子类要使用extends关键字实现继承关系。

（2）子类只能有且仅有一个直接父类。

（3）多个类可以继承同一个父类。

（4）一个类的父类可以继承另外的父类。

二、方法重写

定义：子类从父类继承的方法不能满足子类的需求时，子类对父类的同名方法进行重新改写的过程

方法重写的特点：
（1）相同方法名
（2）相同参数列表
（3）相同返回值类型或者是其子类

注意：

（1）子类重写父类方法后，子类对象只会调用重写后的方法

（2）子类重写父类方法时，不能使用比父类方法更严格的访问权限

三、super关键字

作用：访问父类的构造方法、成员变量和成员方法

用法：

（1）调用成员属性

        格式：super.属性

（2）调用成员方法

        格式：super.成员方法

（3）调用构造方法

        格式：super.构造方法

范例代码：

//父类
public class Father {
	
	private String name;
	private String gender;
	private int age;
	
	//无参构造方法
	public Father() {
		super();  //调用Object类的无参构造方法
		System.out.println("我是Father类的无参构造方法");
	}
	
	//有参构造方法
	public Father(String name, String gender, int age) {
		super();//调用Object类的有参构造方法
		this.name = name;
		this.gender = gender;
		this.age = age;
		System.out.println("我是Father类的有参构造方法");
	}
	
	//设置set/get方法
	public String getName() {
		return name;
	}

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

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//成员方法
	public void print () {
		System.out.print("姓名："+this.name+" "+"性别："+this.gender+" "+"年龄："+this.age);
	}
}

//子类
package test;

public class Son extends Father{
	
	private int height;
	private int weight;
	
	//无参构造方法
	public Son() {
		super(); //调用父类Father类的无参构造方法
	}
	
	//有参构造方法
	public Son(int height, int weight) {
		
		super(); //调用父类Father类的有参构造方法
		
		//super关键字调用父类Father成员变量并赋值
		super.setName("张三");
		super.setGender("男");
		super.setAge(23);
		this.height = height;
		this.weight = weight;
	}
	
	//设置set/get方法
	public int getHeight() {
		return height;
	}

	public void setHeight(int height) {
		this.height = height;
	}

	public int getWeight() {
		return weight;
	}

	public void setWeight(int weight) {
		this.weight = weight;
	}
	
	//成员方法
	public void print() {
		super.print(); //调用父类Father类的成员方法
		System.out.println(" "+"身高："+this.height+" "+" "+"体重："+this.weight);
	}
}

//测试类
package test;

public class Test {

	public static void main(String[] args) {
		//使用无参构造方法创建Son类对象
		Son s1 = new Son(); 
		//赋值
		s1.setName("李华");
		s1.setGender("男");
		s1.setAge(23);
		s1.setHeight(176);
		s1.setWeight(136);
		s1.print(); //调用Son类成员方法
		
		//使用有参构造方法实例化对象
		Son s2 = new Son(178,138); 
		//调用Son类成员方法
		s2.print();
	}

}

四、Object类

特点：

（1）所有类的对象都继承Object类中的方法。

（2）Object类通常也被称为超类、基类、或根类

（3）Object类是所有类的父类，所有类都直接或间接继承Object类。

（4）一个类如果没有使用extends关键字指定父类，该类默认继承Object类。

Object类中常用方法

方法	功能
equals（ ）	判断某个对象和此对象是否相等
toString( )	返回该对象的字符串表示
hashCode	返回该对象的哈希码值
clone( )	生成当前对象的一个副本，并返回
getClass( )	获取当前对象所属的类信息，返回Class对象

五、final关键字

特点：final关键字可以修饰类、变量、和方法，含有“最终”和“不可更改”的含义

注意：

（1）final关键字修饰的方法不能被子类重写

（2）final关键字修饰的类为最终类不能被继承

（3）final关键字修饰的变量是常量，只能赋值一次

（4）final关键字修饰成员变量时，必须在声明的同时进行初始化赋值

范例代码：

//父类
package homework;

public class Animal {
	private String name;
	private int health;
	private int love;
	
	//无参构造方法
	public Animal() {
		super();//调用Object类的无参构造方法
		System.out.println("我是animal类中的无参构造方法");
	}
	
	//有参构造方法
	public Animal(String name, int health, int love) {
		super(); //调用Object类的有参构造方法
		System.out.println("我是animal类中的有参构造方法");
		this.name = name;
		this.health = health;
		this.love = love;
	}
	
	//设置set和get方法
	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 printInfo() {
		System.out.println("昵称："+this.getName()+" "+"健康值："+this.getHealth()+" "+"亲密度："+this.getLove());
	}

}

//子类
package homework;

public class Cat extends Animal {
	private String sex;

	//设置无参构造方法
	public Cat(String sex) {
		super(); //调用Animal类中的无参构造方法
		this.sex = sex;
	}

	//设置有参构造方法
	public Cat(String name, int health, int love, String sex) {
		super(name, health, love); //调用Animal类中的无参构造方法
		System.out.println("我是Cat类的有参构造方法");
		this.sex = sex;
	}

	//设置set/get方法
	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	
	//成员方法
	public void printInfo() {
		super.printInfo(); //调用Animal类的成员方法
		System.out.println("性别："+this.getSex());
		
	}
		
}

//子类
package homework;

public class Dog extends Animal {
	private String strain;
	
	//设置无参构造方法
	public Dog() {
		super(); //调用Animal类的无参构造方法
		System.out.println("我是Dog类的无参构造方法");
	}

	//设置有参构造方法
	public Dog(String name, int health, int love, String strain) {
		super(name, health, love); //调用Animal类的有参构造方法
		System.out.println("我是Dog类的有参构造方法");
		this.strain = strain;
	}

	//设置set和get方法
	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}
	
	//成员方法
	public void printInfo() {
		super.printInfo(); //调用Animal类的成员方法
		System.out.println("品种："+this.getStrain());
		
	}


}

//测试类
package homework;

public class Test {

	public static void main(String[] args) {
		//创建Dog类对象
		Dog dog = new Dog("旺财",98,99,"中华田园犬"); //实例化对象
		//调用方法
		dog.printInfo();
		
		
		//创建Cat类对象
		Cat cat = new Cat("小白", 99, 99, "雄性");//实例化对象
		//调用方法
		cat.printInfo();

	}

}