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

川长思鸟来 2022-03-14 09:14 262阅读 0赞

## 方法的重载 ##

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.父类方法()。