方法重载

重载，继承，重写和多态的区别： 继承是子类获得父类的成员，重写是继承后重新实现父类的方法。 重载是在一个类里一系列参数不同名字相同的方法。 多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。 网上看到一个有趣的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。 下面的例子包含了这四种实现： class Triangle extends Shape { public int getSides() { //重写 return 3; } } class Rectangle extends Shape { public int getSides(int i) { //重载 return i; } } public class Shape { public boolean isSharp(){ return true; } public int getSides(){ return 0 ; } public int getSides(Triangle tri){ return 3 ; } public int getSides(Rectangle rec){ return 4 ; } public static void main(String[] args) { Triangle tri = new Triangle(); //继承 System.out.println

多态（狭义上的）：同一个方法对不同的对象调用行为不同的现象。 重写：同一方法在不同类中的重新实现。 重载：不同的方法。 多态包括 重写 重载 来源： https://www.cnblogs.com/clemente/p/10768269.html

重用 重用是用于在对象的概念中，实现代码的重用性 在继承角度，在子类继承父类之后，重新使用父类属性方法即是代码的重用 在组合角度，在一个类中以另外一个类的对象作为数据属性，提高代码的重用性 重用的方式： 继承： 方式一：指名道姓的应用某一个类中的函数（无关继承，访问函数不存在自动传值） 例如：CollegePeople.__init__(self, name, age, sex) 方式二：使用内置方法super()，返回特殊对象访问属性（严格依赖mro列表，存在自动传值） 例如：super().__init__( name, age, sex) 组合：通过为某一个对象添加属性的方式，间接将两个类进行关联，减少类与类代码冗余 class Foo: xxx = 222 class Bar: yyy = 111 obj = Foo() b = Bar（） obj.attr = Bar() obj.a = b obj.xxxx #调用Foo内属性 obj.attr.yyyy #调用Bar内属性 重写 重写用于继承概念下，子类继承父类需要同名的不同函数，即可修改重写同名方法。 例如： class Parent: # 定义父类 def myMethod(self): print '调用父类方法' class Child(Parent): # 定义子类 def myMethod(self):

重载 C#中同一个类不可以有两个相同的方法（方法名、参数类型、参数个数和参数位置都 相同）。但可以有方法名相同，参数不同（参数类型、参数个数和参数位置不相同）的方法。这 种相同的方法名，参数不同的方法称为重载。 　　决定方法是否构成重载有以下几个条件： 　　◆ 在同一个类中； 　　◆ 方法名相同； 　　◆ 参数列表不同。 例如下面的代码： public void Show() //(1) { Console.WriteLine("Nothing"); } public void Show(int number) //(2) { Console.WriteLine(number); } /* public int Show(int number) //(3) { Console.WriteLine(number); return number % 5; } */ 对 于上面的代码，(1)没有参数，（2）使用了一个int类型的参数，(1)和(2)之间就构成了重载。(2)与(3)相比仅仅返回值不同，虽然重载不关心 返回值的不同，但是在C#中不允许存在方法名和参数列表相同、返回值不同的方法，所以(2)和（3）不能同时存在于代码中，(3)如果不注释掉上面的代码 是没有办法通过编译的。 重写 通过为声明的方法提供新的实现，派生类可以重写基类的方法。并且基类中的这个方法必须标记为虚方法

STL中由三类适配器，它们分别是： 1.容器适配器(stack、queue) 2.迭代器适配器(insert_iterator、reverse_iterator、iostream_iterator) 3.函数适配器(bind1st等等) 容器适配器 关于容器适配器我们已经在前面的http://www.cnblogs.com/runnyu/p/6003821.html讲过了。 迭代器适配器 1.insert iterator 当我们这样使用copy算法的时候： 1 vector<int> ins = { 1, 3, 5, 7}; 2 vector<int> coll; // coll为空 3 copy(ins.begin(), ins.end(), coll.begin()); View Code 毫无疑问会出现错误，因为copy算法中调用的是iterator的operator*跟operator=，用的是赋值操作，而要进行赋值的iterator并不合法。 insert iterator可以解决这个问题，其实它的实现很简单。 下面是back_inserter的用法跟实现，它的实现主要是重载了operator*跟operator=方法，然后提供了一个接口函数。 1 // 以容器为参数 将元素copy到coll的末尾 2 copy(ins.begin(), ins.end(), back

重载overload 重写override 实现编译时的多态 实现在运行时的多态 发生在一个类中 发生在父类和子类之间 方法名相同，参数列表不同（参数类型不同、参数个数不同或者二者都不同），对返回值没有要求 方法名相同，参数列表相同，返回值相同，方法体不同 重写具体要求 里氏代换原则： 重写要求子类被重写方法与父类被重写方法有相同的返回类型 比父类被重写方法更好访问 不能比父类被重写方法声明更多的异常 也就是两小一大： 方法名相同，参数类型相同 子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。 来源： CSDN 作者： qq_39548074 链接： https://blog.csdn.net/qq_39548074/article/details/104147906

重写方法的规则如下： 1. 参数列表：必须与被重写方法的参数列表完全匹配。 2. 返回类型：必须与超类中被重写的方法中声明的返回类型或子类型完全相同 3. 访问级别：一定不能比被重写方法强，可以比被重写方法的弱。 4. 非检查异常：重写方法可以抛出任何非检查的异常，无论被重写方法是否声明了该异常。 5. 检查异常：重写方法一定不能抛出新的检查异常，或比被重写方法声明的检查异常更广的检查异常 6. 不能重写标志为final,static的方法 重载方法的规则： 1. 参数列表：被重载的方法必须改变参数列表。 2. 返回类型：可以改变返回类型。 3. 修饰符：可以改变修饰符 4. 异常：可以声明新的或者更广泛的异常。 class Animal { public void eat(){ } } 以下列出对于Animal的eat方法各种重写重载实例，根据以上列出的规则，判断其是否合法（以下的方法都属于Animal的子类Horse的方法）： 1. private void eat(){} 不能通过编译，非法重写，访问修饰符限制性变强；不属于重载，因为参数列表没有发生改变 2. public void eat() throw RuntimeException{} 能通过编译，属于重写，重写方法可以抛出任何非检查异常。 3. public void eat() throw IOException

重写的规则： 参数列表必须完全与被重写方法的相同； 返回类型必须完全与被重写方法的返回类型相同； 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。 父类的成员方法只能被它的子类重写。 声明为final的方法不能被重写。 声明为static的方法不能被重写，但是能够被再次声明。 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。 构造方法不能被重写，被重写的前提是被继承，而构造方法根本就不能被继承，所以谈不上被重写。 如果不能继承一个方法，则不能重写这个方法。 重载的规则： 方法名相同，参数列表不同（不同的参数类型或者参数顺序或者参数个数）。至于方法的其他部分，如方法返回值类型和修饰符，与方法重载没有任何关系。最好加上@Overload注解。 来源： https://www.cnblogs.com/pomodoro/p/9585807.html

重写(Override)：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参 都不能改变。 即外壳不变，核心重写！ 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。 以上的编译时不被通过的，因为在animal中并没有定义bark方法，所以dog的对象里面的bark方法并不能被animal内省的b运行，算不上重写 参数列表必须完全与被重写方法的相同； 返回类型必须完全与被重写方法的返回类型相同； 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。 父类的成员方法只能被它的子类重写。 声明为final的方法不能被重写。 声明为static的方法不能被重写，但是能够被再次声明。 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。 重写的方法能够抛出任何非强制异常

这三个概念都是与Java中的多态有关系的。如果单是区别重载与覆盖这两个概念是比较容易的，但是隐藏这一概念却使问题变得有点复杂了， 下面说说它们的区别吧。 重载是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。 覆盖（也叫重写）是指在派生类中重新对基类中的虚函数（注意是虚函数）重新实现。即函数名和参数都一样，只是函数的实现体不一样。 隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了。隐藏与另外两个概念表面上看来很像，很难区分，其实他们的关键区别就是在 多态的实现上。 　　 什么叫多态？简单地说就是一个接口，多种实现吧。 覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数！ 　　 重载(overload): 　　必须在一个域中,函数名称相同但是函数参数不同,重载的作用就是同一个函数有不同的行为,因此不是在一个域中的函数是无法构成重载的,这个 是重载的重要特征 　　必须在一个域中，而继承明显是在两个类中 相同的函数名的函数，在基类和派生类中的关系只能是覆盖或者隐藏。 隐藏(hide): 指的是派生类的成员函数隐藏了基类函数的成员函数.隐藏一词可以这么理解:在调用一个类的成员函数的时候,编译器会沿着类的继承链逐级的向上 查找函数的定义,如果找到了那么就停止查找了,所以如果一个派生类和一个基类都有同一个同名