* 继承（extends）

* java是一种树形结构(联结类的层次模型)，单继承(父类)，多实现(接口+内部类)

* 子类和父类之间是is-a关系

* 在子类中使用super关键字，访问父类的成员，super必须出现在子类。本类中方法中this调用本类的成员(属性和方法，区别于局部变量)，在构造方法中调用(替代)其他构造方法

* 继承规则：①不能继承private成员

*                 ②子类和父类不在同包时，不能继承default默认修饰符成员

*                 ③不能继承(覆盖)父类构造方法(但，在子类构造方法中，使用super可以调用，必须构造方法的第一行)

* 方法重写(覆盖){继承多态}：重写方法和被重写方法，必须有相同的方法名，参数列表，返回值，并且重写方法的访问修饰符权限大于等于被重写方法

* 1：成员方法被覆盖，静态方法不能覆盖

* 2：成员属性(对象)、静态成员属性(类)、静态块(类)被继承了，但不会被覆盖

* 3：用final保证用户调用时动作的一致性，可以防止子类覆盖情况的发生；final修饰的类不可以被继承

* 4：子类构造方法中第一行没有显示使用super调用父类构造方法或this调用本类其他构造方法,则系统默认调用父类的无参构造方法,这种情况，super可以不写(代码规范应该写)

* 5：类在new关键字初始化时，会递归调用高一级的构造方法，结束于Object类的无参构造方法

* 6：abstract(抽象)修饰方法，声明方法而不去实现。此时类为抽象类，不能实例化，必须继承使用，可以作为引用类型。

* 7：抽象(或非抽象)父类：将子类中的共性最大限度的抽取出来，放在父类中，提高程序的简洁性。例如：狗(子类)是一种哺乳动物(父类)，is - a

* 8：方法：abstract必须继承才能使用，static不能被覆盖，final不能被覆盖，所有不能同时作为修饰符

* 9：局部变量和成员变量，在同一个类中，不能有重名的成员变量，在同一方法中不能有重名的局部变量，但同一个类中多个不同方法，成员变量和局部变量可以重名(冲突)。

局部变量，要先赋值，在进行计算。而成员变量new出来就已经赋有初值值。

实现代码：

父类：

package ca.bx.staticextends;public class APClass {	private String p1;	private int p2;	//有参构造方法	public APClass(String x,int y){		this.p1 = x;		this.p2 = y;	}	//默认构造方法	public APClass(){		super();	}	//成员变量(属于对象)	private int a = 1;	int b = 2;	protected int c = 3;	public int d = 4;	public int f = 444;	public static final int h = 555;	//静态变量，类变量(属于类)	public static int sa = 5;	public static int sc;	public static int sd;	public static int sf;	//静态块，初始化静态成员变量	static{		sc = 6;		sd = 7;		sf = 8;	}	//成员方法(属于对象)	public int add(int x,int y){		return x + y;	}	//静态方法，类方法(属于类)	public static int multiply(int x,int y){		return x * y;	}	//final修饰方法	public final int minus(int x,int y){		return x - y;	}	//省略对私有属性，访问接口，getter和setter方法}

子类继承父类：

package ca.bx.staticextends;public class SClass extends APClass{	private boolean p3;	private String p4;	//调用构造方法,	//this和super不能同时使用	public SClass(boolean b,String s){		this();//相当于本类的public SClass()构造方法，也可以this(false,"ss");必须第一行		this.p3 = b;		this.p4 = s;	}	//默认构造方法	public SClass(){		super("ss", 1);//调用父类的public APClass(String x,int y)构造方法；必须第一行	}	//成员变量(属于对象)	private int a = 11;	int b = 22;	protected int c = 33;	public int d = 44;	//静态变量，类变量(属于类)	public static int sa = 55;	public static int sc;	public static int sd;	//静态块，初始化静态成员变量	static{		sc = 66;		sd = 77;	}	//成员方法(属于对象)	public int add(int x,int y){		return x + y+8;	}	//静态方法，类方法(属于类)	public static int multiply(int x,int y){		return x * y *2;	}	//Error：不能覆盖final方法，故报错//	public final int minus(int x,int y){//		return x - y;//	}	//super调用父类的成员	public void apcPrint(){		System.out.println("父类b属性:"+super.b+"，父类add方法："+super.add(4, 9));	}	//this局部变量和成员变量，优先级前者高	public void scPrint(){		int b = 200;		System.out.println("变量(局部)b："+b+"，成员变量b："+this.b);	}}

测试类：

package ca.bx.staticextends;public class TestX {	public static void main(String[] args) {		SClass sc = new SClass();		APClass apc = new SClass();		int x = 2;		int y = 3;		System.out.println("调用方法：");		System.out.println(apc.add(x, y));//2 + 3 + 8  //成员方法被覆盖，多态		System.out.println(apc.multiply(x, y));//2 * 3 //静态方法未被覆盖(静态),无多态   *APClass.multiply(x, y)		//用final保证用户调用时动作的一致性，可以防止子类覆盖情况的发生		System.out.println(sc.minus(x, y));		System.out.println(apc.minus(x, y));		sc.apcPrint();		sc.scPrint();		System.out.println("子类对象调用属性1：");		//父类访问修饰符对子类可见,子类才可以继承（*方法也类似*）		//a属性，为private，本来可见，子类不可见，不继承		//b属性不在同包下，不可见，不继承		System.out.println(sc.b); 		System.out.println(sc.c);		System.out.println(sc.d);		System.out.println(sc.f);		System.out.println(sc.sa);		System.out.println(sc.sc);		System.out.println(sc.sd);		System.out.println(sc.sf);		System.out.println(sc.h);		System.out.println("父类对象调用属性1：");		System.out.println(apc.b); 		System.out.println(apc.c);		System.out.println(apc.d);		System.out.println(apc.f);		System.out.println(apc.sa);		System.out.println(apc.sc);		System.out.println(apc.sd);		System.out.println(apc.sf);		System.out.println(apc.h);		//***可见类的成员变量，可继承，但不可被子类覆盖	}}

输出结果：

调用方法：

13 6 -1 -1 父类b属性:2，父类add方法：13 变量(局部)b：200，成员变量b：22 子类对象调用属性1： 22 33 44 444 55 66 77 8 555 父类对象调用属性1： 2 3 4 444 5 6 7 8 555