java继承

* 继承（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