1.子类对象访问成员的顺序：先子类，再父类。 ----如果子类存在就是使用子类的，

不会访问父类。

2.子类对象的构造顺序: 先父类，再子类。

3.如果一个类显式声明从哪个类继承，则父类就是哪个类；如果没有显式声明，那么

Java会帮自动让该类继承Object,因此Object是Java中所有类的根。

4. super(...), this(...) 这两种方法只能在构造方法中调用，且必须是在第一句，还有这

两种方法是互斥的(有一个，就不能有另外一个)。
  
5. 子类和父类相同的方法叫覆盖方法。子类与父类方法中，一个是静态，另一个是非静

态，这种情况不能形成覆盖方法，且Java不允许出现这种情况。

6. 子类的覆盖方法权限不能低于父类的  ---覆盖方法的一个约束: 前(权限)不能小，

后(异常)不能大。

 

7.子类的构造方法中，一定会在第一句调用super(...)。如果我们手动写了这一句，

就是调用该句；如果我们没写,Java会自动帮我们加:super()。

package cn.hncu.para2.v1;

public class Person{
  private String name;
  private int age;
  private static int count;
  
  
  public Person(String name, int age) {
     = name;
    this.age = age;
    count++;
  }
  public Person() {
    this("NoName",0);
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
     = name;
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  @Override
  public String toString() {
    return name + ", " + age;
  }
  
  public static void howMany(){
    System.out.println( count+ " 个人!");
  }
  
  
}
package cn.hncu.para2.v1;

/*
 * 1.子类对象访问成员的顺序：先子类，再父类。 ----如果子类存在就是使用子类的，不会访问父类。
 * 2.子类对象的构造顺序: 先父类，再子类。
 * 
 * 3.如果一个类显式声明从哪个类继承，则父类就是哪个类；如果没有显式声明，那么Java会帮自动让该类继承Object,因此Object是Java中所有类的根。
 * 
 * 4. super(...), this(...) 这两种方法只能在构造方法中调用，且必须是在第一句，还有这两种方法是互斥的(有一个，就不能有另外一个)
 * 
 * 5. 子类和父类相同的方法叫覆盖方法。子类与父类方法中，一个是静态，另一个是非静态，这种情况不能形成覆盖方法，且Java不允许出现这种情况。
 * 
 * 6. 子类的覆盖方法权限不能低于父类的  ---覆盖方法的一个约束: 前(权限)不能小，后(异常)不能大
 * 
 */

public class Student extends Person{
  String speciality;
  private static int count; //隐藏
  
  public Student(String name, int age, String speciality){
    //this.setName(name);
    super(name,age);// super(...)是用于构造父类对象的，且必须在第一句
    this.speciality = speciality;
    count++;
  }
  
  public Student(){
    /*子类的构造方法中，一定会在第一句调用super(...)。
     * 如果我们手动写了这一句，就是调用该句；如果我们没写,Java会自动帮我们加:super()。
     */
    super();//这一句我们不写，Java会帮我们加
    count++;
  }
  
  public String getSpeciality() {
    return speciality;
  }

  public void setSpeciality(String speciality) {
    this.speciality = speciality;
  }

  //覆盖方法，子类的权限不能低于父类
  public String toString() {
    return "Student: "+super.toString()+","+this.speciality;
  }
  
  
  public static void howMany(){
    System.out.println(count+" 个学生!");
  }
  
}
package cn.hncu.para2.v1;

public class Teacher extends Person{
  private String research;
  private static int count;
  
  public Teacher(String name, int age, String research){
    //super(name,age);
    this.research = research;
    count++;
  }
  public Teacher(){
    this(null,0,null);
  }
  public String getResearch() {
    return research;
  }
  public void setResearch(String research) {
    this.research = research;
  }
  
  @Override
  public String toString() {
    return "Teacher:"+super.toString()+"," + research;
  }
  
  public static void howMany(){
    System.out.println(count+" 个老师!");
  }
}
package cn.hncu.para2.v1;

public class Demo {

  public static void main(String[] args) {
    Person p = new Person("Jack",22);
    System.out.println( p.toString() );  //p.toString()
    System.out.println(p.hashCode());
    
    Student s = new Student();
    //="Tom";
    //s.age=23;
    s.setName("Tom");
    s.setAge(23);
    System.out.println(s); //s.toString()
    
    Student s2 = new Student("张三",25,"Computer");
    System.out.println(s2.toString()); //
    
    
    Teacher t = new Teacher("Rose", 28, "Programming");
    System.out.println(t);
    
    System.out.println("----------------");
    Teacher t2 = new Teacher();
    Teacher.howMany();
    Student.howMany();
    Person.howMany();
    
  }

}