面向对象04

方法重载

 重写：需要有继承关系，子类重写父类的方法
     1、方法名必须相同
     2、参数列表必须相同
     3、修饰符：范围可以扩大，但不能缩小      public》protected》Default》private
     4、抛出的异常：范围可以被缩小，但不能扩大       ClassNotFoundException《Exception（大）
     
     重写，子类的方法和父类必须一致，方法体不同
     
     为什么需要重写：
         1、父类的功能，子类不一定需要，或者不一定满足
         Alt+Insert    ： Override

 

 

 package java_oop.demo05;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 19:44
  */
 ​
 public class A extends B{
 //    public static void test(){
 //        System.out.println("A=>test()");
 //    }
 ​
     //Override  重写
     @Override       //注释：有功能的注释
     public void test() {
 //        super.test();
         System.out.println("A=>test()");
     }
 }
 ​
 ​
 /**
  * //静态方法输出结果
  * A=>test()
  * B=>test()
  *
  * //@Override
  * //super.test();输出结果
  * B=>test()
  * B=>test()
  *
  * //@Override
  * //System.out.println("A=>test()");输出结果
  * A=>test()
  * A=>test()
  */
 ​
 /**
  * //main方法
  * //静态方法和非静态方法区别很大
  *     //静态方法：方法的调用只和左边，定义的数据类型有关
  *     //非静态方法：重写
  *     public static void main(String[] args) {
  *
  *         A a = new A();
  *         a.test();
  *
  *         //父类的引用指向了子类
  *         B b = new A();      //子类重写了父类的方法
  *         b.test();
  *
  *     }
  */

 package java_oop.demo05;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 19:44
  */
 //重写都是 方法的重写，与属性无关
 public class B {
 //    public static void test(){
 //        System.out.println("B=>test()");
 //    }
 ​
     public void test(){
         System.out.println("B=>test()");
     }
 }

 

 

多态

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

• 一个对象的实际类型是确定的，但可以指定对象的引用的类型有很多（父类，有关系的类）

• 多态存在的条件

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态

• instanceof （类型转换） 引用类型 判断一个对象是什么类型

 

 

 package java_oop.demo06;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 20:16
  */
 ​
 public class Person {
     public void run(){
         System.out.println("run");
     }
 ​
 }
 ​
 ​
 /**
  * 多态注意事项：
  *      1、多态是方法的多态，属性无多态
  *      2、父类和子类，有联系  类型转换异常ClassCastException
  *      3、存在条件：继承关系，方法需要重写，父类的引用指向子类对象  Father f1  = new Son（）；
  *
  *                              不能重写
  *                              1、static方法，属于类，不属于实例
  *                              2、final 常量
  *                              3、private 方法；
  */
 ​
 /**
  * //main方法
  * 
  * public static void main(String[] args) {
  *         //一个对象的实际类型是确定的
  * //        new Student();
  * //        new Person();
  *
  *         //可以指向的类型就不确定了:父类的引用指向子类
  *
  *         //Student能调用的方法都是自己的或者继承父类的
  *         Student s1 = new Student();
  *         //Person父类型，可以指向子类，但是不能调用子类独有的方法
  *         Person s2 = new Student();
  *         Object s3 = new Student();
  *
  *         //对象能执行哪些方法，主要看对象左边类型！
  *         s2.run();   //重写之前输出run；Override后，子类重写父类的方法，执行子类的方法
  *         s1.run();
  *
  *         s1.eat();
  * //        s2.eat();     //报错，
  *     }
  */

 package java_oop.demo06;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 20:16
  */
 ​
 public class Student extends Person{
     @Override
     public void run() {
         System.out.println("son");
     }
 ​
     public void eat(){
         System.out.println("eat");
     }
 }

 

 

• instanceof

 

 

• main

 public static void main(String[] args) {
         //类型之间的转换： 父类  子类
         //高                 低
         Person student =new Student();
 ​
         //将student（此时为Person类型）这个对象转换为Student类型，我们就可以直接使用Student类的方法
 //        Student s = (Student)student;
 //        s.go();
 ​
         ((Student)student).go();        //两句合为一句
 ​
         //子类转父类，可能丢失自己本来的方法
         Student student1 = new Student();
         student1.go();
         Person person = student;
     }

• Person

 package java_oop.demo07;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 20:55
  */
 ​
 public class Person {
     public void run(){
         System.out.println("run");
     }
 }

• Teacher

 package java_oop.demo07;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 20:56
  */
 ​
 public class Teacher extends Person{
 }

• Student

 package java_oop.demo07;
 ​
 /**
  * @author IT_Jay
  * @date 2022/1/25 20:55
  */
 ​
 public class Student extends Person{
     public void go(){
         System.out.println("go");
     }
 }
 ​
 ​
 /**
  *     public static void main(String[] args) {
  *         //Object >> Person  >> Student
  *         //Object >> Person  >> Teacher
  *         //Object >> String
  *
  * //        System.out.println(X instanceof Y);       //能否编译取决于X、Y是否有父子关系
  *
  *         Object object = new Student();
  *         System.out.println(object instanceof Student);      //true
  *         System.out.println(object instanceof Person);       //true
  *         System.out.println(object instanceof Object);       //true
  *         System.out.println(object instanceof Teacher);      //false
  *         System.out.println(object instanceof String);       //false
  *
  *         System.out.println("==============================================");
  *
  *         Person person = new Student();
  *         System.out.println(person instanceof Student);      //true
  *         System.out.println(person instanceof Person);       //true
  *         System.out.println(person instanceof Object);       //true
  *         System.out.println(person instanceof Teacher);      //false
  * //        System.out.println(person instanceof String);       //false   编译错误
  *
  *         System.out.println("==============================================");
  *
  *         Student student = new Student();
  *         System.out.println(student instanceof Student);      //true
  *         System.out.println(student instanceof Person);       //true
  *         System.out.println(student instanceof Object);       //true
  * //        System.out.println(student instanceof Teacher);      //false      编译错误
  *     }
  *
  */