Java程序设计—面向对象0119

• PS: 关于类前有public修饰的相关问题，参考这里：http://blog.csdn.net/u013438638/article/details/50241807 
• Java的继承思想：
  1. 不同的类中有重复的代码（重复的属性），比如三个类都具有年龄，身高，名字等公共属性。
  2. 使用extends关键字，实现继承关系。解决代码重复的问题，同时表达了体系关系。

class Person{
    String name;
    int age;
    public void sleep() {
    }
}
class Student extends Person{
    int num;
}
class Teacher extends Person{
    int level;
}
class Employer extends Person{
    int hireDate;
}

　　　　3. 所谓继承关系指：子类可以继承父类的默写定义（字段，方法，内部类），也可与增加父类没有的定义，或者覆盖父类的某些特性。总体上讲，是从一般到特殊的关系。

　　　　4. 语法格式：单继承格式，不允许多继承。

　　　　　　　　（public） class 子类名 extends 父类名｛

　　　　　　　　　　　　//自己特有的属性和方法　　　　　　　　

　　　　　　　　　　｝

• • 要明白，Object类是所有类的根类。下面Person类的父类是Object。

class Person{
    String name;
    int age;
    public void sleep() {
        
    }
}//class Person extends Object{};

　　　　5.  关于子类的继承权限，可以参考下面的代码：

class Person{
    String name;
    protected int age;
    public void sleep() {
        
    }
    private String privacy;
}

class J2_OOP_Inheritance {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.name="AAAA";//inherit default name
        s1.age=10;//inherit protected age;
        //s1.privacy;//cannot inherit private privacy;    
    }
    
}

• • 除去private，其它都可以继承。其中default类，继承范围在包内，public和protected可以跨包类继承。

1. 子类覆盖父类的原则：一同，两小，一大。

• • 子类要覆盖父类的方法名，必须一致（有点像重载，但是参数绝对不能变！！！！）
  • 子类与父类的返回值相同，或者子类返回的值更加详细。
  • 子类抛出的异常<=父类抛出的异常。
  • 子类方法的访问权限>=父类方法的访问权限。

class Person{//class Person extends Object{};
    String name;
    protected int age;
    public void sleep() {
        System.out.println("I wanna sleep!");
    }
    public void eat() {
        System.out.println("I like big burger");
    }
    private String privacy;
}

class Student extends Person{
    int num;
    public void sleep() {
        System.out.println("I never sleep!");
    }
    protected void eat() {
        System.out.println("I like small burger");
    }//the visibility should be larger than parent class,so should not use "protected"!!
}

　　　　覆盖的概念，只存在于 方法 中， 字段是没有覆盖的。

　　　　标签: @override, 用于判断子类方法是否重写了父类方法，如果没有，编译报错。

　　　　方法重载（overload）和重写(override)，二者没有任何关系:

• Super关键字：当子类中，需要调用父类被覆盖的方法，利用super关键字。

class Dog{
    public void bark() {
        System.out.println("I can bark");
    }
}
class Husky extends Dog{
    public void bark() {
        System.out.println("I can bark and howl!!");
    }
    public void bark_2() {
        super.bark();// "super" calls the method from superclass.
    }
}
//main中
        Husky h1=new Husky();
        h1.bark();//I can bark and howl!!
        h1.bark_2();//I can bark

　　　　其实super也是一个引用，h1.bark_2()这行代码表示的引用为：h1-->Husky类-->调用bark_2()方法-->通过super引用找到Dog这个父类-->调用bark()方法。

1. 子类初始化过程，在子类构造其中，调用父类的构造器，生成一个父类对象，然后再执行子类构造器代码，生成子类对象。　

class Animal{
    private String name;
    private int age;
    Animal(int age, String name){
        this.age=age;
        this. name=name;
    }
    public int showAge() {
        return this.age;
    }
}
class Cat extends Animal{
    private String color; 
    //initialize the subclass' constructor by calling the superclass' constructor using "super"
    Cat(int age, String name, String color){
        super(age, name);//super calls the constructor from superclass.
        this.color=color;
    }
    public String getColor() {
        return this.color;
    }
    
    public void show() {
        System.out.println("age:"+this.showAge());
    }
}

2.  Super的使用场景：

• • 子类隐藏了父类的字段，例如子类字段和父类字段重名但是类型不同。

class Super{
    public String name="super";
}
class Sub extends Super{
    public int name=18;
    public void func() {
        System.out.println("sub:"+this.name);//sub:18
        System.out.println("super:"+super.name);//super:super
    }
}

• • 调用父类被覆盖方法（已讨论）
  • 子类构造器中使用super()来调用父类构造器（已讨论）

　　　　　　这里讨论一下隐藏和覆盖：子类和父类存在一模一样的静态方法（static修饰），称之为隐藏；存在一模一样非静态方法，称之为覆盖。

　　　　　　static不能和super，this共存，因为static是类级别的，而super和this是对象级别的，所以不能共存。

• 　Object根类

1. 所有对象都拥有Object类中的方法。
2. 方法包括：

• • protected void finalize()，这个是垃圾回收器调用的，做扫尾操作，我们可以不去调用
  • Class<?>getClass(),返回当前对象的数据类型。
  • int hashCode()， 返回对象的哈希码。哈希表中的存储位置由hashCode体现。
  • boolean equals(Object obj)。比较两个对象是否相等。
  • toString()方法。object类内默认的打印obj.toString 和打印obj的结果是一致的。所以建议覆盖toString()方法，返回我们关心的数据。