回顾oop面向对象的编程 以及多态

OPP(Oriented Process Programming)
* 面向过程编程
* 关注的是你要完成的事情本身。
* 所有的设计思路都是围绕完成具体事情设计的。
* 为了完成相应的事情，你会分为
* 第一步
* 第二步
* …
* 第n步
* 完成
*
* 要把大象装冰箱。
* 第一步：把冰箱门打开
* 第二步：把大象放进去
* 第三步：把冰箱门关上
*
*
* OOP(Oriented Object Programming)
* 面向对象编程
* 同样也是完成具体的事情。
* 但是你关注的重心不是这件怎么一步步完成？
* 而是在整个事情进行中，都有哪些对象参与
* 这些参与的对象需要具有什么样的功能或特征。
* 换句话说就是关注类的设计
* 把大象装进冰箱。
* 需要有冰箱
* 需要有大象
* 需要有人
*
* public class 冰箱{
* 此处省略属性，长宽高，功率
* 开门（）{ 。。。}
* 关门（）{。。。}
* 冷冻（）{。。。}
* }
*
* public class 大象{
* 此处省略属性，身高，体重，年龄
* 行走（）{。。。}
* 吃饭（）{。。。}
* }
*
* public class 人{
* 此处省略属性，性别，姓名
* 打开（冰箱）{
* 冰箱.开门（）;
* }
*
* 关闭（冰箱）{
* 冰箱.关门（）
* }
*
* 驱赶（大象）{
* 大象.行走（）
* }
* }
*
* public class Test{
* main{
* 大象 a = new 大象()
* 冰箱 b = new 冰箱()
* 人 c = new 人()
* 人 d = new 人()
*
* c.打开（b）;
* d.驱赶（a）;
* c.关闭（b）;
*
* }
* }
*
* */

• 类：对事物的抽象和提炼，可以把共性的信息提炼出来，做成一个模板。
  * 学生：
  * 崔晨燚 姓名 性别 身高 ；睡觉，吃饭，打游戏
  * 娄亚峰 姓名 性别 身高 ；睡觉，吃饭，打游戏
  * 都具有姓名 性别 身高，都可以睡觉，吃饭，打游戏
  * 把提炼的特征 变为类的属性
  * 把提炼的行为 变为类的方法
  *
  * public class Person{
  * private String name;
  * private String sex;
  * private double height;
  *
  * public void eat(String food){
  * System.out.println(“正在吃”+food);
  * }
  * public void sleep(){
  * System.out.println(“睡觉”);
  * }
  * public void playGames(String game){
  * System.out.println(name + “正在玩”+game);
  * }
  *
  * }
  *
  * 对象:是类的具体实例。
  * 既然对象是类的具体实例，想要使用对象，第一件事就是
  * 实例化对象（创建对象）
  * Person p = new Person();
  * p.eat(“炸鸡”);
  * p.playGames(“扫雷”);
  *
  * Person p1 = new Person();
  * p1.playGame(“LOL”);
  *
  * 使用面向过程表示一个完整的事物，比较麻烦。
  * 而且无法给这个事物添加功能
  *
  * /
  /
  String[] names = {“崔晨燚”,“娄亚峰”};
  String[] sexes = {“男”,“男”};
  double[] heights = {1.75,1.76};

  for(int i = 0; i < names.length;i++) {
  System.out.println(names[i] + sexes[i] + heights[i]);
  }
  */

• 面向对象的三大特征：
  * 封装
  * 隐藏内部细节，对外提供访问的接口
  * （广义的接口，这里的接口指的是提供访问的方式）。
  * 封装包含以下几个维度：
  * 1、对属性的封装------setter和getter
  * 具体做法，把属性私有化 使用private修饰
  * 提供setter和getter方法
  * 对属性封装，能确保属性的安全性。不容易出现脏数据
  * 2、对行为（方法）的封装
  * 对具体功能实现的封装。
  * 隐藏实现细节，对外提供调用方式。
  * 具体做法，在类中定义一个public修饰方法
  * 并且实现功能，使用的时候，通过对象名.方法就完成了功能的调用
  * 3、对类的封装
  * 把属性和行为封装到类里。
  * 使用的时候，创建对象，使用具体的功能。
  * 继承
  * 当两个对象特征和行为完全相同的时候，我们采用类创建不同的对象即可。
  * 但是如果2个对象很相似但是不完全相同，这个时候，我们可以采用继承的方式
  * 优化类的定义。
  * 一般相似的两个类，一定会有一个从属关系。
  *
  * 例如:动物类 有性别 能吃饭，能睡觉，能行走。
  * :猫类 有性别 命的条数 能吃饭，能睡觉，能行走，能卖萌
  * 猫 is a 动物
  * 猫是一个动物
  * 不能反过来说 动物是个猫。
  *
  * 比较模糊的比较抽象往往是父类，
  * 比较具体的往往是子类。
  *
  * 父类也叫超类、基类、superclass
  * 子类是通过扩展父类延伸（派生）出来的，子类也叫派生类
  *
  * 关于继承：
  * 子类可以在父类的基础上增加新的属性和方法
  * 子类还可以重写（override）父类的方法
  *
  * 子类能从父类那里继承什么呢？
  * 答：继承了所有非private的属性和方法。
  * 本质上，私有的属性和方法也继承了，只不过
  * 不能直接访问。
  *
  * 父类的构造方法是继承不了的！
  *
  * 为什么呢？
  * 因为构造方法的特点是：方法名必须与类名相同。
  *
  * 但是你可以调用父类的构造方法。
  *
  * 调用父类的构造方法使用super(),super(参数列表)
  *
  * 多态
  * 多态：从字面意思理解，同一个方法有多种不同的实现。
  * 不同对象（类）对行为相同行为（方法）的不同实现。

• 例如：睡觉（public void sleep()）

• 狗：趴着睡

• 猫：卧着睡

• 人：躺着睡

• 马：站着睡

• 在java里，多态用于写抽象功能。提取共性，但是在运行的时候

• 执行的又是特性（而不是共性）。

• 用的时候（编译期），把子类当父类看。无论你是僵尸还是路障僵尸还是报纸僵尸

• 都当成僵尸来看待。（相当于只看了共性。）

• 真正执行方法的时候（运行期），执行的是子类方法。

• 想要在java里面实现多态有几个前提：

• 1、必须存在继承关系。

• 2、子类必须重写父类的方法。

• 3、执行的是子类的实现。

•   public static void main(String[] args) {
   Animal[] animals = new Animal[5];
   Animal a = new Animal();
   Animal b = new Cat();
   Animal c = new Dog();
   Animal d = new Horse();
   Animal e = new Person();
   
   animals[0] = a;
   animals[1] = b;
   animals[2] = c;
   animals[3] = d;
   animals[4] = e;
   
   for (Animal animal : animals) {
   	animal.sleep();
   }
   }