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=动物
                               子类无参构造方法