第十四章_重载、对象的类型转换与递归

最新推荐文章于 2024-06-18 22:30:11 发布

Y C C Y

最新推荐文章于 2024-06-18 22:30:11 发布

阅读量794

点赞数 12

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/cywhy_s/article/details/137781562

版权

JavaSE 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

第十四章重载、对象的类型转换与递归

提纲

14.1 方法的重载
- 14.1.1 什么是方法重载
- 14.1.2 方法重载的特点
- 14.1.3 重载中参数不同的几种形式
14.2 对象的类型转换
- 14.2.1 什么是对象类型转换
- 14.2.2 向上转型
- 14.2.3 向下转型
14.3 重载与重写的区别
14.4 递归
14.5 作业

14.1 方法的重载

14.1.1什么是方法重载：
- Java允许同一个类里定义多个同名方法，只要形参列表不同就行。如果同一个类中包含了两个或两个以上方法的方法名相同，但形参列表不同，则被称为方法重载。
- 方法重载是让类以统一的方式处理不同类型数据的一种手段。
14.1.2 方法重载的特点
1. 方法名相同
2. 参数列表不同
3. 与返回值无关
4. 不能将功能不同的方法进行重载
5. 与访问权限无关

14.1.3 重载中参数不同的几种形式

参数类型不同

 //定义一个计算总和的方法，参数为整数a和整数b
 public int sum(int a,int b){
 	return a+b;
 }
 //定义一个参数为整数a和浮点型b
 public int sum(int a,double b){
 	return a+b;
 }

参数数量不同

 //定义一个计算总和的方法，参数为整数a和整数b
 public int sum(int a,int b){
 	return a+b;
 }
 //定义一个参数为整数a、整数b和整数c
 public int sum(int a,int b,int c){
 	return a+b+c;
 }

参数类型顺序不同

 //定义一个计算总和的方法，参数为单精度浮点型a和双精度浮点型b
 public double sum(float a,double b){
 	return a+b;
 }
 //将参数顺序转换
 public double sum(double a, float b){
 	return a+b;
 }
 //注意：一定要参数类型不同，如果类型相同，变量名不同，转换顺序是没有意义的。
 比如这两个方法是不能重载的：
 public int sum(int a,int b){
 	return a+b;
 }
 public int sum(int b,int a){
 	return a+b;
 }

14.1.4 重载时需要注意事项

方法名相同的方法才叫重载

 //这样定义是两个方法，不属于重载
 public int sum1(int a,int b){
 	return a+b;
 }
 public int sum2(int a,int b){
 	return a+b;
 }

无论是否有返回值，不影响方法的重载

 //这样定义的两个方法是错误的，这是两个相同的方法，Java中不允许两个相同的方法存在
 public int sum(int a,int b){
 	return a+b;
 }
 public void sum(int a,int b){
 	int c = a+ b;
 }

不能将不同功能的方法进行重载

 //这两个方法不存在重载，这是两个方法
 //计算总和的方法
 public int sum(int a,int b){
 	return a+b;
 }
 //计算平均值的方法
 public int avg(int a,int b){
 	return (a+b)/2;
 }

14.2 对象的类型转换

14.2.1 什么是对象类型转换：类似于基本数据类型之间的类型转换。存在继承关系的父类对象和子类对象之间也可以在一定条件之下相互转换。

14.2.2 向上转型（也可称为：父类的引用指向子类的对象）

  //汽车类
  	public class Car {
  		//开车的方法
  		public void drive(){
  			System.out.println("开汽车");
  		}
  	}
  	//本田车类属于汽车类
  	public class Honda extends Car{
  		@Override//Override覆盖、重写的意思
  		public void drive() {
  			//super.drive();//调用父类的开车方法
  			System.out.println("开本田牌汽车");
  		}
  	}
  	//宝马车类属于汽车类
  	public class BMW extends Car{
  		@Override
  		public void drive() {
  			System.out.println("开宝马牌汽车");
  		}
  	}
  	//保时捷车类属于汽车类
  	public class Porsche extends Car{
  		@Override
  		public void drive() {
  			System.out.println("开保时捷牌汽车");
  		}
  	}
  	//不管什么车子都必须由人来开，所以定义一个人类，并且定义一个开车的方法
  	public class Person {
  		//定义开车方法并不知道开的是什么车，所以定义他们所有车的父类
  		public void drive(Car car){
  			car.drive();
  		}
  	}
  	//定义一个测试类
  	public class Test {
  		public static void main(String[] args) {
  			Person person = new Person();
  			//直接传入子类对象，得到对应的结果
  			person.drive(new BMW());
  			person.drive(new Honda());
  		}
  	}
  //在上面的例子中
  //在BMW宝马车类中单独加入如下属性和方法
  double price = 200000;
  public void start(){
  	System.out.println("宝马车启动了");
  }
  public class Test {
  	public static void main(String[] args) {
  		//其中：new BMW()是创建了一个宝马车对象，然后用汽车类Car来接收，即Car BMW = 是Car对象的引用
  		//因为Car比BMW要大，即宝马车是属于汽车的，所以直接就可以转型
  		Car BMW = new BMW();
  		//这是错误的，因为这个引用是父类的，所以无法调用子类中的属性和方法
  		//BMW.price;
  		//BMW.start();
  		Car honda = new Honda();
  		honda.drive();
  	}
  }
  //执行结果
  开宝马牌汽车
  开本田牌汽车

14.2.3 向下转型

  //如果要调用子类中具体的方法就要将一个汽车类转换成其具体的子类，这种转换叫做向下转型
  public class Test {
  	public static void main(String[] args) {
  		Car car = new BMW();
  		BMW BMW = (BMW) car;
  		BMW.drive();
  		//向下转换为具体的子类之后才可以调用子类中的方法
  		System.out.println(BMW.price);
  		BMW.start();
  	}
  }

14.3 重载与重写的区别

 区别点				重载				重写
参数列表			  必须修改		  一定不能修改
返回类型			  可以修改		  一定不能修改
访问权限			  可以修改		  一定不能做更严格的限制（可以降低限制）

14.4 递归

什么是递归：一个方法体内调用它自身，这样的方法我们称之为方法递归。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。所以使用递归的计算必须是有规律的，有出口的。

例：求10的阶乘10!。提示：3!=3*2*1，0!=1,1!=1。

 public class Recursive {
 	//计算n的阶乘
 	public int factorial(int n){
 		if (n == 1 || n == 0) {
 			return 1;
 		}else {
 			return n*factorial(n-1);
 		}
 	}
 }

14.5 作业

写一个数学类，类中有以下几个方法：
1. public int add(int a,int b); //类型不同的重载
2. public double add(double a,double b);
3. public String add(String a,int b); //顺序不同的重载
4. public String add(int a,String b);
5. public int max(int a,int b,int c);//个数不同的重载
6. public int max(int a,int b)
榨汁机类：
1. 定义一个苹果类:Apple,内有私有的字段:name,color,weiDao。
2. 定义一个构造函数:为三个字段赋初始值。
3. 为三个字段分别添加get、set方法。
4. 定义一个榨汁机类:ZhaFruit。
5. 为ZhaFruit类添加一个榨水果汁方法:public String getFruitZhi(Apple a),
  返回:“一杯XX(颜色)的XX(水果名)汁,味道XXX”。
6. 再定义一个香蕉类：Banana,内有私有的字段:name,color,weiDao。
7. 定义一个构造函数:为三个字段赋初始值。
8. 为三个字段分别添加get方法。
9. 为ZhaFurit类添加一个重载方法public String getFruitZhi(Apple a,Banana b),
  返回：“一杯黄绿(颜色)的香蕉苹果(水果名)汁,味道酸酸的甜甜的”。
10. 为ZhaFurit类添加一个重载方法public String getFruitZhi(Apple a,int num),
  返回：“num杯绿(颜色)的苹果(水果名)汁,味道酸酸的”。
创建一个狗类:Dog。
1. 为Dog添加yao(咬)方法,实现狗咬的功能。
2. 如果是yao(),什么都不传，则是"汪汪叫"。
3. 如果是yao(String str),则是"咬骨头，好香啊"。
4. 如果是yao(Person p),传入的是人类，如果人的性别为男，则"扑上去撕咬"，如果人的性别是女，则"跑过去舔两口"(还需定义Person类，起码有sex属性)。

Y C C Y

关注

12
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
第十四章_重载、对象的类型转换与递归

什么是递归：一个方法体内调用它自身，这样的方法我们称之为方法递归。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。所以使用递归的计算必须是有规律的，有出口的。14.2.1 什么是对象类型转换：类似于基本数据类型之间的类型转换。存在继承关系的父类对象和子类对象之间也可以在一定条件之下相互转换。例：求10的阶乘10!14.2.2 向上转型（也可称为：父类的引用指向子类的对象）无论是否有返回值，不影响方法的重载。不能将不同功能的方法进行重载。方法名相同的方法才叫重载。
复制链接

扫一扫