Java笔记(7)继承重写super关键字

Java笔记（7）

继承

举例：

//Person.java
package day07;

public class Person {
    int age;
    String name;
    int sex;
    
    public void showInfo() {
    	System.out.println(this.age);
    	System.out.println(this.name);
    	System.out.println(this.sex);
    }
}

//Student.java  继承Person类
package day07;

public class Student extends Person {
   String school;
   
   public void showInfo() {
	   System.out.println(this.age);
	   System.out.println(this.name);
       System.out.println(this.sex);
       System.out.println(this.school);
   }
}

子类的共性代码都继承自父类

为什么要有继承：

（1）多个类存在相同属性和行为时，将这些内容单独抽取到同一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

（2）此处的多个类称为子类，单独的这个类称为父类（基类或超类）。可以理解为：“子类 is a 父类”

（3）类继承语法规则：

class Subclasss  extends Superclass

继承的作用：

（1）继承的出现提高了代码的复用性

（2）继承的出现让类与类之间产生了关系，提供了多态的前提

（3）不要仅为了获取其他类中的某个功能而去继承

继承的意义：

（1）子类继承了父类，就继承了父类的方法和属性

（2）在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法

（3）在Java中，继承的关键字用的是”extends“，即子类不是父类的子集，而是对父类的“扩展”

关于继承的规则：

（1）子类不能直接访问父类中私有的（private）的成员变量和方法。

（2）Java只支持单继承不支持多重继承

​ 一个子类只能有一个父类

​ 一个父类可以派生出多个子类

class SubDemo extends Demo{}  //ok
class SubDemo extends Demo1,Demo2...//error 

单继承和多继承

单继承举例：

代码练习：

//ManKind.java
package day07;

public class ManKind {
      int sex;
      int salary;
      
      
      public int getSex() {
		return sex;
	}

	public void setSex(int sex) {
		this.sex = sex;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public void manOrWomen() {
    	  if (this.sex== 1) {
    		  System.out.println("man");
    	  }else if(this.sex == 0){
    		  System.out.println("women");
    	  }
      }
      
      public void employeed() {
    	  if(this.salary==0) {
    		  System.out.println("no job");
    	  }else  {
    		  System.out.println("job");
    	  }
      }
}

//Kids.java
package day07;
//继承Mankind父类
public class Kids extends ManKind {
         int yearsOld;
         
		public int getYearsOld() {
			return yearsOld;
		}

		public void setYearsOld(int yearsOld) {
			this.yearsOld = yearsOld;
		}
         

		  public void printAge() {
	        	System.out.println(this.yearsOld);
	         }
		  //测试代码输出结果
		  public static void main(String[] args) {
			  Kids someKid =new Kids();
			  someKid.setSex(0);
			  someKid.setSalary(100);
			  
			  someKid.manOrWomen();
			  someKid.employeed();
			  
		  }
}

//输出结果：
//			women
//			job

方法的重写（Over Ride）

定义：

在子类中可以根据需要对从父类中继承来的方法进行改造，也称方法的重置、覆盖。在程序执行是，子类的方法会覆盖父类的方法。

要求：

（1）重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型，就是子类重写父类方法，只是编写方法体的代码。

（2）重写方法不能使用比被重写方法更严格的访问权限，如果父类是public的，子类重写的时候不能使用缺省一下。

（3）重写和被重写的方法必须同时为static的，或同时为非static

（4）子类的方法抛出的异常不能大于父类被重写的方法的异常

方法重写代码举例：

package day07;

public class Student extends Person {
   String school;
   
//   public void showInfo() {
//	   System.out.println(this.age);
//	   System.out.println(this.name);
//       System.out.println(this.sex);
//       System.out.println(this.school);
//   }
   @Override
	public void showInfo() {
	   System.out.println("一下是student类对person类的showInfo方法的重写");
	   System.out.println(this.age);
       System.out.println(this.name);
   	   System.out.println(this.sex);
	}
   
//  @Override
//	public void setInfo(int age, String name, int sex) {
//		System.out.println(age);
//		System.out.println(name);
//		System.out.println(sex);
//	}
   
  public static void main(String[] args) {
	   Student stu =new Student();
	   stu.showInfo();
     }
  
  }

//输出结果：
//		一下是student类对person类的showInfo方法的重写
//		0
//		null
//		0

四种访问权限修饰符

（1）如果子类和父类在同一个包下。对于父类的成员，只要修饰符不是私有的（private），那子类就都可以使用

（2）如果子类和父类不在同一个包下，子类只能使用父类中的protected和public修饰的成员变量

关键字super

作用：

在java类中使用super来调用父类中的指定操作：

（1）super可用于访问父类中定义的属性

（2）super可用于调用父类中定义的成员方法

（3）super可用于在子类构造方法中调用父类的构造器

注意：

（1）尤其当子父类出现同名成员，可用super来区分

（2）super的追溯不仅限于直接父类

（3）super和this的用法很像，this代表本类对象的引用，super代表父类的内存空间的标识

super使用方法的代码：

package day07;

public class Kk extends Kids {
   public void test() {
	   super.salary =1;  //可以使用super向上追溯父类的父类，可以一直向上追溯，如果层级很多的话
	   super.yearsOld =1;//可以使用super直接追溯父类的成员变量
	   super.employeed();//可以使用super直接追溯父类的成员方法
	   super.manOrWomen();//可以使用super向上追溯父类的父类的成员方法，可以一直向上追溯，如果层级很多的话
   }
}

调用父类的构造器

（1）子类中所有的构造器默认都会范文父类中空参数的构造器

（2）父类中没有空参数的构造器时，子类的构造器必须通过this（参数列表）或者super（参数列表）语句指定调用本类或者父类中相应的构造器，且必须方在构造器第一行

（3）如果子类构造器中即未显示调用父类或本类的构造器，且父类中有没有无参的构造器，则编译出错

调用父类的构造器举例

public class Perosn{
     
    private String name;
    private int age;
    private Date birthDate;
    
    public Person(String name,int age,Date d){
        this.name=name;
        this.age=age;
        this.birthDate=d;
    }
     
    public Person(String name,int age){
        this(name,age,null);
    }
    
    public Person(String name,Date d){
        this(name,30,d);
    }
    
    public Perosn(String name){
        this(name,30);
    }
    //...
}

public class Student extends Person{
   private String school;
    
   public Student(String name,int age,String s){
       super(name,age);
       school=s;
   }
    
    public Student(String name ,String s){
        super(name);
        school=s;
    }
    
    public Student(String s){
        //编译出错：no super（），系统将调用父类无参数的构造方法
        school=s;
    }
}