方法重载

　　在一个类中，我们可以定义一系列方法，这些方法的方法名称相同，参数列表不同，这种语法称之为方法的【重载】。例如我们可以为Student类定义两个study方法； 　　Class Student { 　　　　public ststic void study(){ 　　　　　　System.out.println("study()"); 　　　　} 　　　　public static void study(int n){ 　　　　　　System.out.println("study(int)"); 　　　　} 　　} 　　上面这段代码中，在Student类中定义了两个study方法，一个没有参数，另一个带一个字符串参数。在程序运行期间，根据不同的参数，会调用不同的方法。例如： 　　public class TestStudent{ 　　　　public static void main(String[] args){ 　　　　　　Student stu = new Student(); 　　　　　　stu.study(); // 调用无参的study方法，打印study() 　　　　　　stu.study(10);// 调用有参数的study方法，打印study(int) 　　　　} 　　} 【需要注意的是，当程序被编译时，如果出现方法的重载，Java编译器会根据不同的实参类型

String s =“a”+“b”，编译器会进行常量折叠（因为两个都是编译期常量，编译期可知），即变成String s =“ab” 对于能够进行优化的（String s =“a”+变量等）用StringBuilder的append（）方法替代，最后调用toString（）方法（底层就是一个新的String（）） 来源： https://www.cnblogs.com/lujiahua/p/11408670.html

什么是多态 多态的概念呢比较简单，就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。 如果按照这个概念来定义的话，那么多态应该是一种运行期的状态。 为了实现运行期的多态，或者说是动态绑定，需要满足三个条件。 即有类继承或者接口实现、子类要重写父类的方法、父类的引用指向子类的对象。 public class Parent{ public void call(){ sout("im Parent"); } } public class Son extends Parent{// 1.有类继承或者接口实现 public void call(){// 2.子类要重写父类的方法 sout("im Son"); } } public class Daughter extends Parent{// 1.有类继承或者接口实现 public void call(){// 2.子类要重写父类的方法 sout("im Daughter"); } } public class Test{ public static void main(String[] args){ Parent p = new Son(); //3.父类的引用指向子类的对象 Parent p1 = new Daughter(); //3.父类的引用指向子类的对象 } }重载（静态多态） 就是函数或者方法有同样的名称

方法重载 ：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。 参数列表：数据类型个数不同，数据类型不同，数据类型顺序不同。 重载方法调用：JVM通过方法的参数列表，调用不同的方法。 #### 方法重载练习一：比较两个数据是否相等 比较两个数据是否相等。参数类型分别为两个`byte`类型，两个`short`类型，两个`int`类型，两个`long`类型，并在`main`方法中进行测试。 public class Method_Demo6 { public static void main(String[] args) { //创建 Count c = new Count(); //定义不同数据类型的变量 byte a = 10; byte b = 20; short c = 10; short d = 20; int e = 10; int f = 10; long g = 10; long h = 20; // 调用 System.out.println(c.compare(a, b)); System.out.println(c.compare(c, d)); System.out.println(c.compare(e, f)); System.out.println(c.compare(g, h)); } } class

9类和对象进一步 9.1构造函数 如果一个类中所有的成员都是公用的，则可以在定义对象时对数据成员进行初始化。 但是，如果数据成员是私有的，或者类中有private或protected的成员， 就不能用这种方法初始化。 class Time {public : //声明为公用成员 hour; minute; sec; }; Time t1={14,56,30}; //将t1初始化为14:56:30 构造函数的作用 构造函数的名字必须与类名同名，构造函数没有返回值，因此也不需要在定义构造函数时声明类型， 以便编译系统能识别它并把它作为构造函数处理。 在类内定义构造函数，也可以只在类内对构造函数进行声明而在类外定义构造函数。 构造函数不需用户调用，也不能被用户调用。 带参数的构造函数 构造函数首部的一般格式为构造函数名(类型 1 形参1，类型2 形参2， …) 定义对象的一般格式为 类名 对象名(实参1，实参2， …); #include <iostream> using namespace std; class Box {public : Box(int,int,int);//形参由定义对象时给出 int volume( ); private : int height; int width; int length; }; //声明带参数的构造函数//声明计算体积的函数 Box::Box

文章目录 3、重载与重写  3.1 重载与重写的概念  3.1.1 重载的概念  3.1.2 重写的概念  3.2 方法的重载  3.2.1 重载的要求  3.3 方法的重写  3.3.2 重写的要求  3.4 重载与重写的区别  3.4.1 目的不同  3.4.2 "绑定"时间时间不同 3、重载与重写  3.1 重载与重写的概念  3.1.1 重载的概念  **重载（Overload）**是让类以统一的方式处理不同类型数据的一种手段，实质表现就是多个具有不同的参数个数或者类型的同名函数（返回值类型可随意，不能以返回类型作为重载函数的区分标准）同时存在于同一个类中，是一个类中多态性的一种表现（调用方法时通过传递不同参数个数和参数类型来决定具体使用哪个方法的多态性）  3.1.2 重写的概念 ​  **重写（Override）**是父类与子类之间的多态性，实质是对父类的函数进行重新定义，如果在子类中定义某方法与其父类有相同的名称和参数则该方法被重写，不过子类函数的访问修饰权限不能小于父类的；若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法，如需父类中原有的方法则可使用 super 关键字。  3.2 方法的重载 ​   定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可 public void

在c++中运算符重载通过两种方式：1.友元函数的方式 2.成员函数的方式 五种运算符不可以重载 点运算符. 域名解析符：： 点星运算符.* 三目运算符：？ 求大小运算符sizeof 不能使用成员重载的运算符>> << 不能通过友元的方式重载的运算符 赋值运算符= 括号运算符（）下标运算符 [] 箭头运算符-> 双目运算符推荐使用友元 单目运算符 推荐使用成员 友元函数是单项传递的 A是B的友元类 在B中不申明 ，B不是A的友元类 A是B的友元类 B是C的友元类 A不一定是C的友元类 需要在C中申明 友元方法和成员方法的区别是 友元方法不能使用this调用成员变量而成员方法可以调用this 1 #pragma once 2 #include<iostream> 3 using namespace std; 4 class A 5 { 6 int data; 7 static int x; 8 int arr[10]; 9 public: 10 A(int data = 0);//构造函数，可缺省 11 A(const A&other);//调用拷贝构造 12 ~A(); 13 int getData(); 14 void setData(int data); 15 friend int addA(const A&a, const A&b);//在申明的时候使用友元在类外定义 16

重载运算符和重载函数 C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为 函数重载 和 运算符重载 。 ———— 类似于 python 的魔法方法 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。 当您调用一个 重载函数 或 重载运算符 时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为 重载决策 。 一、函数重载 在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。 实例： 同名函数 print() 被用于输出不同的数据类型 #include <iostream> using namespace std; class printData { public: void print(int i) { cout << "整数为: " << i << endl; } void print(double f) { cout << "浮点数为: " << f << endl; } void print(char c[]) { cout << "字符串为: " << c << endl; } }; int main(void) {

C++多态方式： （1）静态多态（重载，模板） 是在 编译的时候 ，就确定调用函数的类型。 （2）动态多态（覆盖，虚函数实现） 在 运行的时候 ，才确定调用的是哪个函数，动态绑定。运行基类指针指向派生类的对象，并调用派生类的函数。 虚函数实现原理：虚函数表和虚函数指针。 纯虚函数： virtual int fun() = 0; 多态基础介绍： =============================================================================================== 首先，什么是多态（Polymorphisn）？按字面的意思就是"多种形状"。我手头的书上没有找到一个多态的理论性的概念的描述。 暂且引用一下 Charlie Calverts的对多态的描述吧——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自"Delphi4 编程技术内幕"）。 简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual Function） 实现的。 好，接着是"虚函数"（或者是"虚方法"）。虚函数就是允许被其子类重新定义的成员函数。而子类重新定义父类虚函数的做法，称为

转自：https://blog.csdn.net/wintershii/article/details/80558739 1.重写(Override) 从字面上看，重写就是 重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。 例如： public class Father { public static void main(String[] args) { // TODO Auto-generated method stub Son s = new Son(); s.sayHello(); } public void sayHello() { System.out.println("Hello"); } } class Son extends Father{ @Override public void sayHello() { // TODO Auto-generated method stub System.out.println("hello by "); } } 重写 总结： 1.发生在父类与子类之间 2