java基础复习总结之this和super关键字

一、this和super关键词应用

   1.this关键字

     this关键字在当前类内部使用，可以调用当前类的成员变量和方法。（在类中调用自己的成员变量，建议通过this来调用，这样方便区分成员变量和局部变量）

     1）调用当前类的成员变量

         用法：this.成员变量名
         案例public class Test {
private String name;

// 有参构造方法
public Test(String name) {
//采用这种写法可以很好的区分成员变量和局部变量,解决变量名冲突的问题
this.name = name;
}
}

     2）调用当前类的方法

            用法：this.方法名([参数1，参数2....])
        案例public class Test {
//加法计算
public int add(int a , int b) {
int sum = a + b;
//调用当前类的打印方法
this.log(sum);
return sum;
}

//打印计算结果
public void log(int sum) {
System.out.println("sum = "+sum);
}

public static void main(String[] args) {
Test test = new Test();
test.add(1, 2);
}
}

     3）调用构造方法

         用法：this([参数1，参数2...])
         在构造方法中调用其他构造方法，必须把this()放在方法内部第一行，且只能出现一次。
         案例public class Test {
//无参构造方法
public Test() {
this("cs");
System.out.println("无参构造方法");
}
//有参构造方法
public Test(String name) {
System.out.println("name: "+name);
}
}

    2.super关键字

        1）子类调用父类的成员变量和方法

     用法：super.成员变量名、super.方法名([参数1,参数2...])
     案例     //动物类
class Animal {
public String name = "动物";

// 动物叫
public void shout() {
System.out.println(this.name + "叫");
}
}

//犬类
public class Dog extends Animal {
public String name = "旺财";

// 重写了父类shout的方法
public void shout() {
// 在子类中调用方法
super.shout();
// 子类叫
System.out.println(this.name + "汪汪叫");
}

// 打印名称
public void printName() {
// 子类名称
System.out.println("子类名称： " + this.name);
// 在子类中调用父类的成员变量
System.out.println("父类名称： " + super.name);
}

public static void main(String[] args) {
Dog dog = new Dog();
dog.shout();
dog.printName();

}
}        输出结果：
                    动物叫
                    旺财汪汪叫 
                    子类名称： 旺财
                    父类名称： 动物

     2）子类调用父类的构造方法

      用法：super([参数1,参数2...])
             *在子类中无参构造方法默认会调用父类的无参构造方法。
              java中每个类必须有一个构造方法，如果没有写，则系统会默认生成一个无参的构造方法，如果写了一个有参的构造方法，则系统不会自动生成无参构造方法，所以如果觉得当前类可能被别的类继承，建议写无参的构造参数。

         A.子类无参构造方法调用父类无参构造方法  

            错误案例：父类没有无参构造方法   //动物类
class Animal {
//父类有参的构造方法
public Animal(String name) {
System.out.println("父类有参构造方法 name="+name);
}
}

//犬类
public class Dog extends Animal {
//子类无参构造方法
public Dog() {
//super(); //系统默认会调用父类无参构造方法，所以加不加效果一样
System.out.println("子类无参构造方法");
}

public static void main(String[] args) {
Dog dog = new Dog();
}
}            输出结果：   编译错误
            正确案例：父类有无参构造方法   //动物类
class Animal {
//父类无参构造方法
public Animal() {
System.out.println("父类无参构造方法");
}
//父类有参构造方法
public Animal(String name) {
System.out.println("父类有参构造方法 name="+name);
}
}

//犬类
public class Dog extends Animal {
//子类无参构造方法
public Dog() {
//super(); //系统默认会调用父类无参构造方法，所以加不加效果一样
System.out.println("子类无参构造方法");
}

public static void main(String[] args) {
Dog dog = new Dog();
}
}           输出结果：  父类无参构造方法
                              子类无参构造方法

          B.子类无参构造方法调用父类有参构造方法

             案例：//动物类
class Animal {
//父类无参构造方法
public Animal() {
System.out.println("父类无参构造方法");
}
//父类有参构造方法
public Animal(String name) {
System.out.println("父类有参构造方法 name="+name);
}
}

//犬类
public class Dog extends Animal {
//子类无参构造方法
public Dog() {
//调用父类有参构造方法
super("动物");
System.out.println("子类无参构造方法");
}

public static void main(String[] args) {
Dog dog = new Dog();
}
}             输出结果：  父类有参构造方法  name=动物
                               子类无参构造方法