方法的重写与多态

回顾昨天的内容

       public static text1{
          public static void main(String [] args){
               //方法的调用只和左边，定义的数据类型有关
                A a = new A();
                a.text();
                //输出的是a=>text
                
                //父类的引用指向了子类
                B b = new B();
                b.text();
                //输出的是b=>text
}
}

      public class A extends B{
          public static void text(){
              System.out.println("a=>text");
}
}

        public class B{
           public static void text(){
               System.out.println("b=>text");
}
}

简单理解：方法的调用只和左边的数据类型有关，和new的东西没有什么关系

       public class text1{
       //静态的方法和非静态的方法区别很大!
         //静态方法： //方法的调用只和左边，定义的数据类型有关

         //非静态:重写
            public static void main(String [] args){
              A a = new A();
              a.text();
              //输出的是a=>text

              B b = new B();
              b.text();
              //输出的是b=>text

}

}

        public class A extends B{
            public void text(){
                System.out.println("a=>text");
}      
}

         //重写都是方法的重写，和属性无关
         public class B{
           public void text(){
         System.out.println("b=>text");

}
}

重写：需要有继承关系，子类重写父类方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大； public>protected>Default>private
4、抛出的异常：范围，可以被缩小，但不能扩大;ClassNotFoundExcepetion—>Exception(大)

重写，父类的方法和父类必须要一致：方法体不同！
子类重写了父类的方法就要执行子类的方法！

为什么需要重写：
1、父类的功能，子类不一定需要，或者不一定满足！
Alt + Insert: override;

多态

1、即同一个方法可以根据发送对象的不同而采用多种不同的行为方式
2、一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

3、多态存在的条件
①有继承关系
②子类重写父类的方法
③父类引用指向子类对象

4、注意：多态是方法的多态，属性没有多态
5、instanceof

        public class text1{
           public static void main(String []args ){
                //一个对象的实际类型是确定的
                //new student();
                //new person();

                //可以指向的引用类型就不确定了：父类的引用指向了类           
                
                //student 能调用的方法都是自己的或者继承父类的！
                student s1 = new student;
                //person 父类型 可以指向子类，但是不能调用子类独有的方法
                person s2 = new student;
                object s3 = new student;


               s1.run();
               s2.run();

               //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
              s1.eat();
              ((student) s2).eat();//子类重写了父类的方法，执行子类的方法
}
}

       public class person{
           
           public void run(){
             System.out.println("run");
}
}

         public class student extends person{

             public void run(){
                System.out.println("run");                
}
             public void eat(){

             System.out.println("eat");
}
}

多态的注意事项：
1、多态是方法的多态，属性没有多态
2、父类和子类，有联系 类型转换异常！ ClassCastException!
3、存在条件：继承关系： 方法需要重写，父类引用指向子类对象！
Father f1 = new son();
1、static 方法，属于类，它不属于实例
2、final 常量
3、private方法：不能重写