2020-04-13
Java面向对象中：方法重载和方法重写 、 this关键字和super关键字
方法重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型或者参数顺序不能完全相同；重载是一个类中多态性的一种表现
总结：
1.同一个类中
2.方法名相同
3.参数列表不同，即参数的数量 或 参数类型 或 参数顺序 不能完全相同
4.对其他没有要求,（例如：对返回值类型没有要求一致）
package com.zzm.trydemo; /* 方法重载： * 1.同一个类中 * 2.方法名相同 * 3.参数列表不同，即参数的数量 或 参数类型 或 参数顺序 不能完全相同 * * */ public class Test1_Overload { public static void main(String[] args) { student(); student("小明",5); student(18,"小红"); } public static void student(){ System.out.println("我是一个学生"); } public static void student(String name,int age){ System.out.println("我是一个学生，我叫"+name+"，我今年"+age+"岁"); } public static void student(int age,String name){ System.out.println("我是一个学生，我叫"+name+"，我今年"+age+"岁"); } } /* 代码输出： *我是一个学生 *我是一个学生，我叫小明，我今年5岁 *我是一个学生，我叫小红，我今年18岁 * * */
方法重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型；
重写是父类与子类之间多态性的一种表现；
重写是为了调用子类对象时，改变父类的功能
总结：
1.方法重写：访问修饰符 返回值类型 方法名(参数类型 参数){代码...}
2.方法重写用于继承中(子类 Extends父类)的子类里--------不在同一个类中
3.访问修饰符 权限： 子类>=父类（public>protected>default>private）
4.返回值类型： 4.1.基本类型 或者 void ---子类和父类相同
4. 2.引用类型 -----子类<=父类
5.方法名、参数列表：子类同父类相同,一模一样
6. 继承后，子类就拥有了父类的功能
7. 那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能
8. 子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能
注意：
1、父类中的私有方法不能被重写
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限
package com.zzm.trydemo; /* *方法重写：访问修饰符 返回值类型 方法名(参数类型 参数){代码...} *方法重写用于继承中(子类 Extends父类)的子类里---在不同一个类中 *访问修饰符 权限： 子类>=父类 *返回值类型： 1.基本类型 或者void ---子类和父类相同 * 2.引用类型 ---子类<=父类 *方法名、参数列表：子类同父类相同,一模一样 */ public class Test2_OverRide { public static void main(String[] args) { Student1 s=new Student1(); s.teach(); } } class Teacher1{ public void teach(){ System.out.println("老师上课"); } } class Student1 extends Teacher1{ public void teach(){ System.out.println("学生听课"); } } /* * 输出结果： * 学生听课 * * */
重载与重写的区别（Overload和Override的区别）
1、目的不同
overload用于增加程序的可读性(做法不同,但是做的同一事情)。 override用于提供其超级类已经提供的方法的特定实现。
2、范围不同
overload 在相同的类范围内内执行,是一个类中多态性的一种表现。 override发生在两类具有继承（继承）的关系,是父类与子类之间多态性的一种表现。
3、参数不同
overload参数 必须不同。 override参数 必须相同。
this关键字：
1.this 代表本类对象引用，在本类中使用
2.局部变量和成员变量同名时，用this可调用本类成员方法或者本类成员变量，调用方式 this.成员
因为在构造方法（构造函数）中，有个经典的this用法，所以也顺便提一提
构造方法（构造函数）：构造方法是与类同名，且 没有返回值类型，主要是完成对象的创建或者对象的初始化
修饰符 类名(【参数】){
代码……
}
package test.constructe; //构造方法创建 public class Constr { public static void main(String[] args) { Person p=new Person();//无参创建对象，底层会自动调用无参构造方法 Person p2=new Person("小明");//含参创建对象，底层会自动调用含参构造方法 } } class Person{ //构造方法，与类同名，修饰符 类名(参数列表){方法体} public Person(){//默认会存在构造方法--前提没有提供含参构造方法 System.out.println("无参构造方法"); } //重载构造方法 public Person(String name){ System.out.println("含参构造方法 "+name); } } /* *无参构造方法 *含参构造方法 小明 * * */
package com.zzm.trydemo; /* *1.this 代表本类对象引用，在本类中使用 *2.局部变量和成员变量同名时，用this可调用本类成员方法或者本类成员变量 */ public class Test3_This { public static void main(String[] args) { ThisDemo td=new ThisDemo();//创建无参构造对象时，就会自动调用无参构造方法 ThisDemo td2=new ThisDemo(30); td2.f1(); } } class ThisDemo{ int sum=20; public ThisDemo(){//一般，没有用也要写出来 //this(999);//this 不能在两个都早参数中相互调用，那是死循环 System.out.println("自动调用无参构造方法"); } public ThisDemo(int sum){ this();//在构造方法中，放在第一行；在一个构造函数中可以调另一个构造函数 System.out.println("含参构造方法，已经传入值"+sum); this.sum=sum; } public void f1(){ int sum=10; System.out.println("就近原则"+sum); ThisDemo t=new ThisDemo();//又会调用一次无参构造 System.out.println("新创建一个对象仍然使用的是成员变量的值"+t.sum);//仍然使用的是成员变量的值 System.out.println("使用的传入的赋值后的值"+this.sum);//使用的传入的赋值后的值 f2();//同this.f2();意义结果相同，通常this是隐式，不写直接调用，氮实际上是有this关键字的 } public void f2(){ System.out.println("这是f2"); } } /* * 输出结果： *自动调用无参构造方法 *自动调用无参构造方法 *含参构造方法，已经传入值30 *就近原则10 *自动调用无参构造方法 *新创建一个对象仍然使用的是成员变量的值20 *使用的传入的赋值后的值30 *这是f2 * * * */
super关键字：
1、 通过super关键字可以使用父类的内容
2、 super代表父类的一个引用对象
3、 如果用，必须出现在调用位置的第一行
4、 不管父类无参构造写没写，子类构造无参里都有super，隐式了 。一般都要写无参构造，方便。
如果父类没有写无参构造，子类的构造函数里必须写 super(参数)
package com.zzm.trydemo; /*1、 通过super关键字可以使用父类的内容,在子类中使用 *2、 super代表父类的一个引用对象 *3、 如果用在构造方法中，必须出现在调用位置的第一条语句！！(类似于this) * *4、 不管父类无参构造写没写，子类构造无参里都有super，隐式了 。一般都要写无参构造，方便 * 如果父类没有写无参构造，子类的构造函数里必须写super(参数) * */ public class Test4_Super { public static void main(String[] args) { Student2 s=new Student2(); } } class Person2{ int a=1; public Person2(){//父类无参构造 System.out.println("无参Person2"); } public Person2(int a){//父类有参构造 System.out.println("有参Person2"); } public void f(){ System.out.println("父类f方法"); } } class Student2 extends Person2{ int a=2; public Student2(){//子类无参构造 //super();//先调用父类的无参构造；隐式的，可以不写，不写也会调用父类的无参构造；必须放在第一行 super(1);//super(1)会将super()覆盖掉 System.out.println("Student2"); System.out.println("调用子类的a值"+a); System.out.println("调用父类的a值"+super.a); f(); super.f(); } public void f(){ System.out.println("子类f方法"); } } /* * 输出结果： *有参Person2 *Student2 *调用子类的a值2 *调用父类的a值1 *子类f方法 *父类f方法 * */
1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行
联系客服
