什么是面对对象

1.什么是对象

在《Java In Think》一书中对对象的定义是：
我们将问题空间的元素以及其在解空间中的表示称为---对象，这样就很抽象，通俗的说就是类的一个实例，且拥有状态和行为
这样解释引申了一个概念：什么是类？
类：类是一个模板，它描述一类对象的行为和状态 比如说 人类、鸟类。

面对对象和面对过程

面对过程和面向对象：

     面向过程和面向对象都是一种抽象过程的抽象思想，也就是解决问题的思想。   

区别：

  基于问题的解决步骤就是面向过程：分析问题第一步，第二步....
  基于问题的组成元素以及元素之间的关系：也就是直接分析问题需要那些类和对象，以及他们的方法和属性，还有类之间的关系

这两种思想不是对立的，是相互扶持的，在Java中解决业务问题，通常都有两种思想的碰撞，比如抽象问题成为对象，然后业务逻辑的解决顺序

面对对象的三大基本特征

1.封装

隐藏对象内部的复杂性，只对外公开了简单的接口，便于外界调用，从而提高系统的可拓展性，可维护性，作用就是安全。 程序设计的要求：高内聚，低耦合
例如：把描述一个对象的属性和行为封装成一个类，把具体的业务逻辑功能实现封装成一个方法，其次封装的意义还有效的保护属性通过访问修饰符私有化属性(成员变量),公有化方法

2.继承

实现代码的复用，把所有的子类的共同方法和属性抽象成一个父类，让所有的子类继承这个父类便可以获得父类的属性和方法，具有单一性和传递性
单一性 ： Java中OOP都是单根继承结构 每个子类都只能继承一个父类
传递性：子类有父类的方法和属性也有父类的父类的方法和属性
子类在继承父类的构造方法时会先调用祖先的构造的方法依次到本类为止

3.多态

程序中定义的引用类型变量所指向的具体类型和调用的具体方法在程序编译阶段无法确定，而是在运行期才能确定该引用类型变量指向具体哪个对象而调用在哪个类中声明的方法。
eg：
1.定义一个动物类 具有方法 吃东西

abstract class Animal {  
 abstract void eat();  
} 

2.定义一个狗 类和一个猫类都继承 动物类 但是吃东西的方式不同
class Cat extends Animal {  
 public void eat() {  
     System.out.println("吃鱼");  
 }  
 public void work() {  
     System.out.println("抓老鼠");  
 }  
}  

class Dog extends Animal {  
 public void eat() {  
     System.out.println("吃骨头");  
 }  
 public void work() {  
     System.out.println("看家");  
 }  
}
3.编译期不确定  运行期知道是 Dog类
public class Test {
 public static void main(String[] args) {
   show(new Cat());  // 以 Cat 对象调用 show 方法
   show(new Dog());  // 以 Dog 对象调用 show 方法
             
   Animal a = new Cat();  // 向上转型  
   a.eat();               // 调用的是 Cat 的 eat
   Cat c = (Cat)a;        // 向下转型  
   c.work();        // 调用的是 Cat 的 work
}
public static void show(Animal a)  {
   a.eat();  
     // 类型判断
     if (a instanceof Cat)  {  // 猫做的事情 
         Cat c = (Cat)a;  
         c.work();  
     } else if (a instanceof Dog) { // 狗做的事情 
         Dog c = (Dog)a;  
         c.work();  
     }  
 }   
}
简单的来说就是：编译时期无法确定是那种类型，运行期可以知道方法的执行方式

存在的条件:
继承、 重写、父类引用指向子类对象
分类:

行为多态：
      同一个run( ){ }方法，不同的对象调用时会有不同的实现，猫调用时是跑，鱼调用时是游，鸟调用时是飞。
 对象多态：同一个对象，可以被造型为不同的类型，比如同一个人对象，可以被造型为儿子，父亲，员工等。

面对对象的五大基本原则

1.单一职责原则（SRP）

• 一个类应该仅有一个引起它变化的原因

2.开放封闭原则（OCP）

• 既开放又封闭，对扩展是开放的，对更改是封闭的！
• 扩展即扩展现有的功能模块，当出现新的需求，就需要我们对模块进行扩展，使其能够满足新的需求。
更改封闭即是在我们对模块进行扩展时，勿需对源有程序代码和DLL进行修改或重新编译文件！

3.里氏替换原则（LSP）

• 子类可以替换父类并且出现在父类能够出现的任何地方
• 这个原则也是在贯彻GOF倡导的面向接口编程！
在这个原则中父类应尽可能使用接口或者抽象类来实现！
子类通过实现了父类接口，能够替父类的使用地方！
通过这个原则，我们客户端在使用父类接口的时候，通过子类实现！
意思就是说我们依赖父类接口，在客户端声明一个父类接口，通过其子类来实现
这个时候就要求子类必须能够替换父类所出现的任何地方，这样做的好处就是，在根据新要求扩展父类接口的新子类的时候而不影响当前客户端的使用！

4.依赖倒置原则（DIP）

• 传统的结构化编程中，最上层的模块通常都要依赖下面的子模块来实现，也
称为高层依赖低层！
所以DIP原则就是要逆转这种依赖关系，让高层模块不要依赖低层模块，所以称之为依赖倒置原则！
举个例子就是 我们数据库操作模块 我们的业务不需要依赖具体是哪个数据库 我们只要实现自己的业务，通常都是把增删改查的操作放在Dao层操作，然后把dao注入即可其实还是多态的应用

5.ISP 接口隔离原则

• 这个原则的意思是：使用多个专门的接口比使用单个接口要好的多

值传递和引用传递

1.值传递

在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

2.引用传递

在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

3.为什么Java只有值传递

Java参数传递时，如果是自定义的对象其实会把对象的地址 copy一份在堆空间建立新的对象的以用hash值 当作实参传递给函数
Java中传递都是对象在内存空间也就是堆空间的地址的hash值
如果是基本数据类型，那么直接复制一份新的基本数据类型 当成实参
所以都是值传递
理解JVM虚拟机运行时候的内存空间