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