10 面向对象三大特性之多态

最新推荐文章于 2022-03-03 23:26:51 发布
最新推荐文章于 2022-03-03 23:26:51 发布
阅读量149 收藏
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44962092/article/details/95077295
版权

面向对象三大特性之多态

多态的概念

概念：多态就是父类引用指向子类对象
满足： dog is  a  animal

现实生活中 一个事物是什么  取决于你认为他是什么

你认为是什么---  Animal a   引用
这个事物真实存在的是什么类型-----对象  

继承是多态的前提！！！！

多态的特点

编译时多态（还没有打开箱子 无法确定箱子中所放的数据类型）
特点：在编译时只能通过引用调用引用所对应类中声明的方法
编译时编译器无法确定引用中所放的数据是什么类型
案例：
public class Demo{
	public static void main(String[] args) {
		//java 是强类型语言   
		//Dog d = new Dog();
		Animal a = new Dog();
		a.eat();
		a.sleep();	

		//a.shout();//编译报错
	}
	
}

class  Animal{
	//吃
	public void eat(){
		System.out.println("动物吃");
		
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
	}
}

class Dog extends Animal{

	//加
	public void shout() {
		System.out.println("狗叫");
		
	}

}


验证编译器是否能确定引用中所放的数据类型
代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入一个整数：");
		int i = s.nextInt();
		Animal a;
		if (i%2==0) {
			a = new Dog();
		} else {
			a = new ShiKeLang();
		}	
	}
}

class  Animal{
	//吃
	public void eat(){
		System.out.println("动物吃");
		
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
		
	}
	
	
}


class Dog extends Animal{

	//加
	public void shout() {
		System.out.println("狗叫");
		
	}

	
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");
		
	}
	
	
}
运行时多态（打开箱子 能够确定数据类型了 ）
特点：当多态发生时，运行代码时调用的是子类覆盖父类后的方法的实现
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Animal a = new Dog();

		a.eat();
		a.sleep();
	}
}

class  Animal{
	//吃
	public void eat(){
		System.out.println("动物吃");
		
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
	}
}


class Dog extends Animal{
	//吃
	public void eat(){
		System.out.println("狗吃屎");
		
	}
	//睡
	public void sleep() {
		System.out.println("狗趴着睡");
	}
	//加
	public void shout() {
		System.out.println("狗汪汪的叫");
	}
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");	
	}
}

关于属性是否有多态

属性是不存在多态的
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Animal a = new Dog();

		System.out.println(a.name);	//动物
	}
}

class  Animal{
	String name = "动物";
	//吃
	public void eat(){
		System.out.println("动物吃");
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");	
	}
}


class Dog extends Animal{
	String name = "哈士奇";
	//吃
	public void eat(){
		System.out.println("狗吃屎");
	}
	//睡
	public void sleep() {
		System.out.println("狗趴着睡");	
	}
	//加
	public void shout() {
		System.out.println("狗汪汪的叫");
	}
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");
		
	}
	
	
}

引用之间的转换

向上转型
将子类对象的引用赋值给父类类型的引用
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Dog d = new Dog();

		Animal a = d;	
	}
}

class  Animal{
	String name = "动物";
	//吃
	public void eat(){
		System.out.println("动物吃");
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
	}	
}


class Dog extends Animal{
	String name = "哈士奇";
	//吃
	public void eat(){
		System.out.println("狗吃屎");
	}
	//睡
	public void sleep() {
		System.out.println("狗趴着睡");
	}
	//加
	public void shout() {
		System.out.println("狗汪汪的叫");
	}	
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");
	}
}
向下转型
将父类类型的引用赋值给子类类型的引用
意义：当我们需要用父类的引用去调用子类特有的方法时，需要将父类的引用类型向下转型为子类类型的引用，这时候需要强制转换，结果可能失败  会报类型转换异常
Exception in thread "main" java.lang.ClassCastException: ShiKeLang cannot be cast to Dog    at Demo.main(Demo.java:5)
从以上的案例说明：一个对象创建之后 其类型永远不可改变(java中对象类型不可变)

案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Animal a = new ShiKeLang();
		Dog d = (Dog)a;	

		d.shout();
		
	}
}

class  Animal{
	String name = "动物";
	//吃
	public void eat(){
		System.out.println("动物吃");
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
	}
}


class Dog extends Animal{
	String name = "哈士奇";
	//吃
	public void eat(){
		System.out.println("狗吃屎");
	}
	//睡
	public void sleep() {
		System.out.println("狗趴着睡");
	}
	//加
	public void shout() {
		System.out.println("狗汪汪的叫");
	}
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");
	}
}
当两个类之间没有继承关系 这两个类引用之间是否可以转换
当两个类之间没有继承关系时 引用类型之间是不可以转换的   即使强制转换 编译也不通过
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		ShiKeLang s = new ShiKeLang();

		Dog d = (Dog)s;
		
	}
}

class  Animal{
	String name = "动物";
	//吃
	public void eat(){
		System.out.println("动物吃");
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
		
	}
}


class Dog extends Animal{
	String name = "哈士奇";
	//吃
	public void eat(){
		System.out.println("狗吃屎");
	}
	//睡
	public void sleep() {
		System.out.println("狗趴着睡");
	}
	//加
	public void shout() {
		System.out.println("狗汪汪的叫");
	}
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");	
	}
}

instanceof(实例 属于)

作用：能够判断一个引用中所存放的数据类型
语法：
引用名  instanceof 类型

a instanceof  Dog

值是一个布尔类型
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Animal a = new Dog();
		if (a instanceof Dog) {
			Dog d = (Dog)a;
			d.shout();
		} else {
			a.eat();
			a.sleep();
		}
	}
}

class  Animal{
	String name = "动物";
	//吃
	public void eat(){
		System.out.println("动物吃");
	}
	//睡
	public void sleep() {
		System.out.println("动物睡");
		
	}
}


class Dog extends Animal{
	String name = "哈士奇";
	//吃
	public void eat(){
		System.out.println("狗吃屎");
	}
	//睡
	public void sleep() {
		System.out.println("狗趴着睡");
	}
	//加
	public void shout() {
		System.out.println("狗汪汪的叫");
	}
}

class ShiKeLang extends Animal{
	public void moveShi() {
		System.out.println("移动屎球");
	}
}


案例：
Animal a = new ShiKeLang();
System.out.println(a instanceof Dog );//false

ShiKeLang a = new ShiKeLang();
System.out.println(a instanceof Dog );//编译报错

在用instanceof判断之前首先编译器会先进行判断两个类之间是否存在继承关系

关于多态中的特点的口诀

编译看左边:编译时 只能调用引用所对应类中声明的方法
运行看右边：当多态发生时 调用方法执行的是子类覆盖父类后的方法的实现

Animal a  = new Dog();

多态的应用

多态用在数组中
定义一个动物类
	方法： eat()
每个子类都重写eat方法
狗类
猫类


案例：
public class Demo{
	public static void main(String[] args) {
		//分别创建每个子类的对象 调用吃的方法
		/*Dog d = new Dog();
		Cat c = new Cat();

		d.eat();
		c.eat();*/

		//数组将这些动物
		Animal[] zoo = {new Dog(),new Cat()};

		//遍历
		for(int i = 0;i<zoo.length;i++) {
			zoo[i].eat();
		} 		
	}
}
class Animal{
	//吃
	public void eat() {
		System.out.println("动物吃");
	}
}

class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

练习：
有一个动物类的数组 数组中有很多动物对象  统计数组中狗对象的个数
考点：
instanceof

升级：将所有的狗对象放到一个狗窝中（狗的数组）

public class Demo{
	public static void main(String[] args) {
		//分别创建每个子类的对象 调用吃的方法
		/*Dog d = new Dog();
		Cat c = new Cat();*/

		//数组将这些动物
		Animal[] zoo = {new Dog(),new Cat(),new Dog(),new Cat()};
		int sum = 0;
		for(int i = 0;i<zoo.length;i++) {
			//判断是否为狗
			if (zoo[i] instanceof Dog) {
				sum++;
			} 		
		} 

		System.out.println(sum);

		Dog[] d = new Dog[sum];
		int j = 0;
		for(int i = 0;i<zoo.length;i++) {
			if (zoo[i] instanceof Dog) {
				d[j] = (Dog)zoo[i];
				j++;
			} 
		} 		
	}
}


class Animal{
	//吃
	public void eat() {
		System.out.println("动物吃");
	}
}

class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}	
}

改进之后的案例：

import java.util.*;
public class Demo{
	public static void main(String[] args) {
		//分别创建每个子类的对象 调用吃的方法
		/*Dog d = new Dog();
		Cat c = new Cat();*/

		//数组将这些动物
		Animal[] zoo = {new Dog(),new Cat()};
		Dog[] d = new Dog[0];
		int j = 0;
		for(int i = 0;i<zoo.length;i++) {
			//判断是否为狗
			if (zoo[i] instanceof Dog) {
				d = Arrays.copyOf(d,d.length+1);
				d[j] = (Dog)zoo[i];
				j++;
			} 		
		} 
		System.out.println(d.length);	
	}
}
多态用在函数的参数上
案例： 多态可以使函数的功能更加通用  
import java.util.*;
public class Demo{
	public static void main(String[] args) {
	
		m(new Dog());
		m(new Cat());
		m(new Duck());
			
	}
	//给我传进一个动物  我会调用这个动物吃的方法 Animal a = new Dog()
	public static void m(Animal a) {
		a.eat();	
	}
}


class Animal{
	//吃
	public void eat() {
		System.out.println("动物吃");
	}	
}

class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头");
	}	
}

class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
多态用在函数的返回值上
马戏团中有好多动物  游客可以买票看不同的动物

10  ------  鱼
20 ------猴
30 ----羊
40-----狗

1000--- 老虎

参数：double d 
返回值类型：Animal    return new Dog();

案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		Animal a = sh
	}

	public static Animal showAnimal(double d) {
		if (d==10) {
			return new Fish();
		} else if (d==20) {
			return new Monkey();
		} else if (d==30) {
			return new Sheep();
		} else if (d==40) {
			return new Dog();
		} else if (d==1000) {
			return new Tiger();
		} else{
			return null;
		}	
	}	
}


class Animal{
	//吃
	public void eat() {
		System.out.println("动物吃");
	}	
}

class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

class Cat extends Animal{
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

class Monkey extends Animal{
	public void eat() {
		System.out.println("猴子吃桃");	
	}
}
class Tiger extends Animal{
	public void eat() {
		System.out.println("老虎吃人");		
	}
}

class Sheep extends Animal{
	public void eat() {
		System.out.println("羊吃草");
	}	
}
class Fish extends Animal{
	public void eat() {
		System.out.println("鱼吃虾米");	
	}
}

class Duck extends Animal{
	public void eat() {
		System.out.println("鸭子嘎嘎的吃");
	}
}
勋大大
关注
专栏目录
多态
qq_30973049的博客
08-02 204
多态 多态是继封装，继承后面向对象的第三大特性 多态是出现在继承或接口实现关系中 多态的定义 是指同一行为，具有多个不同表现形式。 多态前提 继承或者实现【二选一】 方法的重写【意义体现：不重写，无意义】 父类引用指向子类对象【格式体现】 体现格式 父类类型 变量名 = new 子类/实现类构造器； 变量名.方法名； 实现例子 定义父类： public class Animal { p...
面向对象三大特性之多态
zd1304859264的博客
11-19 384
  多态性在面向对象中是一个最重要的概念，在Java中主要有两种体现形式：方法的重载与覆写和对象的多态性。 方法重写   子类实现父类的同名方法，并且参数的类型和个数完全相同，这种情况称为覆写/重写/覆盖。   关于覆写的注意事项   1. 覆写和重载是两个不同的概念和意义；   2.普通方法是可以完成覆写的，但是被static修饰的静态方法无法被覆写；   3.覆写中子类的方法访问权限不能够低于...
Java中A instanceof B是什么意思？
weixin_30852419的博客
12-05 343
instanceof用来判断内存中实际对象A是不是B类型出现这种情况经常是需要强制转换的时候class Dog extends Animal譬如dog定义了自己的方法wangwangAnimal anAnimal = new Dog();此时不能直接调用anAnimal.wangwang方法但是可以if( anAnimal instanceof Dog){Dog dog = (Dog)anAnim...
16、java面向对象的三大特性（封装、继承、多态）、instanceof关键字
最秃不过程序员的博客
05-21 185
封装 封装：是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法， 要访问该类的代码和数据，必须通过严格的接口控制。 public class Person { //将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。 private String name; private int age; public int getAge(){ return age; } ​//对每个值属性提供对外的公共方
instanceof 用法及作用
浪子的专栏
08-09 3735
===〉instanceof用来判断内存中实际对象A是不是B类型 出现这种情况经常是需要强制转换的时候 class Dog extends Animal 譬如dog定义了自己的方法wangwang Animal anAnimal = new Dog(); 此时不能直接调用anAnimal.wangwang方法 但是可以 if( anAnimal instanceof Dog)
java中instanceof用法
weixin_30437337的博客
11-11 113
　　instanceof是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据 　　 java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它...
【Java】基础18：面向对象三大特性之多态
01-21
面向对象三大特性：封装、继承和多态。 今天学最后一个特性：多态。 什么叫多态呢？按照字面意思理解就是多种形态的意思。 还是举昨天的那个例子： 动物园里动物都得吃食物，兔子吃胡萝卜，猫吃鱼，狗吃肉。 同一...
Java 面向对象三大特性之多态
05-20
面向对象编程是Java的核心特性，其中封装、继承和多态是三大基石。在这个主题中，我们将专注于"多态"这一特性，它是Java编程灵活性和可扩展性的重要体现。 多态（Polymorphism）在希腊语中意为“多种形态”，在编程...
javascript面向对象三大特征之多态实例详解
12-13
本文实例讲述了javascript面向对象三大特征之多态。分享给大家供大家参考，具体如下： 多态 从某种意义上来说，多态是面向对象中重要的一部分，也是实施继承的主要目的。 一个实例可以拥有多个类型，它既可以是这种...
多态、instanceof运算符 详解 .
lwj_07的博客
03-03 2060
一、多态的基础语法 1、学习多态基础语法之前,我们需要普及两个概念： 第一个：向上转型 子 ---> 父 (自动类型转换) 第二个：向下转型 父 ---> 子 (强制类型转换) 注意： java中允许向上转型 也允许向下转型 (重点)：无论向上转型,还是向下转型,两...
三大特性之多态
weixin_40055163的博客
09-09 518
概念：父类引用可以存储不同的子类对象，子类对象不同呈现出不同的状态，固称为多态。 在程序中的体现：// 父类引用 子类对象 // 主观类型 客观类型 Animal a1 = new Dog(); Animal a2 = new Cat(); Animal a3 = new Fish(); Animal a4 = new Bird(); 在父类引用中存储子类对象。 1 多态的特点 1.1对象类型始终不变 演示的代码如下： class Animal{} class Pet extends Anima.
继承（instanceof ：比较运算符；不仅运行父类方法，也运行子类独有的方法）
紫梦涵的博客
07-08 164
/* */ class Animaldome{ public void eat(){} public void sleep(){} } class Cat extends Animaldome{ public void eat(){ System.out.println("我是猫咪，能吃饭"); } public void sleep(){ System.out.println("我是猫咪，我能睡觉");} public void play(){ System.
instanceof
weixin_34014277的博客
12-23 72
if(maps instanceof List){ System.out.println(“hhhh”); } instanceof 我们左边的内容是否在右边的这个内容的范围内 转载于:https://www.cnblogs.com/nangongyibin/p/10164829.html...
java多态类型转换异常，instanceof关键字处理异常
weixin_50773203的博客
10-13 778
异常： 向下转型时，如果父类引用中的子类对象类型和目标类型不匹配，则会发生类型转换异常。 instanceof关键字处理异常 1、向下转型前，应判断引用中的对象真实类型，保证类型转换的正确性。 2、语法:引用instanceof类型 //返回boolean类型结果 代码例子： public class InstanceofText { public static void main(String[] args) { Animal a = new Dog(); if (a in
聊一聊面向对象的三大特征
极客园地
11-15 881
学习Java语言程序设计也有一段时间了。现在我想对封装、继承和多态，在Java中面向对象的三大特征，总结一下我的理解，不妥当的地方望大家包涵。 　　封装。给我的感觉封装就是一个包装，一个代码是否健壮，与用不用封装有很大的关系，封装就像是包裹一个礼物，不仅让礼物看起来更加精美，而且还完善了内容。请看代码：
面向对象的三个基本特征
Tears of a poet
04-26 2622
面向对象的三个基本特征是：封装、继承、多态。 [img]http://www.cnitblog.com/images/cnitblog_com/lily/1972/o_OOBase.gif[/img] 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的...
Java多态深入解析：面向对象三大特性的关键
深入理解Java三大特性中的多态是面向对象编程中不可或缺的概念，它体现了对象的不同表现形式。在Java中，多态的核心在于利用父类引用引用子类对象，允许在运行时动态决定调用的具体方法。这一特性基于以下两个关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值