学步园

继承：就是扩展已有类的功能，在继承中分为子类和父类，父类有时候又称为超类（super class）、子类有时候也称为派生类

继承的基本语法：

class 子类 extends 父类();

继承的特征：

*在使用继承的时候虽然可以扩充类的功能

*在JAVA中不允许多重继承，一个子类只能继承一个父类，不能继承多个父类。

*允许多层继承（B继承A ；C继承B；）

*继承中子类不能访问父类的私有操作，只能继承全部的公共操作；

（私有内容是不能直接访问的，但是可以通过其他的途径访问）

ExtendsDemo.java 

public class ExtendsDemo {

	public static void main(String[] args) {
		Student student = new Student();//学生
		student.setName("张三");//从Persons继承而来
		student.setAge("11");//从Persons继承而来
		student.setSchool("大学");
		System.out.println("name="+student.getName());
		System.out.println("age="+student.getAge());
		System.out.println("schooll="+student.getSchool());
	}
}

class Student extends Persons{
	private String school; //扩充的属性
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
}

class Persons{
	private String name;
	private String age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	
};


//结果：
//name=张三
//age=11
//schooll=大学

继承的子类实例化过程

class A{
	public A(){
		System.out.println("-------A-------");
	}
}
class B extends A{
	public B(){
		System.out.println("-------B-------");
	}
}
public class ExtendsDemo2 {
	public static void main(String args[]){
			B b = new B();
	}
}

//结果：
//-------A-------
//-------B-------

以上操作代码在执行时，发现先执行了父类中的无参构造方法（如果没有定义，则编译时也会出现错误），之后才调用子类自己的*

• 构造方法的主要目的：是为类中的属性初始化
• 在实例化子类对象的时候肯定要首先实例化父类中的内容，为父类初始化（先造出父类 才能造出子类）

public class ExtendsDemo {

	public static void main(String[] args) {
		Student student = new Student("zhang san ","11","小学");//学生
		System.out.println("name="+student.getName());
		System.out.println("age="+student.getAge());
		System.out.println("schooll="+student.getSchool());
	}
}

class Student extends Persons{
	private String school; //扩充的属性
	public Student(String name, String age,String school) {
		super(name, age);
		this.school =school;
		// TODO Auto-generated constructor stub
	}
	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
}

class Persons{
	private String name;
	private String age;
	
	public Persons(String name, String age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	
};

//结果：
//name=zhang san 
//age=11
//schooll=小学

方法的覆写 （方法的覆写是发生在继承的关系中，子类覆写了父类的方法（即子类定义了与父类同名的方法））

如果希望调用父类中被子类覆写过的方法 ，则只能通过super.方法() 的形式调用

* 访问权限问题：被覆写的方法不能拥有比子类更严格的访问权限（private < protect<public）

例如：父类中使用的是public访问权限，则子类覆写时的权限只能是public而不能是其他的

   *只要是使用子类实例化对象，调用的方法也被子类覆写过的话，则永远调用的是覆写过的操作

class A{
	public void fun(){
		System.out.println("-------A方法-------");
	}
}
class B extends A{
	public void fun(){
		System.out.println("-------B方法-------");
	}
}
public class ExtendsDemo2 {
	public static void main(String args[]){
			B b = new B();
			b.fun();
	}
}
//结果：
//-------B方法-------

例子  只要是使用子类实例化对象，调用的方法也被子类覆写过的话，则永远调用的是覆写过的操作

class A{
	public void fun(){
		System.out.println("-------A方法-------");
	}
	public void print(){
		this.fun();
	}
}
class B extends A{
	public void fun(){
		System.out.println("-------B方法-------");
	}
}
public class ExtendsDemo2 {
	public static void main(String args[]){
			B b = new B();
			b.print();
	}
}
//结果：
//-------B方法-------

权限问题

class A{
	private void fun(){
		System.out.println("-------A方法-------");
	}
	public void print(){
		this.fun(); 
	}
}
class B extends A{
	void fun(){//此方法实际上属于新建的一个方法
		System.out.println("-------B方法-------");
	}
}
public class ExtendsDemo2 {
	public static void main(String args[]){
			B b = new B();
			b.print();
	}
}
//结果：
//-------A方法-------

属性的覆盖  （《因为开发中属性基本是private 所以属性覆盖基本不存在》子类中声明了父类中同名的方法，成为覆盖）