Java面向对象的基本概念-重写与多态

Object类

object类里的toString()方法输出的是对象的地址值

子类中直接输出对象和通过对象调用toString()方法，都是按照0bject类中的toString()方法输出地址值*在应用中输出地址值没有具体的意义，所以在子类中都会重写0bject类中的toString()方法

obiect类里的equals(()方法比较的对象的地址值

子类在进行比较的时候比较地址值没有具体的应用意义，所以在子类中可以重写0bject类里的equals()方法实现对象的具体比较

 

方法的重写或方法的重载:

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

重写是,可以用super()来继承父类的方法

构造方法不能重写

方法重写规则:

1. 类名要相同
2. 返回值类型要相同
3. 参数列表相同
4. 访问抢权限不能严与父类

public class Student {
	private String name;
	private int age;
	private int schoolNumber;
	private String sex;
	public Student(String name, int age, int schoolNumber, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.schoolNumber = schoolNumber;
		this.sex = sex;
	}
	public Student() {
		super();
	}
	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;
	}
	public int getSchoolNumber() {
		return schoolNumber;
	}
	public void setSchoolNumber(int schoolNumber) {
		this.schoolNumber = schoolNumber;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	
	
	@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + ", schoolNumber="
				+ schoolNumber + ", sex=" + sex + "]";
	}
	
	public boolean equals(Student stu){//重写equals方法
		if(this==stu){
			return true;
		}
		
		if(this.name.equals(stu.name)&&this.age==stu.age&&this.schoolNumber==stu.schoolNumber&&this.sex.equals(stu.sex)){
			return true;
		}
		return false;
	}

public class StudentTest {

	public static void main(String[] args) {
		Student stu=new Student("ph",23,1234567,"男");
		Student stu1=new Student("ph",23,1234567,"男");
        String result= stu.toString();
        System.out.println(result);
		boolean bool= stu.equals(stu1);
		System.out.println(bool);
		
	}

}

运行结果:
Student [age=23, name=ph, schoolNumber=1234567, sex=男]
true

abstract

抽象方法

1. 使用abstract修饰的方法为抽象方法
2. 抽象方法没有方法体
3. 抽象方法所在的类要声明为抽象类
4. 子类必须重写父类所有的抽象方法,如果不重写子类也需要定义成抽象类

抽象类

1. 使用abstract修饰的类为抽象类
2. 抽象类可以有普通方法,也可以有抽象类,也可以没有抽象方法
3. 抽象类不能实例化,实例化没有任何

public class Demo01 {
	public static void main(String[] args) {
		Chicken djj=new HomeChicken("大鸡鸡");
		Chicken xjj=new YeChicken("小鸡鸡");
		Chicken sjj=new YeChicken("尖叫鸡");
		djj.eat();
		xjj.eat();
		
		djj=xjj;
		djj.eat();
		eat(djj);
		eat(xjj);
		JianJiaChicken jjj=new JianJiaChicken("尖叫鸡");
		eat(jjj);
		
	}
	

	public static void eat(Chicken c){  //面向抽象编程 ,,面向接口编程,最好使用父类
		System.out.println("吃饭饭");
		c.eat();
		
		//当我们需要把父类的实例强制转换为子类 
		//做出判断
		if(c instanceof JianJiaChicken ){
			JianJiaChicken sjj=(JianJiaChicken)c;
			sjj.song();
		}
	} 
}



//鸡
abstract class Chicken{
	private String name;
	public Chicken(){
		
	}
	public Chicken(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	public abstract void eat();
}

//家鸡
 class HomeChicken extends Chicken{
	 
	 public HomeChicken(String name){
		 super(name);
	 }
	public void eat(){
		System.out.println(this.getName()+",我爱吃米");
	}
}
 
 //野鸡
 class YeChicken extends Chicken{
	 
	 public YeChicken(String name){
		 super(name);
	 }
	public void eat(){
		System.out.println(this.getName()+",我爱吃虫子");
	}
}
 
 
 class JianJiaChicken extends Chicken{
	 
	 public JianJiaChicken(String name){
		 super(name);
	 }
	public void eat(){
		System.out.println(this.getName()+",我喜欢尖叫");
	}
	
	public void song(){
		System.out.println(this.getName()+",我喜欢唱歌");
	}
}

运行结果:
大鸡鸡,我爱吃米
小鸡鸡,我爱吃虫子
小鸡鸡,我爱吃虫子
吃饭饭
小鸡鸡,我爱吃虫子
吃饭饭
小鸡鸡,我爱吃虫子
吃饭饭
尖叫鸡,我喜欢尖叫
尖叫鸡,我喜欢唱歌

instanceof

适用于检查对象是否为指定的类型,通常在把父类引用强制转换为子类引用时要使用,以避免发生类型装换异常(ClassCastException)

语法格式如下:

对象 instanceof 类型   ---返回boolean类型值

示例:

if(homeZChichken instanceof Chicken){//正确是true 错误是flase

//..

}

父类的设计法则

通过instanceof关键字，我们可以很方便的检查对象的类型，但如果一个父类的子类过多，这样的判断还是显得很繁琐，那么如何去设计一个父类呢?

1、父类通常情况下都设计为抽象类或接口，其中优先考虑接口，如接口不能满足才考虑抽象类.

2、一个具体的类尽可能不去继承另一个具体类，这样的好处是无需检查对象是否为父类的对象。

多态性

大致分为两类:

(1):方法的重载和重写

(2):对象的多态性

举例子:

用父类的阴指向子类对象(用大的类型去接受小的类型,向上转型,自动换行)

School  sc=new Student();  //面向抽象编程 ,面向接口编程,最好使用父类

对象的多态性:

对象的多态性是从继承关系中的多个类而来的

总结:

1. 方法的重载与重写就是方法的多态性表现
2. 多个子类就是父类中的多种形态
3. 父类引用可以指向子类对象,自动转换

1. 子类对象指向父类引用需要强制转换(注意:类型不对会报异常)
2. 在实际开发中尽量使用父类引用

//父类动物类
public class Animal {
	//定义属性
	private String name;
	private int  health;
	private int love;
	
	Animal(){//无参构造
		
	}
	
	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 say(){
		System.out.print("我的名字是"+this.name+"健康值是"+this.health+"亲密度是"+this.love);
	}
	
	public void toHospital(){
		System.out.println("去医院看病");
	}
}


//子类狗狗类
public class Dog extends Animal {
	private String sex;
	
	Dog(){//无参构造
		super();
	}
	
	Dog(String sex,String name,int health,int love){
		super(name,health,love);//父类中带参数的构造器
		this.sex=sex ;
		
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public void say(){
		super.say();    //调用父类的方法
		System.out.println("我的性别是"+this.sex);
	}
	
	public void toHospital(){ //方法重写
		super.toHospital();
		System.out.println("狗狗吃药");
		setHealth(85);
	}

//宠物主人类
public class Master {
	//定义动物看病
	public void cure(Animal animal){
		if(animal.getHealth()<60){
			animal.toHospital();
		}
	}
	
}

public class Test {

	public static void main(String[] args) {
		Master mas=new Master();
		Animal dog=new Dog();  //父类调用子类 向上转型
		dog.setHealth(55);	
		mas.cure(dog);     //多态性,后续可以有很多的动物可以写
		System.out.println(dog.getHealth());
	}

}


   

运行结果:

去医院看病

狗狗吃药

85