Day12

Java面向对象三大特征小结

面向对象之————封装

• 设计程序的最求即为“高内聚，低耦合”

  高内聚：类的内部数据操作细节自己完成，不允许外部干涉

  低耦合：仅对外部暴露少量的方法用于使用。

  

• 封装型的体现：

  1. 将类的属性私有化，同时提供公共的方法来获取和设置此属性的值。
  2. 不对外暴露的私有的方法
  3. 单例模式（将构造器私有化）
  4. 如果不希望类在包外被调用，可以将类设置为缺省

面向对象之————继承性

// 一、继承性的好处
//  1.减少了代码的冗余，提高了代码的复用性
//  2.便于功能的扩展
//  3.为以后多态性的使用提供了前提

// 二、继承性的格式
// class A extends B(){}
// A:子类，派生类，subclass
// B:父类，超类，基类，superclass
// 体现：一旦子类A继承B以后，子类中A就获取了父类中声明的结构：属性，结构
// 特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。
// 只有因为封装性的影响，是的子类不能直接调用父类的结构而已
//
// 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展；
// 子类和父类的关系，不同于子集和集合的关系

// 三、Java中关于继承的规定
// 1.一个类可以被多个子类继承。
// 2.Java中类的单继承性：一个类只能有一个父类：单继承
// 3.子父类是相对的概念
// 4.子类直接继承父类，称为直接父类，间接继承的父类称为：间接父类
// 5.子类继承父类以后，就获取了类直接父类以及所有间接父类中声明的属性和方法
// 6.如果我们没有显式的声明一个类的父类，则此类继承java.lang.Object类
// 7.所有的java类(除java.lang.Object类之外)都直接或间接的继承于java.lang.Object类

// 方法的重写(override / overwrite)
// 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
// 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法
// 3.重写的规定：
//              方法的声明：权限修饰符 返回值类型 方法名(形参列表){}
//              约定俗成：子类中的叫重写的方法，父类中的叫被重写的方法。
//              1.子类重写的方法的方法名和形参列表与父类被重写的方法名和形参列表形同
//              2.子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
//              >特殊情况：子类不能重写父类中声明为private权限的方法
//              3.返回值类型
//              >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
//              >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
//              >父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型（必须也是double）
//              4.方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{}
//              子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常
//
//              子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写)，要么都声明为static（不是重写）
//
//
// 区分方法的重载与重写：
// 二者的概念；重载和重写的具体规则；重载在编译时就确定了调用地址
// 重写只有在运行时才会确定具体的调用地址，而这又称晚绑定，而这又
// 是多态的体现
// 重载：在同一个类中允许出现相同方法名的参数，但是需要参数列表不同
//			它们的调用地址在编译期就绑定了，Java的重载是可以包括父类
//			和子类的，即子类可以重载父类的同名不同参数的方法，对于重载
//			而言，在方法调用之前，编译器就已经确定了所要调用的方法，这
//			称为"早绑定"或"静绑定"
// 重写：

// super关键字的使用
// 1.super理解为：父类的
// 2.super可以用来调用：属性、方法、构造器
//
// 3.super的使用:调用属性和方法
//      1.我们可以在子类的方法中或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
//      父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
//
//      2.特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，必须显式的
//      使用"super.属性"的方式，表明调用的是父类中声明的属性
//      3.特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显
//      式的使用"super.方法"的方法，表明调用的是父类中被重写的方法
//
// 4.super调用构造器
//      1.我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
//      2."super(形参列表)"的使用，必须声明在子类构造器的首行
//      3.我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
//      4.在构造器的首行，没有显式的声明"this.(形参列表)"或"super(形参列表)"。则默认调用的式父类中空参的构造器super()
//      5.在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

// 子类对象实例化的全过程
// 1.从结果上来看：
//          子类继承父以后，就获取了父类中声明的属性或方法
//          创建子类的对象，在堆空间中，就会加载所有父类中声明的属性
// 2.从过程上来看：
//          当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的构造器
//          直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有
//          父类的结构，子类对象才可以考虑进行调用。
//
// 明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

面向对象之————多态

// 1.理解多态性：可以理解为一个事物的多种形态
// 2.何为多态性：
//              对象的多态性：父类的引用指向子类的对象(或子类的对象赋给父类的引用)
// 3.多态的使用：虚拟方法的调用
//              有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
//              总结：编译看左边的引用 类型；运行看右边的new对象。
// 4.多态性的使用前提：
//              1.类的继承关系
//              2.需要有方法的重写
//
// 5.多态性的好处：
//              有了多态性就可以避免方法的重载
//
// 对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为"晚绑定"或"动态绑定"

//instanceof关键字的使用
// a instanceof A ：判断对象a是否是类A的实例。如果是返回true；如果不是返回false


// 使用情景：为了避免向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行
// instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型

//如果a instanceof A返回true，则a instanceof B也返回true。其中类B是类A的父类
//其中类B是类A的父类

// 1.若子类重写类父类的方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法
// 系统就不可能把父类里的方法转移到子类中：编译看左边，运行看右边
// 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例
// 变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边