java中重载和覆盖的含义，特点，区别

重载：方法名相同，但参数不同的多个同名函数
　　注意：1.参数不同的意思是参数类型、参数个数、参数顺序至少有一个不同
　　　　　2.返回值和异常以及访问修饰符，不能作为重载的条件(因为对于匿名调用，会出现歧义，eg:void a ()和int a() ，如果调用a()，出现歧义)
　　　　　3.main方法也是可以被重载的
覆盖：子类重写父类的方法，要求方法名和参数类型完全一样(参数不能是子类)，返回值和异常比父类小或者相同(即为父类的子类)，访问修饰符比父类大或者相同

重载和覆盖的联系：都是作用在方法上。区别就是覆盖的是继承类中的方法，而重载是不需要继承关系的----我是初学者，不对的地方，不要介意

重载：在同一个类中修饰符、返回值类型和方法名相同，但他们的参数个数或者参数类型或者参数顺序不同。
覆盖：子类复写父类或者接口的方法，复写父类方法的可不定义该方法，子类直接调用父类方法，也可重新定义该方法，这时运行时调用子类方法；复写接口方法时，必须重新定义，因为接口中的方法是抽象的。

在我csdn博客上有，http://blog.csdn.net/baidu_26654149/article/details/44461099。在这里再贴下。
Overload和Override的区别？
答：Overload是重载，Override是重写(也称覆盖)。都是类的多态性的体现。
        共同点：方法名称都相同。
        不同点：1.Overload是发生在同一个类中，Override是发生在子类和父类之间；
                2.Overload要求参数列表不同，而Override要求参数列表完全相同；
                3.Overload对于方法前面的修饰符没有限制，而Override则对这些修饰符的使用有限制（参见下边的“两小一大原则”）；
                4.Overload时编译器在编译期间就可以确定调用那一个方法，而Override则有可能在运行期间才能确定。

        Override(重写)注意点：要遵守“两小一大”原则。
        “两小”指：1.子类方法返回值类型应小于或等于父类方法返回值类型；
                          2.子类方法声明抛出的异常应小于或等于父类方法声明抛出的异常；
        “一大”指：子类方法的访问权限应大于或等于父类访问权限。重写方法和被重写方法要么都是                          类方法要么都是实例方法，切忌一个类方法一个实例方法。
        特别指出：被private修饰的方法是不能被重写的。

        语言的表达总是那么的不能一目了然，上几个最简单的代码说明吧：
//        重载Overload
        class OverLoad
        {
                public static void main (String [] args)
                {
                        // 无参数方法
                        show();
                        // 一个参数的方法
                        show("我要重载");
                        // 两个参数的方法
                        show(12,"我还要重载");
                }

                public static void show()
                {
                        System.out.println("后面两个要重载我");
                }
                public static void show(String a)
                {
                        System.out.println(a);
                }
                public static void show(int a , String s)
                {
                        System.out.println(a+"..."+s);
                }
        }
//        运行结果：
//                后面两个要重载我
//                我要重载
//                12...我还要重载
//--------------------------------------------
//        重写Override
        class OverRide
        {
                public static void main (String [] args)
                {
                        SuperClass s = new SubClass();
                        //静态方法被隐藏，父类仍可调用。
                        s.name();
                        //调用的是父类方法，因为父类和子类的say方法的参数列表不一致，故不能被覆盖
                        s.say();
                        // 下面一行出错
                        // s.say(20);
                        // 实例方法被覆盖，调用的是子类方法
                        s.work();
                }
               
        }
        class SuperClass
        {
                static void name()
                {
                        System.out.println("superfather") ;
                }
                public void say()
                {
                        System.out.println("父类有话说");
                }
               
                public void work()
                {
                        System.out.println("父类在工作");
                }
        }
        class SubClass extends SuperClass
        {
                static void name()
                {
                        System.out.println("subson") ;
                }
                public void say(int a)
                {
                        System.out.println("子类说的是："+a);
                }
                public void work()
                {
                        System.out.println("子类在工作");
                }
               
        }
//        运行结果：
                superfather
                父类有话说
                子类在工作