三大特性：(经典代码）

 1.定义一个Person类

public class Person {
    
    private String name;  // 姓名
    private int age;      // 年龄
    
    public Person() {    // 无参构造
        super();
    }
    public Person(String name, int age) {  // 有参构造
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
   
    
    @Override  // 重写toString()方法
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    public void show() {
        System.out.println("Person类中的show()方法");
    }
    
    
    
}

 2.写一个Student 学生类

public class Student extends Person {
    private int id;   // 学号
    
    public Student() {  // 无参构造
        super();
    }

    public Student(String name, int age,int id) {   // 有参构造
        
        super(name,age);  // 调用父类中的构造方法
        this.id = id;
    }


     //提供供外界访问的 get/set()方法
    public int getId() {
        return id;
    }


    public void setId(int id) {
        this.id = id;
    }

     @Override
    public String toString() {
        return "Student [id=" + id +" name="+getName()+" age="+getAge()+ "]";
    }


    @Override
    public void show() {
        System.out.println("Student类中重写后的show()方法");
         
    }
}

---

3.写一个 Teacher 教师类

package com.monkey1024;

public class Teacher extends Person {
    
    private double salary;  // 工资

    public Teacher() {
        super();
    }

    public Teacher(String name, int age,double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Person [name=" + getName() + ", age=" + getAge() + ", salary="+salary+"]";
    }

    @Override
    public void show() {
         System.out.println("Teacher类中重写后的show()方法");
    }

}

---

测试类：

public class Test {

    public static void main(String[] args) {
        
        // 创建一个学生类
        Student student = new Student("小茅棚",23,01);   // 姓名，年龄，学号
        System.out.println(student);
        student.show();
        System.out.println("--------------------");
        
        // 创建一个教师类
        Teacher teacher = new Teacher("马云",55,88888.8); // 姓名， 年龄， 工资
        System.out.println(teacher);
        teacher.show();

    }

}

控制台结果：

Student [id=1 name=小茅棚 age=23]
Student类中重写后的show()方法
--------------------
Person [name=马云, age=55, salary=88888.8]
Teacher类中重写后的show()方法

重点：

子类继承父类，

若子类 没有重写 父类的方法，则 运行阶段 调用从父类中继承的对应方法  -----如该程序中的，show()方法

若子类 重写了父类中的方法， 则 运行阶段 调用自己重写之后的该方法。

注意:

无论是否重写父类的方法，在编译阶段 程序统一都是调用父类中的该方法。

(这就是为什么，虽然子类中对父类方法进行了重写，但是一旦删除父类中被重写的方法，程序立马报错的原因）

---

 测试类中写如下内容：

public class Test {
    
    // 定义一个静态的print()方法，既能打印人类的功能，又能打印老师的功能 还能能打印学生的功能

    public static void print(Person p) {    // 形参要的是是一个Person类型
        p.show();
    }

    public static void main(String[] args) {
        Test.print(new Person());
        System.out.println("--------------");
        Test .print(new Student());
        System.out.println("--------------");
        Test.print(new Teacher());
        
     

    }

}

控制台结果：

Person类中的show()方法
--------------
Student类中重写后的show()方法
--------------
Teacher类中重写后的show()方法

 public static void print(Person p) {      

该方法中要求的是一个 Person类型的引用作为方法的形参

在main()方法的代码中，把Person类的子类 Student类的引用 和 Teacher类的引用作为形参 传递 过去，并不报错。且运行阶段 调用的是他们各自的方法。

---

代码改进：

     如 Person类中，有 name 和 age属性，其中age代表的是年龄。

     生活经验告诉我们，年龄通常不能小于0，且通常不会超过150岁。

    但是在以上的代码中，将age设置为负数 或 888，程序也正常运行。这显然是不符合逻辑的。

改动代码：

在setAge()方法中 对传入的 age值做合理值 判断

 public void setAge(int age) {
        if(age>0 && age<=150)   // 判断条件
        this.age = age;
        else
            System.out.println("年龄输入不符合常理....");
    }

在构造方法中将 this.age= age; 改为setAge(age);

public Person(String name, int age) {  // 有参构造
        super();
        this.name = name;
        // this.age = age;
        setAge(age);    
    }

测试：

System.out.println(new Person("james",888));

控制台打印结果：

年龄输入不符合常理....
Person [name=james, age=0]

 同理，像salary、id 等属性 都最好 传值前做合理值判断，来避免发生夸张不合常理的运算结果

---

让程序产生异常：

若传入不符合常理的age值，当然也可以使用暴力点的方式处理问题直接让程序产生异常     

1.先自定义一个异常：AgeException 年龄值异常

// 自定义一个异常： id异常
public class AgeException extends Exception {
     
    public AgeException() {   // 无参构造
        
    }
    
   public AgeException(String str) {   // 有参构造
        super(str);
    }
    
    

}

2.Person类中修改代码：setAge()方法

public void setAge(int age) throws Exception {
        if(age>0 && age<=150)
        this.age = age;
        else
            // System.out.println("年龄输入不符合常理....");
            throw new AgeException("年龄输入不符合常理.....");    // 这里指定要抛出AgeException异常类型
    }

3.将程序报警的每个地方进行，异常的抛出 或 异常的捕获 处理

4.test代码:

public class Test {
    
 public static void main(String[] args) throws Exception {    // 异常的向上抛出
     
     Student student = new Student("Bob",-1,1002);   // 年龄值 传递了一个 -1
     System.out.println(student);
     System.out.println("-------------");
}

     

控制台打印结果：

Exception in thread "main" com.monkey1024.AgeException: 年龄输入不符合常理.....
    at com.monkey1024.Person.setAge(Person.java:32)
    at com.monkey1024.Person.<init>(Person.java:15)
    at com.monkey1024.Student.<init>(Student.java:16)
    at com.monkey1024.Test.main(Test.java:7)

---

还有注意：

super();   // 写在子类构造方法体的首行，表示 调用父类中的无参构造

super(属性类型1，属性值1, 属性类型2 属性值2...);  //表示调用父类中对应的有参构造

super.父类方法();      // 写在子类重写之后的方法体内，表示 调用父类中的该方法

this关键字 表示 --"当前对象"    谁调用该方法，this 代表的就是 谁这个对象

---

多态：

            父类类型的引用 指向 子类类型的对象      ===>  形成多态！！！

 测试代码：

public class Test {
    
 public static void main(String[] args) {
     
     //Person类型的引用p 指向 Student类型的对象 形成 多态
     Person p = new Student();
     p.show();
     
     
    //Person类型的引用p 指向 Teacher类型的对象 形成 多态
     p = new Teacher();
     p.show();
     
}

}

控制台结果：

Student类中重写后的show()方法
Teacher类中重写后的show()方法

---

分析：

 p.show();

 虽然是Person类型的引用p调用show()方法，但是运行出来的结果表明：执行的是子类各自的重写之后的show()方法

其中：

            父类类型的引用 指向 子类的对象， 子类 is a 父类

           Person p = new Student();   此时，发生了 Student类型 向 Person类型的自动类型转换 

子类 is a 父类，父类有的方法，子类也一定可以调用。

---

产生问题：那么父类可以调用子类中的方法吗？

 Person ps = new Student("Bob",24,1002);
     ps.show();
     
     // ps.getId();       编译报错，是因为ps是Person类型的引用。父类类型的引用不能直接调用子类类型的方法

     Student ts=(Student)ps;  //做了强制类型转换：将Person类型的ps 强转为 Student类型
     int res = ts.getId();     
     System.out.println(res);
 
     
}

通过上面代码可以知道：
   父类类型的引用 要想访问 子类特有的方法，则需要进行 强制类型转换才能访问。  （父类引用直接访问子类属性则编译报错）

---

再思考一问题：若把 Person类型的引用 强制 转换 为String类型，再调用String类中length()方法能不能成功？

res = ((String)ps).length();  // 编译报错

报错的原因：String类 与 Person类之间，不存在 父子类 关系！！！

---

再思考一问题：那么是不是只要存在父子类关系，父类的引用就可以转换成任意的子类类型后也能执行成功呢？

public class Test {
    
  public static void main(String[] args) {
     
     Person ps = new Student("Bob",24,1002);   // ps指向的是Student类型的对象
     ps.show();
     Student ts=(Student)ps;    // 编译成功
     int res = ts.getId();
     System.out.println(res);  // 且运行成功
     
     System.out.println("-------------");
     
     Teacher t=(Teacher)ps;   // 编译阶段 成功
 
     
  }
}

控制台结果：

Student类中重写后的show()方法
1002
-------------
Exception in thread "main" java.lang.ClassCastException: com.monkey1024.Student cannot be cast to com.monkey1024.Teacher
    at com.monkey1024.Test.main(Test.java:15)

 从输出结果发现：产生了java.lang.ClassCastException，类型转换异常

   Teacher t=(Teacher)ps; // 编译阶段 成功
   这行代码能够成功通过编译阶段， 但是在运行阶段报错了。
 
编译通过-----因为Teacher类 与 Person类之间确实存在父子关系，
运行报错----- Person ps = new Student("Bob",24,1002); ps真正指向的是Student对象，并不是Teacher。其实进行的是Student类型 转 Teacher类型，肯定报错！
ps真正指向的是Student类型的对象，而非Teacher类型的对象。


所以，代码在运行阶段的错误风险更高。为了避免类型转换异常的发生，添加判断：判断ps引用真正 指向 的对象是否为 Teacher类型即可！

public class Test {
    
 public static void main(String[] args) {
     
     Person ps = new Student("Bob",24,1002);
     ps.show();
     Student ts=(Student)ps;    // 编译成功
     int res = ts.getId();
     System.out.println(res);  // 且运行成功
     
     System.out.println("-------------");
     
     if(ps instanceof Teacher) {     // instanceof关键字 判断 ps真正的指向类型是不是Teacher类型
         Teacher t=(Teacher) ps;

         System.out.println("ps可以放心地转换为Teacher类型");
         
     }else {
         System.out.println("ps不能强制转换为Teacher类型");
     }
     
 
     
}

}

运行结果:

Student类中重写后的show()方法
1002
-------------
ps不能强制转换为Teacher类型

---

instance关键字的作用

---