继承
一个类 可以 继承自 另一个类；
派生的类（子类）继承父类的方法和数据成员；
关键字：子类 extends 父类。
public class 继承 {
public static void main(String[] args) {
王思聪 a = new 王思聪();
System.out.println(a.money);
a.show();
}
}
class 王健林 {
double money = 188.88;
void show() {
System.out.println("不差钱");
}
}
class 王思聪 extends 王健林 {
}
设计示例
继承主要解决的问题是：共性抽取。
继承的特点：
|--子类可以拥有父类的“内容”
|--子类可以拥有自己的“内容”
卡车和巴士都是汽车，它们共有的特征来自汽车，他们也可以有自己的特征：
public class 继承2 {
public static void main(String[] args) {
}
}
class 汽车 {
private int wheels;
public int getWheels() {
return wheels;
}
public void setWheels(int wheels) {
this.wheels = wheels;
}
// ------------------------
public void 开车() {
System.out.println("开车了");
}
public void 刹车() {
System.out.println("刹车");
}
}
class 卡车 extends 汽车 {
private int carryingCapacity;
public int getCarryingCapacity() {
return carryingCapacity;
}
public void setCarryingCapacity(int carryingCapacity) {
this.carryingCapacity = carryingCapacity;
}
// ------------------------
public void 挂箱() {
System.out.println("挂箱");
}
}
class Bus extends 汽车 {
private int seatings;
public int getSeatings() {
return seatings;
}
public void setSeatings(int seatings) {
this.seatings = seatings;
}
// ------------------------
public void 报站(String str站名) {
System.out.println(str站名 + "已到");
}
}
继承控制
protected：继承即可用，即使不在同一个包中
private：不给继承
this和super
this：自己的
super：父类的
|-|-super()：父类构造方法
|-|-super.XXX：父类的成员（方法或变量）
public class This_and_Super {
public static void main(String[] args) {
S _s = new S();
_s.m();// 直接通过子类对象，调用的是子类的方法
_s.newNethod();
}
}
class F {
protected int a = 1;
protected void m() {
System.out.println("F");
}
}
class S extends F {
protected int a = 99;
protected void m() {
System.out.println("S");
}
protected void newNethod() {
System.out.println(super.a);
System.out.println(this.a);
System.out.println(a);// 直接调用，是自己的值
// ---------
super.m();
this.m();
m();// 直接调用，是自己的方法
}
}
super()：再论构造方法
super必须有，不写也默认，必须第一句，只能有一个
(1)默认调父类的无参构造方法，直到显式调用父类的有参构造方法。
详解：无论子类构造方法带不带参数，默认都是执行父类的无参构造方法。【隐藏一句代码:super()】
如果非要执行父类带参构造方法的话，使用super(参数列表)。
(2)super(父类构造方法)只能放在构造方法中，且必须放在第一句，因此也不能多次调用父类构造方法。
测试：
public class 构造顺序 {
public static void main(String[] args) {
new S();
new S(1);
new S(1L);
}
}
class F {
F() {
System.out.println("父类构造方法");
}
F(int a) {
System.out.println("父类构造方法(带参)");
}
}
class S extends F {
S() {
System.out.println("子类构造方法
");
}
S(int a) {
System.out.println("子类构造方法(带参)
");
}
S(long a) {
super(1);
System.out.println("子类构造方法2(带参)，显示调用父类的带参构造方法
");
}
}
父类构造方法
子类构造方法父类构造方法
子类构造方法(带参)父类构造方法(带参)
子类构造方法2(带参)，显示调用父类的带参构造方法
this()
this(...)也可以调用自己的其它构造方法，也必须放在第一句，一个构造方法中只能写一句。
class S2 extends F {
S2() {
this(100);
}
S2(int a) {
this(100, 200);
}
S2(int a, int b) {
}
}
思考题：总结super和this的用法
重写·Override
Override：方法重写、方法覆盖。
子类可以重新定义继承自父类的方法。子类方法中，可通过super来调用父类的方法。
- 两同：方法名相同，形参列表相同
- 两不大：返回类型不比父类大（大手大脚败家子），异常不比父类大（不得扩大范围）
- 一不小：访问权限不比父类小（不得废公为私）
public class 重写 {
public static void main(String[] args) {
Ostrich os = new Ostrich();
os.twitter();
os.fly();
}
}
class Bird {
public void twitter() {
System.out.println("wakuwaku");
}
public void fly() {
System.out.println("飞");
}
}
// 鸵鸟类
class Ostrich extends Bird {
@Override// 不写也是重写，写了会做检测，若方法在父类不存在将报错
public void fly() {
super.fly();
System.out.println("?并不会");
}
}
wakuwaku
飞
?并不会
返回类型不比父类大（注：Object是String的父类）
访问权限不比父类小（尧→舜→禹，启结束了禅让制度。）
class Bird {
public Object twitter() {
return null;
}
public String fly() {
return null;
}
}
// 鸵鸟类
class Ostrich extends Bird {
public String twitter() {// 父类是Object，子类是String，没问题
return null;
}
@Override// 父类返回类型String，改为Object
public Object fly() {// The return type is incompatible with Bird.fly()
return null;
}
}
// 鸽子类
class Pigeon extends Bird {
@Override
private String fly() {// 父类是public，改为private
// Cannot reduce the visibility of the inherited method from Bird
return null;
}
}
重写的应用场景：
对于已经存在的类，尽量不要进行代码修改，而是派生一个新的子类，对响应的方法进行重写。
final（不准修改）
Final修饰类：该类不可被继承（比如String类）
Final修饰方法：该方法不能被重写
Final修饰变量：不能被重新赋值
Java里的“常量”：
public static final int CHANG_LIANG = 10;
继承的坏处
继承是实现类复用的重要手段，但是继承会破坏封装。
每个类都应该封装其内部信息和实现细节，仅暴露必要的方法给其他类使用。但子类可以直接访问父类的内部信息，甚至可以重写父类的方法，这增加了子类和父类的耦合度，破坏了封装。
设计父类时，应遵循以下原则：
- 尽量将父类的成员变量设置为private。
- 尽量缩小方法的访问权限，能私有尽量不要共有。
- 不希望被子类重写的方法设置为final。
- 不要在父类的构造方法中调用被子类重写的方法。
下例代码中，父类A的构造方法，该方法调用了被重写的method()方法，因为是先执行父类构造方法，而其调用的method()方法是被子类重写的，此时并没有变量s，因此s为null。
class A {
public A() {
System.out.println("A的构造方法");
method();
this.method();
}
public void method() {
System.out.println("A method");
}
}
class B extends A {
public String s = "子类变量";
public void method() {
System.out.println("B method：" + s);
}
}
public class TestInstanceOf {
public static void main(String[] args) {
B b = new B();
}
}