Java面向对象------方法的重载与重写

方法的重载

1. 方法的重载: 方法名一样，参数不同的，不同功能方法的集合

   1. 方法名相同，完全相同
   2. 参数不同，包含参数的个数和顺序不同
      1. 参数名不参与比较
   3. 方法体（算法）可以完全不同
   4. 设计重载的方法，往往是显示设计的优雅。

2. 实现重载：

   1. 声明相同的方法名
   2. 参数必须不同。如果参数相同就会出现编译错误！
   3. 方法体没有限制，返回值没有限制。
   4. 调用方法时候，根据方法名和参数列表 识别调用那个方法。
      1. 如果参数不同时候，Java会尝试自动类型转换匹配方法。
      2. 如果参数完全不兼容，则调用时候出现编译错误
   5. 方法名+参数类型列表 = 方法签名
   6. Java 中 println 方法是重载的方法：
      1. println(int) 将整数按照10进制进行转换输出
      2. println(double) 将浮点数按照10进制转换小数输出
      3. println(char) 将字符转换为字模进行输出
      4. println(char[]) 将字符数组转换为字符串输出
      5. …

         	System.out.println(65);// "65"
         	System.out.println((char)65);//A
         	System.out.println(new char[]{65,66,67}); //ABC
         	
         

   7. 重载方法调用案例：

      	public class Demo {
      		public static void main(String[] args) {
      			/*
      			 * 重载中参数不同：
      			 * 1. 参数个数不同
      			 * 2. 参数类型不同
      			 * 3. 参数顺序不同
      			 * 4. 或者 1 2 3 都不同
      			 * 
      			 * 注意：仅仅参数名不同，算作相同参数
      			 * 
      			 * 调用重载方法时候：
      			 * 1. Java 明确类型优先
      			 * 2. 如果类型不兼容，Java会采用“最近”
      			 * （代价最小）的原则转换数据，调用方法
      			 * 3. 如果不能进行转换调用，则报编译错误。
      			 */
      			Foo foo = new Foo();
      			//明确类型优先
      			int n = foo.add(4, 5); //add(int, int)
      			double d = foo.add(4.0, 5.0);//(double, double)
      			System.out.println(n+","+d);
      			//2 转换类型调用方法, “就近原则”
      			int k = foo.add('A', 'B');
      			 //(char, char)->(int, int)
      			System.out.println(k);
      			double d1=foo.add(5, 5f); 
      			//(int, float)->(int, double)
      			System.out.println(d1);
      			//...
      			//转换不能成功，就报编译错误
      			//foo.add(5, false);
      		}
      	}
      	
      

      			class Foo{
      				//不能写 仅仅参数名不同的方法
      				//public double add(double x, int y) {
      				//	return x+y;
      				//}
      				public double add(double a, int b) {
      					return a+b;
      				}
      				public double add(int a, double b) {
      					return a+b;
      				}
      				public int add(int a, int b, int c) {
      					return a+b+c;
      				}
      				public int add(int a, int b) {
      					return a+b;
      				}
      				public double add(double a, double b) {
      					return a+b;
      				}
      			}		
      

方法的重写

1. 方法的重写： 在子类中修改从父类继承的方法（行为）

2. 子类可以继承父类中声明的方法，如果此方法不能满足子类的需求，则可以在子类中利用“重写”语法进行修改。 改变父类中定义行为。

3. 如果子类的行为与父类的不同，就可以利用“重写”修改父类的行为。

4. 语法：子类定义一个与父类“一样”的方法。

   1. 方法名一样
   2. 参数一样
   3. 返回值，一般是一样的，可以是更小的子类型。
   4. 修饰词，一般是一样的，可以更加扩大
   5. 异常，一般是一样的，可以更加具体

5. 在重写方法后的子类对象上调用方法时候，执行子类重写后的方法逻辑。父类的方法被 “覆盖” 掉了

6. @Override 注解用于通知编译器，对后续一个方法进行 重写 语法检查——一般建议使用。

7. super. 在子类中代表父类型

   1. 当子类的属性或方法命名与父类冲突时候，可以利用super.引用父类中的属性方法。
   2. 在重写时候，子类与父类的方法相同，如果需要利用父类的逻辑。super.父类方法()。