疯狂java学习笔记之面向对象(六) - 构造器重载、方法重载和方法重写

一、方法重载(Overload):

　　Java允许同一个类中定义多个同名方法,只要形参不一样就可以,如果同一个类中包含了两个或两个以上方法名相同的方法,但形参列表不同,则被成为方法重载(两同一异).

　　同时这这里我们需要注意以下两点:

　　  A.方法重载与返回值类型没有任何关系;

　　  B.方法重载与是否有static修饰没有任何关系.

　　那我们如何才能确定到底调用的哪个方法呢?

　　  A.主调者:明确是谁在调用这个方法,是类还是对象

　　  B.方法名和形参:确定调用哪个方法(由方法名和形参共同决定)

例1：

 1 public class TestMethodLoad{
 2     public void test(){
 3         System.out.println("~~没有形参的test方法~~");
 4     }
 5     public void test(String name){
 6         System.out.println("~~带一个形参的test方法~~,参数名为:" + name);
 7     }
 8
 9     public static void main(String[] args){
10         TestMethodLoad t = new TestMethodLoad();
11         t.test();
12         t.test("哈喽");
13     }
14 }

例2：

 1 public class TestMethodLoad2{
 2     public void test(String name){
 3         System.out.println("带一个参数的方法,参数是:" + name);
 4     }
 5     public void test(String... msgs){
 6         for(String msg : msgs){
 7             System.out.println("带可变String类型参数的方法,参数是:" + msg);
 8         }
 9     }
10
11     public static void main(String[] args){
12         TestMethodLoad2 tl = new TestMethodLoad2();
13         tl.test("哈喽");
14         tl.test("123","jkl");
15
16     }
17 }

二、构造器重载：

　　构造器可以认为它是个特殊的方法:无需声明返回值类型,如果声明了返回值类型则变成普通方法;

　　构造器的作用:构造器并不是创建对象,而是初始化实例,严格来说对象是new出来的;

　　构造器重载:完全类似于方法重载 -- 两同(同一个类、方法名相同)-- 一异(形参列表不同)

 1 public class Monkey{
 2     private String name;
 3     private double weight;
 4     private int age;
 5
 6     //提供带两个参数的构造器
 7     public Monkey(String name , double weight){
 8         this.name = name;
 9         this.weight = weight;
10     }
11
12     //提供带三个参数的构造器,构造器的作用是用来初始化实例的
13     public Monkey(String name , double weight , int age){
14         this(name,weight);
15         this.age = age;
16     }
17
18     public void info(){
19         System.out.println("这是一只猴子,它的名字是:" + name +
20             ",体重是:" + weight + ",年龄是:" + age);
21     }
22
23     public static void main(String[] args){
24         Monkey m = new Monkey("小金刚",100);
25         m.info();
26         Monkey m2 = new Monkey("金刚",300,20);
27         m2.info();
28     }
29 }

三、方法重写(Override)/方法覆盖:

　　方法重写是用在子类与父类之间的,而方法重载是用于同一个类的,当子类从父类那里继承得到的方法,不能真正满足子类需求的时候,子类可以重写父类的方法。

　　1、方法重写规则:

　　两同:方法名相同、形参列表相同;

　　两小:子类重写方法的返回值类型必须比父类方法的返回值类型更小或相等;子类重写方法的声明抛出异常必须比父类方法的声明抛出异常更小或相等

　　一大:子类重写方法的访问权限必须比父类更大或相等。

　　2、@Override:强制要求子类必须重写方法标识符

　　作用:要不编译的时候则出错,防止重写父类方法出错;让编译器执行更严格的检查,要求被修饰的方法必须是重写父类的方法

1 public class Bird{
2     public void fly(){
3         System.out.println("这是一只在填空飞翔的鸟啊~~");
4     }
5 }

1 public class TuoNiao{
2     public void fly(){
3         System.out.println("鸵鸟太笨了,只能在地上跑了!");
4     }
5     public static void main(String[] args) {
6         TuoNiao tn = new TuoNiao();
7         tn.fly();//因为子类重写了fly方法,所以最终调用的是子类重写后的方法
8     }
9 }

注意:

 1 public class GoldMonkey extends Monkey{
 2     //子类会从父类那里获得所有Field与方法,不重写父类构造器的话默认会继承父类的空构造器,若父类没有空构造器则报错
 3     public GoldMonkey(String name , double weight , int age){
 4         this.name = name;
 5         this.weight = weight;
 6         this.age = age;
 7     }
 8
 9     public static void main(String[] args){
10         GoldMonkey gm = new GoldMonkey("小金",300,12);
11         //调用从父类那里继承得到的方法
12         gm.info();//若子类没有重写info方法,默认则继承父类的info方法
13     }
14
15     //当子类从父类那里继承得到的方法,不能真正满足子类需求的时候,子类可以重写父类的方法
16     //protected void info(){} //错误 子类重写方法必须比父类的访问权限更大或相等。
17
18     public void info(){
19         //extends是继承了父类的所有方法和属性,所以它有name、weight、age等属性
20         //但由于父类访问权限为private 所以不能访问，此时需要修改父类Field属性为Protected/默认
21         System.out.println("这是一只金丝猴,名字是:" + name + ",体重是:" + weight + ",年龄是:" + age);
22     }
23 }