方法重写与多态

方法重写

1.在子类和父类直接

2.方法名相同

3.参数个数和类型相同

4.返回类型相同或是其父类

5.访问权限不能严于父类

package com.hz.ch04.test01;

public abstract class Pet {
	private String name;
	private int love;
	private int health;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public Pet(String name, int love, int health) {
		this.name = name;
		this.love = love;
		this.health = health;
	}
	public abstract void print();
}

package com.hz.ch04.test01;

public class Dog extends Pet {

	public Dog(String name, int love, int health) {
		super(name, love, health);
		// TODO 自动生成的构造函数存根
	}
	public void print() {
		System.out.println("宠物的自白:");
    System.out.println("我的名字叫"+getName()+"我的健康值是"+getHealth()+"我和主人的亲密度是"+getLove());
    System.out.println("我是一只雪娜瑞犬");
}
}

Object

object类是超类(基类)

java中所有的类都直接或间接继承Object

类型转换

向上转型:子类转父类(自动转换)

向下转型:父类转子类(强制转换)

instanceof:判断是否可以转换为指定类型

package com.hz.ch04.test04;


import com.hz.ch04.test04.Dog;
import com.hz.ch04.test04.Penguin;
import com.hz.ch04.test04.Pet;

public class Master {
	public void zuo(Pet p) {
			if(p instanceof Dog) {
				Dog dog = (Dog)p;
				dog.pick();
			}else if (p instanceof Penguin) {
				Penguin penguin = (Penguin)p;
				penguin.swimming();
			}
				

		}
	public Pet lingYPet(int type) {
		if(type==1) {
			Dog dog = new Dog("张三", 40, 60, "拉布拉多");
			return dog;
		}else if(type==2) {
			Penguin penguin = new Penguin("李四", 30, 80, "Q妹");
			return penguin;
		}
		return null;
	}
}

抽象

abstract抽象类:不能被实例化,等待被继承

public abstract class Pet

abstract抽象方法:

1.抽象方法使用abstract修饰 public abstract void

2.抽象方法没有方法体

3.抽象方法必须被重写

4.抽象方法必须在抽象类中,而抽象类中可以没有抽象方法

抽象类

public abstract class Animal { 
	public abstract void run();
}

抽象类的子类

public class Cat extends Animal {
    public void run (){
    	System.out.println("小猫在墙头走~~~");
    }
}

测试类

public class CatTest {
    public static void main(String[] args) { 
        // 创建子类对象
        Cat c = new Cat();
        // 调用run方法
        c.run();
    }
}

多态

在Java中,多态面向对象中的一个重要概念,它允许不同类型的对象对同一方法进行不同的实现。具体来说,多态性指的是通过父类的引用变量来引用子类的对象,从而实现对不同对象的统一操作。

在Java中,要实现多态性,就必须满足以下条件:

继承关系

存在继承关系的类之间才能够使用多态性。多态性通常通过一个父类用变量引用子类对象来实现。

方法重写

子类必须重写(Override)父类的方法。通过在子类中重新定义和实现父类的方法,可以根据子类的特点行为改变这个方法的行为,如猫和狗吃东西的独特行为。

父类引用指向子类对象

使用父类的引用变量来引用子类对象。这样可以实现对不同类型的对象的统一操作,而具体调用哪个子类的方法会在运行时多态决定

class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("狗发出汪汪声");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("猫发出喵喵声");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 父类引用指向子类对象
        Animal animal2 = new Cat(); // 父类引用指向子类对象

        animal1.sound(); // 输出:狗发出汪汪声
        animal2.sound(); // 输出:猫发出喵喵声
    }
}

向上转型和向下转型

向上转型(Upcasting)是指将一个子类的对象引用赋值给其父类类型的引用变量。这是在面向对象编程中的一种常见操作,用于实现多态性和灵活的对象处理。

在向上转型中,子类对象可以被视为父类对象,可以使用父类类型的引用变量来引用子类对象。这样做的好处是可以以统一的方式处理不同类型的对象,实现代码的灵活性和可扩展性。

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型
        animal.eat();  // 调用的是 Dog 类中的 eat() 方法
        // animal.bark();  // 错误:无法访问 Dog 类中独有的方法

        Dog dog = (Dog) animal;  // 向下转型
        dog.bark();  // 调用 Dog 类中的 bark() 方法
    }
}

向下转型(Downcasting)是指将一个父类类型的引用变量转换为其子类类型的引用变量。它与向上转型相反,需要进行显式的类型转换操作。

在某些情况下,当一个对象被向上转型后,它的具体类型信息会丢失,只保留了父类类型的信息。如果我们需要访问子类中特有的成员或调用子类重写的方法,就需要使用向下转型。

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // 向上转型

        // 使用向下转型之前,需要先检查对象是否实际上是子类的实例
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;  // 向下转型
            dog.bark();  // 调用 Dog 类中的 bark() 方法
        } else {
            System.out.println("animal is not an instance of Dog");
        }
    }
}
相关推荐
苹果醋325 分钟前
React源码02 - 基础知识 React API 一览
java·运维·spring boot·mysql·nginx
Hello.Reader44 分钟前
深入解析 Apache APISIX
java·apache
菠萝蚊鸭1 小时前
Dhatim FastExcel 读写 Excel 文件
java·excel·fastexcel
旭东怪1 小时前
EasyPoi 使用$fe:模板语法生成Word动态行
java·前端·word
007php0071 小时前
Go语言zero项目部署后启动失败问题分析与解决
java·服务器·网络·python·golang·php·ai编程
∝请叫*我简单先生1 小时前
java如何使用poi-tl在word模板里渲染多张图片
java·后端·poi-tl
ssr——ssss2 小时前
SSM-期末项目 - 基于SSM的宠物信息管理系统
java·ssm
一棵星2 小时前
Java模拟Mqtt客户端连接Mqtt Broker
java·开发语言
鲤籽鲲2 小时前
C# Random 随机数 全面解析
android·java·c#
zquwei2 小时前
SpringCloudGateway+Nacos注册与转发Netty+WebSocket
java·网络·分布式·后端·websocket·网络协议·spring