面向对象

面向对象三大特征

1.封装

封装：隐藏对象的属性和实现的细节，仅对外提供一种公共的访问方式。
好处：
1.隔离了内部的变化
2.便于使用。
3.提供了复用性。
4.提供了安全性。

封装的原则：（怎么体现封装）
1.将不需要对外提供的内容都隐藏起来。
2.将属性都隐藏起来，然后提供公共的方法来对其访问。

继承：
好处：1.提高了代码的复用性。
      2。让类和类之间产生了关系.（关系是多态的前提）
将对像中的内容不断的向上抽取，就形成了关系，就有了继承，就有父子类，提高了代码的复用性。
特点：
java语言当中的继承只能单继承，
 
单继承：一个类只能有一个父类,一个儿子只能有一个父亲
多继承：一个类可以有多个父类，一个儿子可以有多个父亲。

 java不支持多继承的原因：会产生调用的不确定性
 多继承的好处：同时继承几个类，就会有几个类的方法。
 java改良了多继承，虽然不支持多继承，但是支持多重继承。这样就形成了继承体系。

  class A extends B{}
  class B extends C{}
  
  C
  ----|B
      -----|A

什么时候定义继承？
  必须是事物之间存在着所属关系时，才能定义继承。
  所属关系：xxx是zzz当中的一种，   学生是人当中的一种，
  用英文翻译就是   is  a  的关系

注意：不要仅仅为了复用，为了获得其他类当中的内容就去继承。

继承在成员中的特点：
  1.成员变量
  2.成员方法
  3.构造方法
  
 继承在成员变量中的用法
  1.父类当中包含的公有的属性，子类都可以调用。
  2.如果父类当中包含的属性的名称和子类当中包含的属性的名称相同了，并且在需要调用的方法中也有同名的变量名称。
  正常情况下，方法中会采用就近原则去获取变量的值，如果想获得子类的对象的属性的值，就通过this调用，如果想获得
  父类的属性的值，就通过super来调用。
super关键字：
super代表父类，它和this的用法是比较相似的。
this代表本类当中对象的引用，super则代表父类所属的空间。
一般情况下，如果父类中定义了一个属性，子类中就不需要定义同名的属性了，直接继承就可以了。
子类只能直接的访问父类非私有的内容，如果想要访问私有的内容，就使用其他的方法。
子类能访问的空间至少是两片。
  
堆内存存放对象本身的属性外，还存放着父类的属性，要用super来访问，对象不能直接访问私有的属性。


继承在成员函数中的特点：
  当父子类出现了一模一样的方法时，会产生一个函数的特性，名字叫做重写（复写，覆盖）。
  英文 Override


重写的注意事项：
  1.子类重写父类时，必须要保证重写方法的权限必须大于等于被重写方法的权限。
  权限修饰符权限的顺序：   private   default   protected   public
  2.重写方法有静态修饰时，静态只能重写静态，或者被静态重写。
  
重写和重载的区别
  1.重写override     重载是overload
  2.重载要求在同一个类当中。
    重写要求在父子类继承关系中。
  3.重载方法名相同，参数列表不同，返回值没要求
    重写方法方法名相同，参数列表相同，返回值类型也相同
  4.重载权限修饰符没要求
    重写权限的要求：重写方法的权限必须大于等于被重写的方法的权限。


当重写一个方法时，想保留原来的功能的同时还想新增加功能，
这时可以在重写的方法中加入一句代码：super.Xxx()---->保留父类这个方法中的功能。


继承在构造函数中的特点：
  子类实例化的过程：
  其中子类所有的构造函数，都有一条默认的隐士的语句super();
  也就是说子类的构造函数，都会默认访问父类空参的构造函数。
  
  为什么子类当中的构造函数都要默认去访问父类的空参的构造函数呢？
  因为子类继承了父类，可以访问父类当中的一些属性，在子类进行实例化的时候就必须为父类包含的属性分配空间，
  并且进行初始化，所以就必须要访问父类的构造函数。看看父类是如何对齐属性进行初始化的。
  
结论：父类的构造函数，既可以给本类的对象初始化，同时也可以给子类的对象初始化。


注意：
  如果父类中没有空参数的构造函数，子类的构造函数必须手动的用super来指定要访问的父类的构造函数。
  或者用this来访问本类中的构造函数。
  
  this和super只能定义在构造函数的第一行，而且不能同时出现


对象可以作为一个类的成员属性。

[多态]
多态：多种形态 
 *好处：提高了代码的拓展性
 *弊端：前期建立了父类的引用，虽然能够接收所有的子类的对象，但是只能使用父类当中的功能，不能使用子类特有的功能。
 *  因为前期的程序不知道后期要添加的内容，但是前期的程序可以使用子类重写父类的内容。
 *
 *多态的前提：
 *   1.必须存在继承关系。
 *   2.必须存在着重写的操作。
 *
 *多态在程序当中的体验：
 *狗   x = new 狗（）;
 *动物  d = new 狗（）；//对象的多态性。
 *
 *
 *对象的转型
 *Dog d = new Dog();
 *Animal a = new Dog();  //子类对象类型的提升，对象的向上转型，
 *
 *d和a的区别：
 *从外表看类型是不一样的，而且狗的引用d只能指向狗的对象，而animal的引用a可以指向狗的对象，也可以指向猫的对象，
 *他能指向所有的继承了animal子类的对象，但是他只能调用animal当中共有的方法。
 *
 *【类型提升】
 *好处：提高了拓展性。
 *弊端：只能使用父类的方法
 *这个提升可以限制对子类对象的操作。
 *专业术语：向上转型
 *
 *当想要实现子类特有的功能时，可以让子类对象向下转型。
 *Dog dog = (Dog)d;      //对象向下转型的格式，转成了子类型
 *好处：可以使用子类特有的功能了。
 *弊端：如果类型转换错误，就会出现运行时异常。
 *
 *【应用场景】
 *什么时候向上转型，什么时候向下转型？
 *当需要对程序进行拓展，或者限定对子类对象的操作时，就可以使用向上转型，操作其父类型。
 *当要使用子类特有的功能时，就向下转型，所以在转型之前，要经过类型判断。
 *
 *【误区】
 *在转型的过程当中，都是子类的对象在做着类型的改变，千万不要把父类的对象转换成子类的类型。
 *
 *Animal a = new Animal();
 *Dog d = (Dog)a;
 *  //以上写法是错误的。
 *
 *关键字  instanceof
 *用处：判断对象是否属于此类型
 *
 *对象向下转型前，一定要加上这个判断，否则很容易出现类型转换异常，很可怕的，这是对象转换的健壮性判断！！！