Java_多态-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44738540/article/details/139085670

什么是多态 ?

多态是在继承/实现情况下的一种现象，表现为：对象多态，行为多态。

多态的具体代码体现

     
     People p1 =new Student();
     p1.run();

      People p2 = new Teacher();
      p2.run();

多态的前提
有继承/实现关系；存在父类引用子类对象；存在方法重写。
多态的一个注意事项
多态是对象、行为的多态，Java中的属性(成员变量)不谈多态。


   //People 类
   public class People {
      String name = "父类";
      public void run()
      {
        System.out.println("人会跑");
      }
   }

   //Teacher 类

 public class Teacher extends People{
      String name = "老师"；

      @override
       public void  run()
       {
           System.out.println("老师跑的比较慢~~~");
       }
       
 }


 //学生类

  public class Student extends People{
   
    String  name = "学生";

    @Override
    public void run()
    {
        System.out.println("学生跑的飞快~~~");
    }
  }

多态的好处

在多态形式下，右边对象是解耦合的，更便于扩展和维护。

   People p1 = new Student();
   p1.run();

定义方法时，使用父类类型的形参，可以接受一切子类对象，扩展性更强，更便利。

///老师类
    public class Teacher extends People{
       String name = "老师";
       @overrid
       public void run()
       {
          System.out.println("老师跑的比较慢~~~");
          
       }
       public void teach()
       {System.out.println("老师教授Java");
       }
    }

//学生类

 public class Student extends People()
 {
   String name = "学生";
   @Override 
   public void run()
   {
     System.out.println("学生跑的飞快~~~");
   }
   public void study()
   {
       System.out.println("学生好好学习~~~");
   }
 }
   
    public class Test2{
  
      public static void main(String [] args)
      {
          //目标：掌握使用多态的好处，以及多态下的类型转换的问题。
           // People p1 = new Student();
           // p1.run();
      }
   public static void go(People p)
   {
       System.out.println("开始-------------");
         p.run();
         p.teacher();//父类无法调子类独有方法
         p.study();
       System.out.println("结束------------");
       
   }
      
    }

多态下会产生一个问题，怎么解决？

多态下不能使用子类独有功能。

解决方法类型转换

自动类型转换父类变量名 = new 子类();
强制类型转换：子类变量名 = (子类) 父类变量；


      public  static void go(People p)
      {
      System.out.println("开始-----------");
      p.run();
      Student s = (Student) p ;//如果 p 为老师类型参数则出错
      s.study();
      System.out.println("");
      }




// 改正方法
    public static void go (People p)
    {
       System.out.println("开始---------------");
       p.run();
       if(p instanceof Student)
       {
          Student s = (Student) p;
          s.study();
       }else if(p instanceof Teacher)
       {
             Teacher t=(Teacher) p;
             t.teach();
       }
        System.out.println("结束---------------");
    }

强制类型转换的一个注意事项

存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
运行时，如果发现对象的真实类型于强转后的类型不同，就会报类型转换异常(ClassCastException)的错误出来。

   People p = new Teacher();
   Student s = (Student) p; //java.lang.ClassCastException

强转前，Java 建议

使用instanceof关键字，判断当前对象的真实类型，再进行强转。

  p instanceof Student

总结

1、多态使用有什么好处？存在什么问题？
可以解耦合，扩展性更强；使用父类类型的变量作为方法形参时，可以接收一切子类对象。
2、类型转换有几种形式？能解决什么问题？
自动类型转换、强制类型转换。
可以把对象转换成真正的类型，从而解决了多态下不能调用子类独有方法的问题。
3、强制类型转换需要注意什么？
存在继承/实现时，就可以进行强制类型转换，编译阶段不会报错。
但是，运行时，如果发现对象的真实类型与强转后的类型不同会报错(Class CastException)。
4、强制类型转换前？Java建议我们做什么事情？
使用instanceof判断当前对象的真实类型：对象instanceof类型。

final

final 关键字是最终的意思，可以修饰(类、方法、变量)

修饰类：该类被称为最终类，特点是不能被继承了。

修饰方法：该方法被称为最终方法，特点是不能被重写了。
修饰变量：该变量只能被赋值一次。

   public class FinalDemo{
       //目标 ：掌握final关键字的基本作用
       
       //变量有几种？ 局部变量  成员变量 (类变量，实例变量)
       final double a = 3.14;
       //a=3.15; //第二次赋值

      pay(0.8);
      E e = new E();
//e.name="李四";
//E.schoolName = "程序员"; //第二次赋值

 public static void pay(final double)
{  // z = 0.9  ; //第二次赋值
}

//注意事项
 final int a2=10;
 //a2= 23;


final int [] arr1 = {10,20,30};
//arr1= null; //数组地址不可以被重新赋值，但数组里的内容可以被重新赋值。
arr[1]=222;

   }
class E{
  final String name = "张三";
  final static String schoolName = "黑马";

}


//final的作用：修饰类不能被继承
// final class A{}
//class B extends A{}

class C{
    //final 修饰方法，方法不能被重写
    public final void test()
    {
       
    }
}


class D extends C{
    //@Override
    // public void test()
    {   }
}

final 修饰变量的注意

final 修饰基本类型的变量，变量存储的数据不能被改变。
final 修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象内容是可以改变的。

常量

使用了static final 修饰的成员变量就被称为常量。

作用：通常用于记录系统的配置信息。


public  class Constant{
    //常量 
     public  static String SCHOOL_NAME="传智教育"；
}

     public class FinalDemo2{
             public static void main(String [] args)
             {
                 System.out.println(Constant.SCHOOL_NAME);
             }
           }

使用常量记录系统配置信息的优势、执行原理

代码的可读性好，可维护性也更好。
程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。

抽象类的场景和好处

    

   public class Animal {
      private String name;
      public abstract void cry();
      public String getName()
      {
        return name;
      }
      public void setName(String name)
      {
          this.name=name;
      }
   }
    public class Cat extends Animal{
       private String name;
       private void cry()
       {
          System.out.println(getname()+"喵喵喵的叫~~");
       }
    
    }

  public class Dog extends Animal{
     private String name;
     public void cry()
     {
          System.out.println(name+"汪汪的叫~~~");
     }
     
  }
   
    public static void main(String [] args)
    {
        //目标：掌握抽象类的使用场景和好处
        Animal a = new Dog();
        a.cry();
    }

1、抽象类的应用场景和好处
两种主要的应用场景，一种是：用抽象类，我们可以把子类中的相同代码，包括方法签名都抽上来，这样能更好的支持多态，以提高代码的灵活性。
一种是：反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去继承实现，以方便系统的扩展。

模板方法设计模式

   public class Test {
        public static  void main(String []args)
        {
        //目标:搞清楚模板方法设计模式能解决什么问题，以及怎么写
         A a = new A();
         a.sing();
        }
   }

   public abstract class C
   {
       public void sing()
       {
           System.out.println("唱一首你喜欢的歌");
           doSing();
           System.out.println("唱完了！");
       }
       public abstract doSing();
     
   }
   public class A extends C{
      @Override
       public void doString()
       {
          System.out.println("我是一只小小鸟")
       }
   }

1、模板方法设计模式解决了什么问题

解决方法中存在重复代码的问题

2、模板方法设计模式应该怎么写

定义一个抽象类
在里面定义两个方法，一个是模板方法：放相同的代码里，一个是抽象方法：具体实现交给子类完成。

3、模板方法建议使用什么关键字修饰？为什么
建议使用final 关键字修饰模板方法。

多学一招：建议使用final关键字修饰模板方法，为什么？
模板方法是给对象直接使用的，不能被子类重写。
一旦子类重写了模板方法，模板方法就失效了。

接口

认识接口
Java 提供了一个关键字interface，用这个关键字我们可以定义出一个特殊结构：接口。

Java 提供了一个关键字interface，用这个关键字我们可以定义出一个特殊结构：接口。

public interface 接口名
{
    //成员变量(常量)
    //成员方法(抽象方法)
    
}

注意：接口不能创建对象；接口是用来被类实现(implements)的，实现接口的类称为实现类。

修饰符 class 实现类 implement 接口1，接口2，接口3，...{
          //具体实现
           }

一个类可以实现多个接口(接口可以理解成干爹)，实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

   public class Test{

     public static void main(String []args)
     {
         //目标：认识接口
         System.out.println(A.SCHOOL_NAME);
        
         //A a = new A();
     }


   }


public class D implement B,C
{
    @Override
     public void testb1()
     {
     
     }
     @Override
     public void testb1()
     {
     
     }
     
     @Override
     public void testc1()
     {
     
     }
     @Override 
     public void testc2()
     {
     
     }
}


public interface B {
   void testb1();
   void testb2();
}

public interface C
{
  void test1();
  void test2();
}

接口的好处(重点)
弥补了单类继承的不足，一个类同时可以实现多个接口

让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。

   public class Test()
   {
      public static void main(String []args)
      {
        Driver s = new A();
        s.drive();

        Driver d = new B();//程序员灵活方便切换各种实现 
        d.driver();

        Animal a = new Cat();//父类类型指向子类对象
        a.cry();


      }
      
   }

1、使用接口有啥好处，第一个好处是什么？

可以解决类单继承的问题，通过接口，我们可以让一个类有一个亲爹的同时，还可以找多个干爹去扩展自己的功能。
2、为什么我们要通过接口，也就是去找干爹，来扩展自己的功能呢？

因为通过接口去找干爹，别人通过implements接口，就可以显性的知道你是谁，从而也就可以放心的把你当作谁来用了。
3、使用接口的第二个好处是什么？

一个类我们说可以实现多个接口，同样，一个接口也可以被多个类实现的。这样做的好处是我们的程序就可以面向接口编程了，这样我们的程序员就可以很方便的灵活切换各种业务实现。

接口的应用案例：班级学生信息管理模块的开发

请设计一个班级学生的信息管理模块：学生的数据有：姓名、性别、成绩

功能1：要求打印出全班学生的信息；功能2：要求打印出全班学生的平均成绩。

注意！以上功能的业务实现是有多套方案的，比如：

第一套方案：能打印出班级全部学生的信息；能打印班级全部学生的平均分。

第二套方案：能打印出班级全部学生的信息(包含男女人数)；能打印班级全部学生的平均分(要求是去掉最高分、最低分)。要求：系统可以支持灵活的切换这些实现方案。

   public class ClassManager{
       private ArrayList<Student> students = new ArrayList();
       private StudentOperator studentOperator = new StudentOperatorImp1();

   public ClassManager()
   {
      students.add(new Student("迪丽热巴",'女',99));
      students.add(new Students("古力娜扎",'女',100));
      students.add(new Student("马儿扎哈",'男',80));
      students.add(new Student("卡尔扎巴",'男',80))
   }  
 //打印全班全部学生的信息
    public void printInfo()
    {
    
    }
 //打印全班全部学生的平均分
   public void printScore()
   {
      
   }         
      
   }


  public interface StudentOperator
  {
    void printAllInfo(ArrayList<Student> students);
    void printAverageScore(ArrayList<Student> students);
    
  }


public class StudentOperatorImpl1 implements StudentOperator {
   @Override
   public void printAllInfo(ArrayList<Student> students){
      System.out.println("-------全班全部学生信息如下-----------");
      for(int i=0;i<student.size();i++)
      {
         Student s = students.get(i);
         System.out.println("姓名："+s.getName() + ",性别"+s.getSex()+",成绩"+s.getScore());
      }
      System.out.println("---------------------");
   }
   @Override 
   public void printAverageScore(ArrayList<Student> students)
   {
     double allSocre = 0.0;
     for(int i =0;i<students.size();i++)
     {
        Student s = student.get(i);
        allSocore +=s.getSocre();
     }
      System.out.println("平均分："+(allScore)/student.size());
   }

}

接口的其他细节：JDK8 开始，接口中新增的三种方法。


   public class Test()
   {
     // 目标掌握接口的新增的三种方法形式。
     //  实例方法：对象方法，必须使用实现类的对象来访问
     public static void main(String[] args)
     {
        B b = new B();
        b.test1();
        // b.text2();
        A.test3();
     }
   }

public interface A {
    
    /**
    *  1.默认方法：必须使用default修饰，默认会被public    修饰 
    * 实例方法：对象方法，必须使用实现类的对象来访问。
    *
    */

     default void test1()
     {
       System.out.println("==默认方法==");
       test2();
     }
  /*
   * 2、私有方法：必须使用private修饰。(JDK 9 开始支持的)    
   *  实例方法对象方法。
  */
    private void test2()
    {
       System.out.println("==私有方法==");
       
    }
    /*
    *  3.静态方法：必须使用static修饰，默认会被public修饰。     
    *
    */
    static void test3()
    {
     System.out.println("==静态方法==");
     
    }
}

总结

1、JDK 8 开始，接口中新增了那些方法？

默认方法：使用default 修饰，使用实现类的对象调用。
静态方法：static修饰，必须用当前接口名调用
私有方法：private 修饰，jdk9开始才有的，只能在接口内部被调用。
他们都会默认被public修饰。
2、JDK8 ，接口中为啥要新增这些方法？

增强了接口的能力，便于项目的扩展和维护。

接口的其它细节：接口的多继承、使用接口的注意事项

 public class Test{
    public static void main(String [] args)
    {
       //目标：理解接口的多继承
    }
 }
 interface A{}
 interface B{}
 interface C{}

//接口是多继承的
interface D extends C,B,A
{
}
class E implements D{
   @Override 
   public void test1()
   {
   
   }
   public void test2()
   {
   
   }

}

接口多继承的作用
便于实现类去实现

接口其它注意事项

1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
3、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

   public class Test2()
   {
        public static void main(String []args)
        {
        


              
        }
   }
   //1、一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。
   interface I{
   void test1();
   }
   interface J
   {
        String test1();
   }
  interface K extends I,J {
  
  }

//2、一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。
// class E implements I,J{
   
//}


//3、一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。

 class Fu
 {
    public void run()
    {
      System.out.println("==父类的run方法执行了==")
    }
 }
 interface IT{
    default void run()
    {
    System.out.println("==接口IT中的run方法执行了===")
    }
 
 }
 class Zi extends Fu implements IT {
 
 }
 //一个类实现了多个接口,多个接口存在同名的默认方法，可以不冲突，这个类重写该方法

  interface It1{
    default void test()
    {
      System.out.println("IT1");
     }
  }
  interface It2{
    default void test()
    {
      System.out.println("IT2");
    }
  }
  class N implements It1,It2{
     @Override 
     public void test()
     {
      System.out.println("自己的");
     }
  }