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
 * 
 * 
 * */
this案例

 

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方法 
 *
 */
super案例

 

this和super的区别

1、 this代表本类对象的引用,super代表父类对象的引用。

2、 this用于区分局部变量和成员变量

3、 super用于区分本类变量和父类变量

4、 this.成员变量  this.成员方法()  this(【参数】)代表调用本类内容

5、 super.成员变量  super.成员方法()  super(【参数】),代表调用父类内容

6、 this和super不可以同时出现在同一个构造方法里,他们两个只要出现都得放在第一行

 

你可能感兴趣的:(Java面向对象中:方法重载和方法重写以及区别、 this关键字和super关键字以及区别)