Java面向对象中：方法重载和方法重写以及区别、 this关键字和super关键字以及区别

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不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行