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不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行
如对本文有疑问， 点击进行留言回复！！
Java面向对象中：方法重载和方法重写以及区别、 this关键字和super关键字以及区别
【开源】使用Angular9和TypeScript开发RPG游戏(补充了Buffer技能)
网友评论