方法的重写

 super注意点：
     1. super调用父类的构造方法，必须在构造方法的第一个
     2. super必须只能出现在子类的方法或者构造方法中!
     3. super和 this不能同时调用构造方法!
 ​
 Vs this：
     代表的对象不同：
         this： 本身调用者这个对象
         super： 代表父类对象的应用
     前提
         this：没有继承也可以使用
         super：只能在继承条件下参能使用
     构造方法不同
         this()：调用的本类的构造方法
         super()：调用的父类的构造
 ​
 重写：需要有继承关系,子类重写父类的方法！
     1.方法名必须相同
     2.参数列表必须相同
     3.修饰符：范围可以扩大，不能缩小 ： public>Protected>Default>private
     4.抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
 ​
 重写，子类的方法和父类必要一致;方法体不同!
 为什么需要重写:
 1．父类的功能,子类不一定需要，或者不一定满足!
 Alt +Insert ; override;

 package com.oop;
 ​
 ​
 import com.oop.demo05.A;
 import com.oop.demo05.B;
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     //静态方法和非静态的方法区别很大
     //静态的方法： //方法的调用之和左边,定义的数据类型有关
     //非静态： 重写
     //重写的关键词是public  子类重写之后的权限不小于父类就好
     public static void main(String[] args){
 ​
 ​
         A a = new A();
         a.test();//A
 ​
         //父类的引用指向了子类
         B b = new A();//子类重写了父类的方法
         b.test();//B  //A
     }
 }

 package com.oop.demo05;
 ​
 //重写都是方法的重写，和属性无关
 public class B {
     public void test(){
         System.out.println("B=>test()");
     }
 }

 package com.oop.demo05;
 ​
 //继承关系
 public class A extends B {
 ​
     //Override 重写
     @Override //有功能的注释！
     public void test() {
         System.out.println("A=>test()");
     }
 }

*多态

动态编译： 类型：可扩展

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

有继承关系 子类重写父类方法

父类引用指向子类对象

注意:

多态是方法的多态，属性没有多态性。

instanceof （ 类型转换）~ 引用类型

 package com.oop;
 ​
 import com.oop.demo06.Person;
 import com.oop.demo06.Student;
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args){
 ​
         //一个对象的实际类型是确定的
         //new Person();
         //new Student();
 ​
         //可以指向的引用类型就不确定了：父类的引用指向子类
 ​
         //Student能调用的方法都是自己的或者继承父类的!
         Student s1 = new Student();
         //Person是父类型,可以指向子类，但是不能调用子类独有的方法
         Person s2 = new Student();
         Object s3 = new Student();
 ​
         //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
         s2.run();//子类重写了父类的方法，执行子类的方法
         s1.run();
         //s2.eat();//报错
         s1.eat();
     }
 }
 /*
 多态注意事项:
 1.多态是方法的多态，属性没有多态
 2．父类和子类，有联系类型转换异常! ClasscastException !
 3．存在条件:继承关系，方法需要重写，父类引用指向子类对象!Father f1 = new Son() ; I
 ​
     不能重写：
     1. static方法,属于类，它不属于实例
     2. final常量;
     3. private方法;
 ​
  */

 package com.oop.demo06;
 ​
 public class Person {
     public void run(){
         System.out.println("run");
     }
 }

 package com.oop.demo06;
 ​
 public class Student extends Person {
     @Override
     public void run() {
         System.out.println("rong");
     }
     public void eat(){
         System.out.println("吃吃吃，就知道吃！");
     }
 }