写点什么

腾讯 T6 大牛体系化带你学习 Java 面向对象,网友:这详解,太清晰了

发布于: 2021 年 05 月 11 日
腾讯T6大牛体系化带你学习Java面向对象,网友:这详解,太清晰了

上一篇是分享的是《Spring Security》,这篇给大家分享《JAVA 面向对象之多态 》。

接下来开始进行分享:

多态

1. 概念

多态是面向对象程序设计(OOP)的一个重要特征,指同一个实体同时具有多种形式,即同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态。

可以把不同的子类对象都当作父类来看,进而屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,统一调用标准。

比如,你的女朋友让你买点水果回来,不管买回来的是苹果还是西瓜,只要是水果就行,这个就是生活中多态的体现

再比如,小猫、小狗、小猪我们可以把他们都归纳成小动物,但是每种小动物爱吃的东西不一样,具体的小动物有具体的食物,如下代码所示:

class Animal{//1.定义父类Animal	....eat(){syso("吃啥都行")}}class Cat extends Animal{//2.1定义子类Cat	....eat(){syso("吃小鱼干")}}class Dog extends Animal{//2.2定义子类Dog	....eat(){syso("吃肉骨头")}}class Pig extends Animal{//2.3定义子类Pig	....eat(){syso("吃菜叶子")}}main(){	//3.创建子类对象	Cat c = new Cat();//小猫是小猫	Dog d = new Dog();//小狗是小狗	Pig p = new Pig();//小猪是小猪	//4.创建多态对象(父类引用指向子类对象/编译看左边,运行看右边)	Animal a1 = new Cat();//小猫是小动物	Animal a2 = new Dog();//小狗是小动物	Animal a3 = new Pig();//小猪是小动物}
复制代码

2 . 特点

多态的前提 1:是继承

多态的前提 2:要有方法的重写

父类引用指向子类对象,如:Animal a = new Cat();

多态中,编译看左边,运行看右边

3. 练习:多态入门案例

创建包: cn.tedu.oop

创建类: TestDemo.java

package cn.tedu.oop;/**本类用于测试多态*/public class TestDemo{	public static void main(String[] args) {		//5.创建父类对象进行测试\		Animal a = new Animal();		a.eat();//小动物Animal吃啥都行~~~		//a.jump();//父类无法使用子类的特有方法		//6.创建子类对象进行测试		Cat c = new Cat();		c.eat();//小猫Cat爱吃小鱼干!!!--调用的是重写以后的功能		c.jump();		//8.创建多态对象进行测试		/**口诀1:父类引用 指向子类对象*/		/**口诀2:编译(保存)看左边,运行(测试)看右边*/		Animal a2 = new Cat();		Animal a3 = new Dog();		a2.eat();//eat()使用的是父类的声明,但使用的是子类的实现方式		a3.eat();		/**多态的出现是为了统一调用标准,向父类看齐		 * 父类提供的功能才能用,子类特有的功能用不了*/	}}//1.创建父类class Animal{	//3.创建父类中的普通方法eat()	public void eat() {		System.out.println("小动物Animal吃啥都行~~~");	}}//2.创建子类class Cat extends Animal{	//4.重写父类中的方法--对父类中的代码功能修改	//重写:方法签名保持一致(返回值类型 方法名(参数列表) ) 	// & 权限修饰符 >= 父类权限修饰符	public void eat() {		System.out.println("小猫Cat爱吃小鱼干!!!");	}		//7.定义了子类特有的方法	public void jump() {		System.out.println("小猫Cat跳的老高啦");	}}class Dog extends Animal{	public void eat() {		System.out.println("小狗爱吃肉骨头!!!");	}}
复制代码

4. 多态的好处

多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法

提高了程序的可扩展性和可维护性

5. 多态的使用

成员变量: 使用的是父类的

成员方法: 由于存在重写现象,所以使用的是子类的

静态成员: 随着类的加载而加载,谁调用就返回谁的

6. 练习:多态成员使用测试

创建包: cn.tedu.oop

创建类: TestDemo2.java

package cn.tedu.oopstatic;/**本类用于多态中的元素测试*/public class TestDemo2 {	public static void main(String[] args) {		//7.创建子类对象进行测试		Dog2 d = new Dog2();		System.out.println(d.sum);//20		d.eat();//小狗要吃肉骨头		d.play();//小狗爱打滚儿~~~				//10.创建多态对象进行测试		/**口诀1:父类引用指向子类对象*/		/**口诀2:编译(保存)看左边,运行(测试)看右边*/		Animal2 a = new Dog2();		/**2.多态中,成员变量使用的都是父类的*/		System.out.println(a.sum);//10		/**3.多态中,成员方法使用的是父类的声明,子类的实现*/		a.eat();		/**4.多态中,如果父子类都有静态方法,使用的是父类的*/		a.play();//玩啥都行	}}//1.创建父类class Animal2{	//2.创建成员变量	int sum = 10;	//3.创建成员方法	public void eat() {		System.out.println("吃啥都行");	}	//8.父类中定义静态方法play()	public static void play() {		System.out.println("玩啥都行");	}}/**1.多态的前提:继承+重写*///4.定义子类Dog2class Dog2 extends Animal2{	//5.定义子类的成员变量	int sum = 20;	//6.重写父类的eat()	/**@Override 这个注解加在方法上,表示这是一个重写的方法*/	@Override //注解--标签	public void eat() {		System.out.println("小狗要吃肉骨头");	}		//9.定义子类的静态方法play()	//@Override --不是重写,不能加这个注解	public static void play() {		System.out.println("小狗爱打滚儿~~~");	}}	/**注意!!!静态资源属于类,不存在重写现象,只是两个类中有同样声明的方法而已,不属于重写*/
复制代码

7 拓展

7.1 设计汽车综合案例

创建包: cn.tedu.oopexec

创建类: DesignCar.java

package cn.tedu.oopexec;/**本类用于完成OOP汽车设计综合案例*//** * 1.分析事物,得出它的属性和功能 * 2.提取类中的共同点,向上抽取,形成父类Car * 3.子类继承父类后,就拥有的父类的功能 * 4.如果对父类的功能不满意,可以重写 * 5.可以封装某些类的属性,如果封装了,就要提供对应的get()/set() */public class DesignCar {	//3.创建入口函数main	public static void main(String[] args) {		//4.创建父类对象进行测试		Car c = new Car();		System.out.println(c.getColor());//通过get方法查看封装后的color值		c.start();		c.stop();				//5.创建宝马类对象进行测试		BMW b = new BMW();		System.out.println(b.color);		System.out.println("*********");		b.start();		b.stop();				//6.创建保时捷类对象进行测试		BSJ j = new BSJ();		System.out.println(j.color);		j.start();		j.stop();	}}//0.创建一个汽车类class Car{	//0.1定义Car类的属性	//0.3通过private对Car类的属性进行封装	private String brand;//品牌	private String color;//颜色	//0.4属性封装后,对外提供公共的get()与set()便于外界对属性进行操作	//右键-->Source-->Generate Getters and Setters -->Select All -->Generate	public String getBrand() {		return brand;	}	public void setBrand(String brand) {		this.brand = brand;	}	public String getColor() {		return color;	}	public void setColor(String color) {		this.color = color;	}	//0.2定义Car类的启动与停止方法	public void start() {		System.out.println("我的车车启动啦~~~");	}	public void stop() {		System.out.println("哎呀呀,我的车车熄火了~");	}}//1.创建一个宝马类并且继承Car类class BMW extends Car{	String color = "五彩斑斓的黑";	@Override	public void start() {		super.start();		System.out.println("宝马启动加速度~~~UPUP");	}}//2.创建一个保时捷并且继承Car类class BSJ extends Car{	String color = "黑不溜秋的白";		@Override	public void stop() {		System.out.println("保时捷想停得稳当些~");	}}
复制代码

7.2 静态变量和实例变量的区别

在语法定义上的区别:静态变量前要加 static 关键字,而实例变量前则不加。

在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。

7.3 向上转型和向下转型

在 JAVA 中,继承是一个重要的特征,通过 extends 关键字,子类可以复用父类的功能,如果父类不能满足当前子类的需求,则子类可以重写父类中的方法来加以扩展。

在应用中就存在着两种转型方式,分别是:向上转型和向下转型。

比如:父类 Parent,子类 Child

向上转型:父类的引用指向子类对象 Parent p=new Child();

说明:向上转型时,子类对象当成父类对象,只能调用父类的功能,如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。

向下转型(较少):子类的引用的指向子类对象,过程中必须要采取到强制转型。

Parent p = new Child();//向上转型,此时,p 是 Parent 类型

Child c = (Child)p;//此时,把 Parent 类型的 p 转成小类型 Child

//其实,相当于创建了一个子类对象一样,可以用父类的,也可以用自己的

说明:向下转型时,是为了方便使用子类的特殊方法,也就是说当子类方法做了功能拓展,就可以直接使用子类功能。

  • 以上就是《JAVA 面向对象之多态》的分享。

  • 也欢迎大家交流探讨,该文章若有不正确的地方,希望大家多多包涵。

  • 你们的支持就是我最大的动力,如果对大家有帮忙给个赞哦~~~

用户头像

还未添加个人签名 2021.04.26 加入

还未添加个人简介

评论

发布
暂无评论
腾讯T6大牛体系化带你学习Java面向对象,网友:这详解,太清晰了