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方法 * */
this和super的区别
1、 this代表本类对象的引用,super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】),代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里,他们两个只要出现都得放在第一行