Java 继承

目录

1.继承的概念

2.继承的特性

3.super 与 this, final,static 关键字

---

1.继承的概念

       继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。当多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

       例如新建一个Person类，拥有age，name属性和introduce方法。

public class Person {
	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void introdce() {
		System.out.println("My name is "+getName()+",I am "+getAge()+" years old.");
	}
}

  再新建一个学生类，同样拥有age，name属性和introduce方法，同时还有school属性和study方法。

public class Student {
	private int age;
	private String name;
	private String school;
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void introdce() {
		System.out.println("My name is "+getName()+",I am "+getAge()+" years old.");
	}
	public void study() {
		System.out.println("I am studying in "+getSchool());
	}
}

       观察这两个类可知，他们拥有相同的属性和方法。如果再新建一个Teacher类，同样拥有age，name属性和introduce方法，又得重复写一遍，非常麻烦。这时我们可以将他们相同的属性和方法抽取出来写到一个类里，通过继承的方式实现我们的需求。以Person类和Student类为例，我们可以用Student类继承Peron类。

//extends 为继承关键字
public class Student extends Person {
	private String school;
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
	public void study() {
		System.out.println("I am studying in "+getSchool());
	}
}

       被继承的类（Person）称为父类，也叫超类，实现继承的类（Student）叫子类，也称派生类。 通过继承Student类拥有了父类的属性和方法，简化了代码。

public static void main(String[] args) {
		Student student = new Student();
		student.setAge(20);  //引用父类方法
		student.setName("Amy");
		student.introdce();
	}

     Student类里没有introduce方法，但通过继承获得Person类的方法，可直接调用。运行结果：

My name is Amy,I am 20 years old.

 

2.继承的特性

  ①Java 不支持多继承，但支持多层继承

     一个类只有一个父类，例如A类不能既继承B类，又继承C类。但B类可以继承C类，然后A类再去继承B类（多层继承）

· ②子类拥有父类非private的属性，方法

     如果把上面Person类的introduce方法改为private，Student类对象不能引用。

· ③子类可以拥有自己的属性和方法，即子类可以对父类进行扩展（可以理解为:“子类 is a 父类” ）

      上面例子中，Student类除了继承Person类的属性和方法，还拥有school属性和study方法.

  ④子类可以重写父类的方法

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

在上面的例子中，Student类继承Person类，我们可以在Student类中重写introduce方法。

public class Student extends Person {
	private String school;
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
	@Override  //重写标志
	public void introdce() {
		// TODO Auto-generated method stub
		System.out.println("My name is "+getName()+",I am "+getAge()+" years old."+"My school's name is "+getSchool());
	}
	public void study() {
		System.out.println("I am studying in "+getSchool());
	}
}

  当我们新建Student对象引用introduce方法时，将执行子类重写的方法。（本例中即输出“My name is.....My school's...”）。

 注意：

Ø重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型。

Ø重写方法不能使用比被重写方法更严格的访问权限。（例如不能将public改为protected，但可将protected改为public）。

3.super 与 this, final ,static关键字

  ①final

    当用final修饰一个类时，表明这个类不能被继承。修饰一个方法时，该方法不能被重写。修饰属性变量时该变量为常量，不能修改，只能在定义时初始化或者构造方法中初始化。

②static

   static修饰方法时，表示方法属于类，称为静态方法，不用定义对象可直接调用。

class A{
	final int i = 0;
	public static void out() {
	 System.out.println("7777777");
	}
} 
//调用静态方法
class B {
	public static void main(String[] args) {
		A.out();
	}
}

  static修饰变量时，该变量也属于类，称为静态变量，也可直接调用。

  注意：静态方法中只能调用本类中的静态变量和静态方法。

 ③this

   我们在写类属性的set方法用过。他可以用来引用成员变量，成员方法，也可以引用构造方法。

class A{
	private int i;
	A(){
		System.out.println("无参构造函数");
	}
	A(int i){
		this();//引用构造函数（必须写在第一行）
		this.i = i; //引用成员变量
	}
	public  void out() {
	 System.out.println("7777777");
	}
	public void output() {
		this.out(); //引用成员方法
	}
} 

 ④super

    我们可以通过super关键字来实现对父类（非private）成员,方法的访问，也可以调用父类的构造器。如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器, 如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

class A{
	private int i;
	A(int i){
		this.i = i;
	}
	public  void out() {
	 System.out.println("7777777");
	}
}
class B extends A{
	public B(int i) {
		super(i); // 调用父类构造函数（必须写在第一行）
		super.out(); //调用父类方法
	}
}