10 多态

ゞ浴缸里的玫瑰 2021-10-29 12:56 175阅读 0赞

1 多态
      2 polymorphism 
      3 就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。
      4 java中如何实现多态?使用多态的好处?
      5 引用变量的两种类型：
      6 编译时类型（模糊一点，一般是一个父类）
      7 public  void (Pet pet);
      8 由声明时的类型决定。
      9 运行时类型（运行时，具体是哪个子类就是哪个子类）
     10 由实际对应的对象类型决定。
     11 多态的存在要有3个必要条件：
     12                  要有继承，要有方法重写，父类引用指向子类对象
     13 方法的调用看引用  
     14 方法的执行看对象
     15 作用：
     16 多态
     17 提高了程序的可扩展性和可维护性提高代码复用性
     18 封装
     19 安全
     20 提高代码复用性
     21  继承
     22 提高代码复用性
     23 实现多态的步骤
     24     编写父类
     25    编写子类 子类重写父类方法
     26    运行时,使用父类的类型,子类的对象
     27 引用数据类型的类型转换 
     28 子类转换为父类：自动转换
     29 上转型对象不能操作子类新增的成员变量和方法。
     30 上转型对象可以操作子类继承或重写的成员变量和方法
     31 如果子类重写了父类的某个方法，上转型对象调用该方法时，是调用的重写方法。
     32 父类转换为子类：强制转换
     33 （绝不是做手术，而是父类的真面目就是一个子类，否则会出现类型转换错误）
     34 为了防止转换出错可以先用instanceof判断类型,再去转换
     35 package 引用数据类型转换;
     36 
     37 public class Test {
     38     public static void main(String[] args) {
     39         Pet pet = new Dog();
     40         pet.bark();
     41         
     42         //判断pet的引用指向的对象是否为Cat类型
     43         if (pet instanceof Cat) {
     44             Cat cat = (Cat)pet;
     45             cat.sleep();
     46         }else {
     47             Dog wangcai = (Dog)pet;
     48             wangcai.catchMouse();
     49         }    
     50     }
     51 }
     52 
     53 
     54 ackage 引用数据类型转换;
     55 
     56 public class Cat extends Pet{
     57     public void sleep() {
     58         System.out.println("猫在睡觉。。。");
     59     }
     60 }
     61 
     62 
     63 package 引用数据类型转换;
     64 
     65 public abstract class Pet {
     66     public void bark(){
     67         System.out.println("宠物发出叫声");
     68     }
     69 
     70 
     71 package 引用数据类型转换;
     72 
     73 public class Dog extends Pet{
     74 
     75     @Override
     76     public void bark() {
     77         System.out.println("won won won ....");
     78     }
     79     public void catchMouse() {
     80         System.out.println("狗在抓老鼠");
     81     }
     82 
     83 }
     84 
     85 接口  interface 
     86 为什么需要接口?接口和抽象类的区别?
     87 接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
     88 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
     89 接口的本质是契约，就像我们人类的法律一样。制定好后大家都遵守
     90 项目的具体需求是多变的，我们必须以不变应万变才能从容开发，此处的“不变”就是“规范”。因此，我们开发项目往往都是面向接口编程！
     91 接口不是类,接口是一种引用数据类型
     92 接口中的属性都必须是public static  final ,声明的时候可以省略   但是接口中的成员变量必须在声明的时候就进行初始化
     93 接口中的方法全都是  public abstract 的方法, public abstract可以省略不写
     94 接口不能被实例化
     95 实现类必须实现接口的所有方法
     96 类可以实现多个接口
     97 接口中不可以有构造方法
     98 接口相关规则：
     99 接口中所有方法都是抽象的。
    100 即使没有显式的将接口中的成员用public标示，也是public访问类型的
    101 接口中变量默认用 public static final标示，所以接口中定义的变量就是全局静态常量。
    102 
    103 可以定义一个新接口，用extends去继承一个已有的接口
    104 接口不能继承普通类
    105 可以定义一个类，用implements去实现一个接口中所有方法。
    106 可以定义一个抽象类，用implements去实现一个接口中部分方法。
    107 如何定义接口?
    108 格式：
    109 [访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {
    110 常量定义      //总是public   static  final
    111 方法定义       //总是：public   abstract
    112 }
    113 
    114 如何实现接口
    115 子类通过implements来实现接口中的规范
    116 接口不能创建实例，但是可用于声明引用变量类型。
    117 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。
    118 Java的类只支持单继承，接口支持多继承
    119 
    120 package interfacedemo;
    121 /**
    122  * 1，接口可以继承其他的接口,接口支持多继承
    123  * 2，一个类用implements 关键字去实现一个接口，一个类可以实现多个接口
    124  * 3，一个普通的类实现接口，则必须将接口中的所有抽象方法都实现
    125  * 4，一个抽象类实现接口，可以不实现接口中的抽象方法
    126  * @author tang
    127  */
    128 public interface MyInterface{
    129     //接口中可以定义成员变量，接口中的所有成员变量默认都是用public static final 修饰
    130     String name = "wangcai";
    131     //接口中所有的方法都是默认用public abstract 来修饰的
    132     public abstract void test01();
    133     public abstract void test02();
    134 }
    135 ckage interfacedemo;
    136 public class Person implements MyInterface{
    137     @Override
    138     public void test01() {
    139         System.out.println("test01");
    140     }
    141     @Override
    142     public void test02() {
    143         System.out.println("test02");
    144     }
    145 }
    146 
    147 C++支持多重继承，Java支持单重继承
    148 C++多重继承的危险性在于一个类可能继承了同一个方法的不同实现，会导致系统崩溃。
    149 Java中，一个类只能继承一个类，但同时可以实现多个接口，既可以实现多重继承的效果和功能，也避免的多重继承的危险性。
    150 
    151 class Student extents Person implements Runner，Flyer
    152 {…}
    153 注意：extends 必须位于implements之前
    154 
    155 开发打印机，墨盒：彩色，黑白，纸张类型：A4 B5，墨盒和纸张都不是打印机厂商生产的，打印机厂商需要兼容市场上的墨盒纸张
    156 package print;
    157 /**
    158  * 开发打印机，墨盒：彩色，黑白，纸张类型：A4 B5
    159  * 墨盒和纸张都不是打印机厂商生产的，打印机厂商需要兼容市场上的墨盒纸张
    160 
    161  * @author tang
    162  *
    163  */
    164 public class Test {
    165     public static void main(String[] args) {
    166         Print print = new Print();
    167         A4Paper a4 = new A4Paper();
    168         ColorBox box = new ColorBox();
    169         print.setPager(a4);
    170         print.setBox(box);
    171         print.print();
    172         
    173         B5Paper b5 = new B5Paper();
    174         BlackBox black = new BlackBox();
    175         print.setBox(black);
    176         print.setPager(b5);
    177         print.print();    
    178     }
    179 }
    180 
    181 
    182 
    183 package print;
    184 
    185 public class Print {
    186     private PaperInterface pager;
    187     private BoxInterface box;
    188 
    189     public void print() {
    190         System.out.println("正在使用" + box.showColor() + "的墨盒,在"
    191                 + pager.shosSzie() + "的纸张上打印");
    192     }
    193 
    194     public PaperInterface getPager() {
    195         return pager;
    196     }
    197 
    198     public void setPager(PaperInterface pager) {
    199         this.pager = pager;
    200     }
    201 
    202     public BoxInterface getBox() {
    203         return box;
    204     }
    205 
    206     public void setBox(BoxInterface box) {
    207         this.box = box;
    208     }
    209 }
    210 
    211 
    212 package print;
    213 
    214 public interface PaperInterface {
    215     String shosSzie();
    216 }
    217 
    218 
    219 
    220 package print;
    221 
    222 public interface BoxInterface {
    223     String showColor();
    224 }
    225 
    226 
    227 
    228 package print;
    229 
    230 public class ColorBox implements BoxInterface{
    231 
    232     @Override
    233     public String showColor() {
    234         // TODO Auto-generated method stub
    235         return "彩色";
    236     }
    237     
    238 }
    239 
    240 
    241 package print;
    242 
    243 public class BlackBox implements BoxInterface{
    244 
    245     @Override
    246     public String showColor() {
    247         // TODO Auto-generated method stub
    248         return "黑色";
    249     }
    250     
    251 }
    252 
    253 
    254 package print;
    255 
    256 public class B5Paper implements PaperInterface{
    257 
    258     @Override
    259     public String shosSzie() {
    260         // TODO Auto-generated method stub
    261         return "B5";
    262     }
    263 
    264 }
    265 
    266 
    267 package print;
    268 
    269 public class A4Paper implements PaperInterface{
    270 
    271     @Override
    272     public String shosSzie() {
    273         // TODO Auto-generated method stub
    274         return "A4";
    275     }
    276 
    277 }

转载于:https://www.cnblogs.com/meizhoulqp/p/11280463.html