JAVA核心技术I---JAVA基础知识（类的继承）

一：基本概念同C++一致

二：继承演示

1.将共同点提取出来，即形成了父类/基类/超类
　　–Parent class/Base class/Super class
2.而其他类则自动成为子类/派生类
　　–Child class/Derived cla

（一）父类Human

public class Human {
    public void say() {
        System.out.println("Hello World");
    }
    
    public void eat() {
        System.out.println("eat food");
    }
}

（二）子类Women

public class Women extends Human{
    public void weave() {
        System.out.println("women is weaving");
    }
}

（三）子类Men

public class Men extends Human{
    public void plough() {
        System.out.println("Men is ploughing");
    }
}

（四）继承演示

public class HumanTest {
    public static void main(String args[]) {
        Women w=new Women();
        w.eat();　　//方法继承于父类
        w.say();　　//方法继承于父类
        w.weave();
        
        Men m=new Men();
        m.eat();　　//方法继承于父类
        m.say();　　//方法继承于父类
        m.plough();
    }
}

eat food
Hello World
women is weaving
eat food
Hello World
Men is ploughing

二：信息隐藏

1.Man extends Human 表示Man继承于Human
2.Human是父类，Man是子类
3.子类继承父类所有的属性和方法（但不能直接访问private成员）
4.根据信息隐藏原则：子类会继承父类所有的方法。可以直接使用。
5.子类也会继承父类的父类的所有的属性和方法（但不能直接访问private成员）

三：单根继承（不同于C++）

1.单根继承原则：每个类都只能继承一个类
2.如果不写extends，Java类都默认继承java.lang.Object类
3.class Human extends java.lang.Object
4.Java所有类从java.lang.Object开始，构建出一个类型继承树
5.Object类里面默认就有clone, equals, finalize, getClass, 
hashCode, toString等

C++允许继承多个父类

四：this和super

（一）this

1.this是对象方法中的隐藏参数们可以用于调用对象中的各个方法和变量。
2.this可以实现调用其他构造方法

class Person {

    String name, department;

    int age;

    public Person(String n){ name = n; }

    public Person(String n, int a){ name = n; age = a; }

    public Person(String n, String d, int a) {

        // doing the same as two arguments version of constructor 

        // including assignment name=n,age=a

        department = d;

   }

}

Which expression can be added at the "doing the same as..." part of the constructor? 

A.Person(n,a);

B.this(Person(n,a));

C.this(n,a);

D.this(name,age);

（二）super

默认调用：

每个子类的构造函数的第一句话，都默认调用父类的无参数构造函数super()，除非子类的构造函数第一句话是super，而且super语句必须放在第一条，不会出现连续两条super语句。

public class Human {
    public Human() {
        System.out.println("Human construct exec");
    }
    
    public void say() {
        System.out.println("Hello World");
    }
    
    public void eat() {
        System.out.println("eat food");
    }
}

public class Men extends Human{
    public Men() {
        
        System.out.println("Men construct exec");
    }
    
    public void plough() {
        System.out.println("Men is ploughing");
    }
}

public class HumanTest {
    public static void main(String args[]) {
        Men m=new Men();
    }
}

Human construct exec    //先执行父类构造
Men construct exec    //再执行子类构造

显式调用：

public class Human {
    public Human() {
        System.out.println("Human construct exec");
    }
    
    public Human(int a) {
        System.out.println("Human construct exec"+a);
    }
    
    public void say() {
        System.out.println("Hello World");
    }
    
    public void eat() {
        System.out.println("eat food");
    }
}

public class Men extends Human{
    public Men() {
        super(5);
        System.out.println("Men construct exec");
    }
    
    public void plough() {
        System.out.println("Men is ploughing");
    }
}

public class HumanTest {
    public static void main(String args[]) {
        Men m=new Men();
    }
}

Human construct exec5
Men construct exec

注意：父类只有含参构造，则子类必须显式调用super(参数)

注意：super只能调用可以由父类继承过来的方法和成员

class TestA{
    private int i;
    
    public TestA(int i) {
        this.i=i;
    }
    
    public String toString() {
        System.out.println("i="+i);
        return " "+i;
    }
    
    protected void say() {
        System.out.println("super can call me");
    }
    
    private void say2() {
        System.out.println("super can`t call me");
    }
}

interface TestTable{
    public int s=11;    //接口声明的成员默认都是常量,必须赋初值,不允许默认值,而且继承的类不允许修改该变量
}

public class Test extends TestA implements TestTable{
    public Test(int i){
        super(i);
        //super.i    不能继承，故super不能调用
        //super.say2()    不能继承，故super不能调用
        super.say();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

五：重写和重载

（一）重载：overload

多个方法：相同名字，不同参数，便产生了重载。编译器会通过参数去判断具体执行哪一个方法。叫做重载解析

public class Men extends Human{
    public Men() {
        System.out.println("Men construct exec");
    }
    
    public Men(int a) {
        System.out.println("Men construct exec");
    }
    
    public Men(int a,int b) {
        System.out.println("Men construct exec");
    }
    
    
    public void plough() {
        System.out.println("Men is ploughing");
    }
    
    public void plough(int a) {
        System.out.println("Men is ploughing");
    }
    
}

（二）重写/覆盖

子类同样实现了父类的方法，相同名字和参数，将父类方法覆盖。调用子类对象时会先在该子类中去寻找，向上查找，在当前子类查找成功，就不会继续向上。

Men construct exec
Men is eating

（三）重写规则《重点》

（1）重写方法不能比被重写方法限制有更严格的访问级别。

    现有
    public class Parent{
        public void change (int x){
        }
    }

    public class Child extends Parent{
    ／／覆盖父类change方法

   }
   下列哪个声明是正确的覆盖了父类的change方法？

A.public void change (int x){}

B.protected void change (int x){}　　//比父类限制更加严格是不对的

---

 

重写方法限制更加宽松是可以的（前提是该方法可以继承）

（2）参数列表必须与被重写方法的相同。

（3）返回类型必须与被重写方法的返回类型相同

（4）重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。但是可以抛出更少，更有限或者不抛出异常。

注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类不再这个限制之中。

（5）不能重写被标识为final的方法。

（6）如果一个方法不能被继承，则不能重写它。如private方法

（7）子类不能用 静态方法重写父类的非静态方法

（8）子类不能用非静态方法重写父类的静态方法