JAVA面向对象---多态

原创 已于 2022-08-06 16:23:01 修改
· 148 阅读 · 3 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #jvm

于 2022-08-06 16:20:48 首次发布

多态

**多态：**同一个事物，作用条件不一样，结果不一样
**多态：**同一个父类引用，指向不同的子类实例，执行不同的操作
方法重写是实现多态的前提

多态实现步骤：
1）在抽象父类中定义抽象方法
2）子类继承抽象父类并重写父类中所有的抽象方法
3）测试类中创建父类引用指向不同的子类实例，父类引用调用方法，调用的是子类重写后的那些方法
向上转型（自动类型转换）：父类的引用指向子类的实例
向下转型（强制类型转换）：子类的引用指向父类的引用

向上转型（自动类型转换）：父类的引用指向子类的实例

宠物看病示例：

package cn.bdqn.demo02;

public class Pet {

	private String name;
	private int health;
	private int love;

	public Pet() {
		super();// 调用父类Object类里的无参构造方法
	}

	public Pet(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;
	}

	@Override
	public String toString() {
		return "宠物信息：name=" + name + ", health=" + health + ", love=" + love;
	}
	
	//定义一个去医院看病的方法
	public void toHospatil(){
		System.out.println("宠物生病了，带宠物去看病......");
	}

}

package cn.bdqn.demo02;

public class Cat extends Pet {

	// 定义属性
	private String color;

	public Cat() {
		super();// 调用父类Pet类里的无参构造方法
	}

	public Cat(String name, int health, int love, String color) {
		super(name, health, love);// 调用父类Pet类里的有参构造
		this.color = color;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	@Override
	public String toString() {
		return "宠物信息：name=" + this.getName() + ", health=" + this.getHealth()
				+ ", love=" + this.getLove() + ",color=" + color;
	}
	
	//Pet类中toHospatil()不足以满足Cat类对象看病的需求，所以需要重写
	@Override
	public void toHospatil() {
		if(this.getHealth()<60){
			System.out.println("打针，吃药......");
			this.setHealth(80);
		}
	}

}

```java
package cn.bdqn.demo02;

public class Dog extends Pet {

	private String strain;

	public Dog() {
		super();// 调用父类Pet类里的无参构造方法
	}

	public Dog(String name, int health, int love, String strain) {
		super(name, health, love);// 调用父类Pet类里的有参构造方法
		this.strain = strain;
	}

	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}

	@Override
	public String toString() {
		return "宠物信息：name=" + this.getName() + ", health=" + this.getHealth()
				+ ", love=" + this.getLove() + ",strain=" + strain;
	}
	
	@Override
	public void toHospatil() {
		if(this.getHealth()<60){
			System.out.println("打针.......");
			this.setHealth(90);
		}
	}

}

`package cn.bdqn.demo02;

public class Penguin extends Pet {

	private String sex;

	public Penguin() {
		super();// 调用父类Pet类里的无参构造方法
	}

	public Penguin(String name, int health, int love, String sex) {
		super(name, health, love);// 调用父类Pet类里的有参构造方法
		this.sex = sex;
	}

	public String getSex() {
		return sex;
	}

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

	@Override
	public String toString() {
		return "宠物信息：name=" + this.getName() + ", health=" + this.getHealth()
				+ ", love=" + this.getLove() + ",sex=" + sex;
	}

}


``package cn.bdqn.demo02;

public class Master {
	
	//定义给Pet类对象看病的方法
	public void cure(Pet pet){
		//传递过来的pet的健康值<60的时候需要看病
		if(pet.getHealth()<60){
			System.out.println("宠物生病了，需要去医院看病");
			pet.toHospatil();
		}
	}

}

```java
package cn.bdqn.demo02;

public class Test {

	public static void main(String[] args) {
		// 创建Master类对象，带宠物去看病
		Master master = new Master();
		
		//创建Cat类对象
		Cat cat1= new Cat("Tom", 55, 99, "白色");
		System.out.println(cat1.getHealth());
		
		master.cure(cat1);//方法调用的时候，需要什么给什么（给其要求的具体对象或者其子类对象）
		System.out.println(cat1.getHealth());
		
		System.out.println("--------------------");
		
		Dog dog1 = new Dog("旺财", 50, 99, "泰迪");
		System.out.println(dog1.getHealth());
		master.cure(dog1);
		System.out.println(dog1.getHealth());
		
		System.out.println("----------------------------------------");
		
		//类名 对象名= new 子类类名();
		//向上转型：父类的引用指向子类的实例
		Pet pet1 = new Cat("黑猫警长", 45, 100, "黑色");
		master.cure(pet1);
		
		System.out.println("--------------------");
		
		pet1 = new Dog("旺财", 40, 99, "哈士奇");
		master.cure(pet1);
	}

}

抽象类

抽象方法：使用abstract修饰的方法为抽象方法
1）抽象方法没有方法体
2）抽象方法所在的类需要声明为抽象类
3）子类继承一个抽象类后，子类中必须重写抽象父类中所有的抽象方法，如果不重写，那么子类也需要定义为抽象类

抽象类：使用abstract修饰的类为抽象类
1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXxx()/setXxx()方法、重写toString()方法等
2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类）
3）抽象类不能实例化（不能通过new的方式来创建对象）

在这里插入代码片package cn.bdqn.demo06;

public abstract class Father {

	private String name;
	private int age;

	public Father() {
		super();
	}

	public Father(String name, int age) {
		super();
		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;
	}

	@Override
	public String toString() {
		return "Father [name=" + name + ", age=" + age + "]";
	}
	
	public abstract void test();
	/*
	 * 抽象方法：使用abstract修饰的方法为抽象方法
	 * 	1）抽象方法没有方法体
	 *  2）抽象方法所在的类需要声明为抽象类
	 * 	3）子类继承一个抽象类后，子类中必须重写抽象父类中所有的抽象方法，如果不重写，那么子类也需要定义为抽象类
	 * 
	 * 抽象类：使用abstract修饰的类为抽象类
	 * 	1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXxx()/setXxx()方法、重写toString()方法等
	 * 	2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类）
	 * 	3）抽象类不能实例化（不能通过new的方式来创建对象）
	 */

}

```package cn.bdqn.demo06;

public class Son1 extends Father {

	private double height;

	public Son1() {
		super();
	}

	public Son1(String name, int age, double height) {
		super(name, age);
		this.height = height;
	}

	public double getHeight() {
		return height;
	}

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

	@Override
	public void test() {
		System.out.println("我是Son1类中从写Father类里的test()方法");

	}
	
	//定义一个Son1类里独有的方法
	public void son1Method(){
		System.out.println("我是Son1类里的独有方法son1Method()");
	}

}

```java
package cn.bdqn.demo06;

public class Son2 extends Father {
	private double weight;

	public Son2() {
		super();

	}

	public Son2(String name, int age, double weight) {
		super(name, age);
		this.weight = weight;
	}

	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}

	@Override
	public void test() {
		System.out.println("我是Son2类中从写Father类里的test()方法");

	}
	
	//定义一个Son2类中独有的方法
	public void son2Method(){
		System.out.println("我是Son2类中独有的son2Method()方法");
	}

}


package cn.bdqn.demo06;

public class Test {

	public static void main(String[] args) {
		// 创建Father类对象
		// Father father = new Father();//抽象类不能实例化，因为没有意义
		
		//向上转型：父类引用指向子类的实例
		Father father = new Son1("张三", 22, 173);
		father.test();
		
		father = new Son2("李四", 25, 160);
		father.test();
		
		
		//父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)
		Son1 son = (Son1)father;
        father.son1Method();
	}

}
向下转型（强制类型转换）：子类的引用指向父类的引用
  • 父类的引用无法调用子类里独有的方法，必须使用向下转型成对应的子类，才能通过子类去调用子类中独有的方法
  • 在向下转型的时候，容易出现ClassCastException（类型转换异常），原因是将父类引用转换成了不匹配的子类对象，可以通过instanceof关键字类判断父类引用指向的是哪一个子类实例，从而避免类型转换异常
package cn.bdqn.demo06;

public class Test {

	public static void main(String[] args) {
		// 创建Father类对象
		// Father father = new Father();//抽象类不能实例化，因为没有意义
		
		//向上转型：父类引用指向子类的实例
		Father father = new Son1("张三", 22, 173);
		father.test();
		
		father = new Son2("李四", 25, 160);
		father.test();
		
		
		//父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)	
        //通过instanceof关键字类判断父类引用指向的是哪一个子类实例，从而避免类型转换异常
		if(father instanceof Son1){
			//向下转型：子类的引用指向父类的引用
			Son1 son = (Son1)father;
			son.son1Method();
		}else if(father instanceof Son2){
			//向下转型：子类的引用指向父类的引用
			Son2 son = (Son2)father;
			son.son2Method();
		}
		

	}

}
bug_writer01
关注
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值