java学习笔记（二）java继承特性总结

java继承特性总结


1、父类（超类）、子类为继承关系，在子类中对父类相同方法进行覆盖的时，使用super（）可调用父类该方法。该方法常用于子类对象试图访问其父类中所定义的域。如：
class Employee{
    private float salary;
    public float getSalary(){
        return salary;
    }
}

class Manager extends Employee{
    private float bonus;
    public float getSalary(){
        return bonus + salary;//无效，因为子类对象的方法不能调用其父类中定义的私有对象。
    }
}
/*无效，因为子类对象的方法不能调用其父类中定义的私有对象。*/

class Boss extends Employee{
    private float benefits;
    public float getSalary(){
        return benefits + getSalary();
    }
}
/*无效，并且该方法会一直递归执行直至程序崩溃。因为子类中的getSalary()覆盖了父类的方法。*/

class CEO extends Employee{
    private float investment;
    public float getSalary(){
        return investment + super.getSalary();
    }
}
/*有效，因为使用了super。*/

同样，super也可以使用在构造器中，以构造尽在父类中定义的域。

2、多态性。子类对象同样也属于父类，所以父类对象的引用也可以指向其子类对象。如(接以上的实例代码)：
Employee e;
e = new Employee();
e = new Manager();
/*都可以*/
但如此行为存在问题，当e指向Manager类的对象时：
e.bonus = 1000;
/*该调用无效*/
因为e本身是Employee对象的引用，而Employee对象不含bonus域，所以这样用是错误的。

3、final类和方法。使用final修饰符修饰的类不能被继承；使用final修饰符修饰的方法不能被子类覆盖。

4、强制类型转换。使用类名加括号在某个对象前可对其进行强制类型转换。但是只能将子类对象转换成其父类对象，反之不行。

5、抽象类。使用abstract修饰符修饰的类为抽象类，使用abstract修饰符修饰的方法为抽象方法，含有抽象方法的类一定为抽象类，抽象类不能被实例化。抽象类的抽象方法可以在子类中对其描述具体实现，方法即为在子类中覆盖即可。如：
abstract class Person{
    private String name;
    public String getName(){
        return name;
    }
    abstract public String getDescription();
    /*该方法不需要实现*/
}

class Student extends Person{
    private String major;
    public String getDescription(){
        return super.getName() + "majors in" + major;
    }
    /*在子类中实现该方法*/
}

6、protected域。protected修饰的域可以被其类的子类直接访问，但不能被其他类的方法访问。

7、Object类。Object类是所有类的父类。可以使用Object类的引用指向任何类的对象。相等测试是用来比较对象之间是否相同的工具。往往以equal方法的形式出现。Object类中定义有equal方法。在子类中定义equal方法时，应先调用父类的equal方法，从而减少判断可能的过程。

8、toString 方法。头String方法可以返回对象的字符串形式或者描述。很多java标准库中的类都定义了toString方法。建议所有用户自定义的类中都实现toString方法。

9、泛型数组列表。ArrayList是一个采用类型参数的泛型类，类似数组可以保存多种相同属性的对象。但使用（实例化）时往往通过<>符号对其内部对象类型指定一个类。例如：
ArrayList<Employee> employee_list = new ArrayList<Employee>();
/*或者：*/
ArrayList<Employee> employee_list = new ArrayList();
该语句定义了一个长度可变的Employee“数组”，可以通过ArrayList类的方法对其进行添加、删除、修改、访问元素操作。其中每个元素都有一从0开始的编号，以上方法可以调用该方法。例如：
employee_list.add(Tom);
/*Tom是一个Employee类型的对象，该操作在“数组”最后加上Tom元素，并重新分配employee_list列表所占据的储存空间*/
employee_list.add(1,Tom);
/*该方法在“数组”编号为1的位置加入Tom元素，其之后的原有元素依次向后移动一个编号*/
employee_list.remove(1);
/*该方法移除列表中编号为1的元素，其之后的元素均一次向前移动一个编号*/
employee_list.set(1,Tom);
/*该方法将列表中原来编号为1的元素修改为Tom*/
employee_list.get(1);
/*该方法返回列表中编号为1的元素*/

10、对象的包装与自动装箱。java中的基础类型（int、float、double等等）不作为类出现，则这些基本类型的变量也不是对象。当需要以对象的方式处理这样的变量时，应用以上类型所对应的包装器（类的形式出现的以上类型）。同时在java程序编译时，编译器会在需要的时候对以上基本类型变量和所对应的包装器对象相互转换。

11、参数可变的方法。可以定义参数可变的方法。例如：
public int findMax(int... x){
    int max = 0;
    for(int e : x){
        if(e > max){
            max = e;
        }
    }
    return max;
}
/*该方法用来寻找一系列整型 中的最大值。*/
定义方法时，在参数表用添加如上int... x的参数即为不定参数数量的方法，调用时，参数以数组的形式传递给方法。另外，在同一个方法中可变参数可以和确定参数相结合。例如：
public int findMax(int mul， int... x){
    int max = 0;
    for(int e : x){
        if(e > max){
            max = e;
        }
    }
    return mul * max;
}
/*该方法返回最大值的mul倍*/
调用此方法时，参数表必须包含两部分int，前一部分为确定参数，后一部分为数量可变的。

12、枚举。声明一个枚举类使用如下语句：
public enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE);
其中，Size是一个自定义的类名，而SMALL, MEDIUM, LARGE, EXTRA_LARGE分别可以理解为其对象，所以在使用枚举类的时候，不需要再new新的对象，直接使用该类的引用指向线程对象即可。如：
public enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE);
Size m_size = Size.Small;

枚举作为一个类，也可以定义构造器或者成员方法，因为在定义枚举类时就会直接产生其对应的对象，如上面Size的声明所示，所以，在定义枚举类中的枚举量（对象）时，应在后面加上构造器所需要的参数。且枚举类的构造器不能为public，因为在声明枚举类之后的使用中无需在new一个对象。例如：
public enum Size{
    SMALL("S");
    MEDIUM("M");
    LARGE("L");
    EXTRA_LARGE("XL");

    private String mark;

    private Size(String mark){
        this.mark = mark;
    }
    /*构造器*/

    public String getMark(){
        return mark;
    }
    /*成员方法，取得该对象的mark变量*/
}