第五章 继承（1）

继承实现的几个点：

        子类通过extends继承父类；

        P p = new Sub()，这种声明方式是多态的一种体现。子类sub重写父类P方法时，调用的是子类重写后的方法。P不能访问子类的getComplay()方法。

public class Main {

    public static void main(String[] args) {
        // 子类赋给超类，P定义是People类，所以它不能使用Employee的私有变量camplay
        People p = new Employee();
        p.setAge(10);
        p.setName("James");
        System.out.println("age: "+ p.getAge() + " name: "+ p.getName() + " className :"+p.getClass().getName() + " test方法： " + p.test());
        Employee e = new Employee();
        e.setCanplay("SN");
        e.setAge(20);
        e.setName("kobe");
        System.out.println("age: "+ e.getAge() + " name: "+ e.getName() + " complay: " + e.getCanplay() +  " className :"+e.getClass().getName() + " test方法： " + p.test());
        // 子类对象赋给超类
        p = e;
        System.out.println("age: "+ p.getAge() + " name: "+ p.getName() +  " className :"+e.getClass().getName() + " test方法： " + p.test());
    }
}

class People{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    protected String test(){
       return  "父类方法test()";
    }
}
class Employee extends People {
    private String canplay;

    public String getCanplay() {
        return canplay;
    }

    public void setCanplay(String canplay) {
        this.canplay = canplay;
    }
    public String test(){
       return "子类方法test()";
    }
}

/*age: 10 name: James className :Employee test方法： 子类方法test()
age: 20 name: kobe complay: SN className :Employee test方法： 子类方法test()
age: 20 name: kobe className :Employee test方法： 子类方法test()*/

若是父类的方法不想被子类重写修改，可以使用final修饰符标记父类方法。

---

抽象类

        abstract修饰的类称为抽象类。有几点需要注意：

        1、抽象类可以没有抽象方法；

        2、抽象方法的声明与普通方法不一样，抽象方法不具备方法体；

        3、子类继承抽象类，必定要实现抽象类中的抽象方法，且需要@Override注解标记子类方法。

public class Main {

    public static void main(String[] args) {
        // 子类赋给超类，P定义是People类，所以它不能使用Employee的私有变量camplay
        People p = new Employee();
        System.out.println(p.getStr()); // hello
    }
}

abstract class People{
    public  String test(){
       return  "父类方法test()";
    }

    public abstract String getStr();
}
class Employee extends People {

    @Override
    public String getStr() {
        return "hello";
    }
}

---

自动装箱与拆箱

        每一个基本类型都有一个与之对应的包装类，例如int与Integer，long与Long，boolean与Boolean等。

public static void main(String[] args) {
       int n = 3;
       Integer m = new Integer(3);
       System.out.println(n == n); // true
       int i = 300;
       Integer j = new Integer(300);
        System.out.println((i == j)); // false
       Integer a = 300;
       Integer b = new Integer(300);
       System.out.println("a : "+ System.identityHashCode(a) + " b:"+ System.identityHashCode(b)  + " 比较结果 ： " + (a == b)); // false
       Integer c = 3;
       Integer d = new Integer(3);
        System.out.println("c : "+ System.identityHashCode(c) + " d:"+ System.identityHashCode(d)  + " 比较结果 ： " + (c == d)); // false
       Integer e = 3;
       Integer f = 3;
        System.out.println("e : "+ System.identityHashCode(e) + " f:"+ System.identityHashCode(f)  + " 比较结果 ： " + (e == f)); // true
       Integer h = 300;
       Integer k = 300;
        System.out.println("h : "+ System.identityHashCode(h) + " k:"+ System.identityHashCode(k)  + " 比较结果 ： " + (h == k)); ; // false
    }

/*输出结果：
true
true
a : 1209271652 b:93122545 比较结果 ： false
c : 403424356 d:321142942 比较结果 ： false
e : 403424356 f:403424356 比较结果 ： true
h : 745160567 k:610984013 比较结果 ： false
*/

        如上述代码所示，n/m,i/j之间的比较是int与Integer的比较涉及到了自动拆装箱之间的转换，-128 ~ 127之间的数会存在与缓存池中， 所以e和f对应的地址值是同一个，对象的比较结果也为true，其他通过new出来的对象之间的比较都是FALSE。