前言:
如果你很想搞明白面向对象是什么，面向过程是什么，或者说二者之间的区别是什么，那么就花费一点时间来研读一下这篇博客，你一定会有很大的收获的！
一、面向对象与面向过程的区别
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。
如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。
可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。
上述的内容是从网上查到的，觉得这个例子非常的生动形象，我就写了下来，现在就应该理解了他俩的区别了吧，其实就是两句话，面向对象就是高度实物抽象化、面向过程就是自顶向下的编程！
二、面向对象的特点
 在了解其特点之前，咱们先谈谈对象，对象就是现实世界存在的任何事务都可以称之为对象，有着自己独特的个性

属性用来描述具体某个对象的特征。比如小志身高180M，体重70KG，这里身高、体重都是属性。

面向对象的思想就是把一切都看成对象，而对象一般都由属性+方法组成！
属性属于对象静态的一面，用来形容对象的一些特性，方法属于对象动态的一面，咱们举一个例子，小明会跑，会说话，跑、说话这些行为就是对象的方法！所以为动态的一面， 我们把属性和方法称为这个对象的成员！
类：具有同种属性的对象称为类，是个抽象的概念。比如“人”就是一类，期中有一些人名，比如小明、小红、小玲等等这些都是对象，类就相当于一个模具，他定义了它所包含的全体对象的公共特征和功能，对象就是类的一个实例化，小明就是人的一个实例化！我们在做程序的时候，经常要将一个变量实例化，就是这个原理！我们一般在做程序的时候一般都不用类名的，比如我们在叫小明的时候，不会喊“人，你干嘛呢！”而是说的是“小明，你在干嘛呢！”
面向对象有三大特性，分别是封装性、继承性和多态性，这里小编不给予太多的解释，因为在后边的博客会专门总结的！
三、面向过程与面向对象的优缺点
很多资料上全都是一群很难理解的理论知识，整的小编头都大了，后来发现了一个比较好的文章，写的真是太棒了，通俗易懂，想要不明白都难!
用面向过程的方法写出来的程序是一份蛋炒饭，而用面向对象写出来的程序是一份盖浇饭。所谓盖浇饭，北京叫盖饭，东北叫烩饭，广东叫碟头饭，就是在一碗白米饭上面浇上一份盖菜，你喜欢什么菜，你就浇上什么菜。我觉得这个比喻还是比较贴切的。
蛋炒饭制作的细节，我不太清楚，因为我没当过厨师，也不会做饭，但最后的一道工序肯定是把米饭和鸡蛋混在一起炒匀。盖浇饭呢，则是把米饭和盖菜分别做好，你如果要一份红烧肉盖饭呢，就给你浇一份红烧肉；如果要一份青椒土豆盖浇饭，就给浇一份青椒土豆丝。
蛋炒饭的好处就是入味均匀，吃起来香。如果恰巧你不爱吃鸡蛋，只爱吃青菜的话，那么唯一的办法就是全部倒掉，重新做一份青菜炒饭了。盖浇饭就没这么多麻烦，你只需要把上面的盖菜拨掉，更换一份盖菜就可以了。盖浇饭的缺点是入味不均，可能没有蛋炒饭那么香。
到底是蛋炒饭好还是盖浇饭好呢？其实这类问题都很难回答，非要比个上下高低的话，就必须设定一个场景，否则只能说是各有所长。如果大家都不是美食家，没那么多讲究，那么从饭馆角度来讲的话，做盖浇饭显然比蛋炒饭更有优势，他可以组合出来任意多的组合，而且不会浪费。
盖浇饭的好处就是"菜"“饭"分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是"可维护性"比较好，“饭” 和"菜"的耦合度比较低。蛋炒饭将"蛋”“饭"搅和在一起，想换"蛋”"饭"中任何一种都很困难，耦合度很高，以至于"可维护性"比较差。软件工程追求的目标之一就是可维护性，可维护性主要表现在3个方面：可理解性、可测试性和可修改性。面向对象的好处之一就是显著的改善了软件系统的可维护性。

　　
看了这篇文章，简单的总结一下!
面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、                                                                                                                      Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统                         更加灵活、更加易于维护

缺点：性能比面向过程低

"""
实现两个对象的相加,需实现类的__add__方法
实现两个对象的相减,需实现类的__sub__方法
complex
1 + 2j
3 + 4j
"""


class Complex(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        self.x += other.x
        self.y += other.y

    def __sub__(self, other):
        self.x -= other.x
        self.y -= other.y

    def show_add(self):
        print('%d + %dj' % (self.x, self.y))

    def show_sub(self):
        print('%d + %dj' % (self.x, self.y))


c1 = Complex(1, 2)
c2 = Complex(3, 4)
# c1 + c2
c1.__add__(c2)
c1.show_add()  # 4 + 6j
# c1 - c2
c1.__sub__(c2)
c1.show_sub()  # 1 - 2j


 

概念
在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。
具体如下图
java 普通对象结构


java 数组对象结构


对象结构组成
对象头
HotSpot虚拟机的对象头包括两部分信息：

Mark Word

第一部分Mark Word,用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机（未开启压缩指针）中分别为32bit和64bit
类型指针

对象头的另外一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例.
数组长度（只有数组对象有）

如果对象是一个数组, 那在对象头中还必须有一块数据用于记录数组长度.

实例数据
​    实例数据部分是对象真正存储的有效信息，也是在程序代码中所定义的各种类型的字段内容。无论是从父类继承下来的，还是在子类中定义的，都需要记录起来。
对象引用（reference）类型在64位机器上，关闭指针压缩时占用8bytes， 开启时占用4bytes。
原生类型（primitive type）的内存占用如下：




Primitive Type
Memory Required(bytes)




byte, boolean
1 byte


short, char
2 bytes


int, float
4 bytes


long, double
8 bytes


包装类型
包装类（Boolean/Byte/Short/Character/Integer/Long/Double/Float）占用内存的大小等于对象头大小加上底层基础数据类型的大小。
包装类型的对象内存占用情况如下：




Numberic Wrappers
+useCompressedOops
-useCompressedOops




Byte, Boolean
16 bytes
24 bytes


Short, Character
16 bytes
24 bytes


Integer, Float
16 bytes
24 bytes


Long, Double
24 bytes
24 bytes


对齐填充
​    第三部分对齐填充并不是必然存在的，也没有特别的含义，它仅仅起着占位符的作用。由于HotSpot VM的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说，就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或者2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。
HotSpot的对齐方式为8字节对齐：
（对象头 + 实例数据 + padding） % 8=0且0 <= padding < 8
jvm相关参数
上面用到的useCompressedOops这个参数，我们可以看看在命令行输入：java -XX:+PrintCommandLineFlags -version 查看jvm默认参数如图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pKMke0p9-1589680207000)(E:\技术帖子\笔记\基础\图\java对象结构\jvm参数.png)]
分别是 -XX:+UseCompressedOops 和 -XX:+UseCompressedClassPointers

这2个参数都是默认开启（+代表开启，-代表关闭）
UseCompressedOops：普通对象指针压缩（oop是ordinary object pointer的缩写),

UseCompressedClassPointers：类型指针压缩。
例如:
Object o = new Object();

o指向new Object()的引用就是“普通对象指针”，

new Object()自身还需要指向Object类型的引用，也就是"类型指针"。
这2个压缩参数可以有4种组合(++, --, + -, -+)，但有1种组合是会抛出警告的：
-XX:+UseCompressedClassPointers -XX:-UseCompressedOops，不要使用这种参数组合，用这种参数启动jvm时会抛出警告。
Java HotSpot(TM) 64-Bit Server TIM warning: UseCompressedClassPointers requires UseCompressOops

原因是jvm层面的hotspot源码对jvm的参数组合做了限制，一看就懂：
// UseCompressedOops must be on for UseCompressedClassPointers to be on.
if (!UseCompressedOops){
   if (UseCompressedClassPointers){
   warning("UseCompressedClassPointers requires UseCompressOops");
}
  FLAG_SET_DEFAULT(UseCompressedClassPointers , false);
}

HotSpot对象模型
HotSpot中采用了OOP-Klass模型，它是描述Java对象实例的模型，它分为两部分：


类被加载到内存时，就被封装成了klass，klass包含类的元数据信息，像类的方法、常量池这些信息都是存在klass里的，你可以认为它是java里面的java.lang.Class对象，记录了类的全部信息；


OOP（Ordinary Object Pointer）指的是普通对象指针，它包含MarkWord 和元数据指针，MarkWord用来存储当前指针指向的对象运行时的一些状态数据；元数据指针则指向klass,用来告诉你当前指针指向的对象是什么类型，也就是使用哪个类来创建出来的；
那么为何要设计这样一个一分为二的对象模型呢？这是因为HotSopt JVM的设计者不想让每个对象中都含有一个vtable（虚函数表），所以就把对象模型拆成klass和oop，其中oop中不含有任何虚函数，而klass就含有虚函数表，可以进行method dispatch。


HotSpot中，OOP-Klass实现的代码都在/hotspot/src/share/vm/oops/路径下，oop的实现为instanceOop 和 arrayOop，他们来描述对象头，其中arrayOop对象用于描述数组类型。
以下就是oop.hhp文件中oopDesc的源码，可以看到两个变量_mark就是MarkWord，_metadata就是元数据指针，指向klass对象，这个指针压缩的是32位，未压缩的是64位；
volatile markOop _mark;  //标识运行时数据
  union _metadata {
    Klass*      _klass;
    narrowKlass _compressed_klass;
  } _metadata;  //klass指针

一个Java对象在内存中的布局可以连续分成两部分：instanceOop（继承自oop.hpp）和实例数据；
如图:


通过栈帧中的对象引用reference找到Java堆中的对象，再通过对象的instanceOop中的元数据指针klass来找到方法区中的instanceKlass，从而确定该对象的类型。
对象大小的计算
有以下几点:
1.在32位系统下，存放Class指针的空间大小是4字节，MarkWord是4字节，对象头为8字节。
2.在64位系统下，存放Class指针的空间大小是8字节，MarkWord是8字节，对象头为16字节。
3.64位开启指针压缩的情况下，存放Class指针的空间大小是4字节，MarkWord是8字节，对象头为12字节。
4.数组长度4字节+数组对象头8字节(对象引用4字节（未开启指针压缩的64位为8字节）+数组markword为4字节（64位未开启指针压缩的为8字节）)+对齐4=16字节。
5.静态属性不算在对象大小内。
贴网上的一个比较实用的工具类:
import java.lang.instrument.Instrumentation;  
import java.lang.reflect.Array;  
import java.lang.reflect.Field;  
import java.lang.reflect.Modifier;  
import java.util.ArrayDeque;  
import java.util.Deque;  
import java.util.HashSet;  
import java.util.Set;  

/** 

​	*对象占用字节大小工具类 

​    **/  
public class SizeOfObject {  
static Instrumentation inst;  

public static void premain(String args, Instrumentation instP) {  
    inst = instP;  
}  

/** 

 * 直接计算当前对象占用空间大小，包括当前类及超类的基本类型实例字段大小、<br></br> 

*引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;<br></br> 

*但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小 <br></br> 

*

*@param obj 

*@return 
*/  
public static long sizeOf(Object obj) {  
return inst.getObjectSize(obj);  
}  

/** 

*递归计算当前对象占用空间总大小，包括当前类和超类的实例字段大小以及实例字段引用对象大小 

*

*@param objP 

*@return 

*@throws IllegalAccessException 
*/  
public static long fullSizeOf(Object objP) throws IllegalAccessException {  
Set<Object> visited = new HashSet<Object>();  
Deque<Object> toBeQueue = new ArrayDeque<Object>();  
toBeQueue.add(objP);  
long size = 0L;  
while (toBeQueue.size() > 0) {  
    Object obj = toBeQueue.poll();  
    //sizeOf的时候已经计基本类型和引用的长度，包括数组  
    size += skipObject(visited, obj) ? 0L : sizeOf(obj);  
    Class<?> tmpObjClass = obj.getClass();  
    if (tmpObjClass.isArray()) {  
        //[I , [F 基本类型名字长度是2  
        if (tmpObjClass.getName().length() > 2) {  
            for (int i = 0, len = Array.getLength(obj); i < len; i++) {  
                Object tmp = Array.get(obj, i);  
                if (tmp != null) {  
                    //非基本类型需要深度遍历其对象  
                    toBeQueue.add(Array.get(obj, i));  
                }  
            }  
        }  
    } else {  
        while (tmpObjClass != null) {  
            Field[] fields = tmpObjClass.getDeclaredFields();  
            for (Field field : fields) {  
                if (Modifier.isStatic(field.getModifiers())   //静态不计  
                        || field.getType().isPrimitive()) {    //基本类型不重复计  
                    continue;  
                }  

​            field.setAccessible(true);  
​            Object fieldValue = field.get(obj);  
​            if (fieldValue == null) {  
​                continue;  
​            }  
​            toBeQueue.add(fieldValue);  
​        }  
​        tmpObjClass = tmpObjClass.getSuperclass();  
​    }  
}  

}  
return size;  
}  

/** 

   * String.intern的对象不计；计算过的不计，也避免死循环 

*

*@param visited 

*@param obj 

*@return 
*/  
static boolean skipObject(Set<Object> visited, Object obj) {  
if (obj instanceof String && obj == ((String) obj).intern()) {  
    return true;  
}  
return visited.contains(obj);  
}  
}

最后举三个例子：
首先需要创建一个mavean项目，引入包
<dependency>
  <groupId>org.openjdk.jol</groupId>
  <artifactId>jol-core</artifactId>
  <version>0.9</version>
</dependency>

1.需要补齐的对象
代码
public class User {
    long sex;
    Long mobile;
    String name;

    public static void main(String[] args) {
        System.out.println(ClassLayout.parseInstance(new User()).toPrintable());
    }
}

输出如图



2.不需要padding补齐的对象
代码：
public class User {

    String name;
    Long mobile;
    int sex;

    public static void main(String[] args) {
        System.out.println(ClassLayout.parseInstance(new User()).toPrintable());
    }
}

输出如图



3.空对象，所占字节数
代码：
public class User {

    public static void main(String[] args) {
        System.out.println(ClassLayout.parseInstance(new User()).toPrintable());
    }
}

输出如图



4.数组对象结构
代码：
public class ArrayTest {

    public static void main(String[] args) {
        System.out.println(ClassLayout.parseInstance(new Integer[7]).toPrintable());
        System.out.println(ClassLayout.parseInstance(new Integer[8]).toPrintable());
        System.out.println(ClassLayout.parseInstance(new int[7]).toPrintabl![在这里插入图片描述](https://img-blog.csdnimg.cn/20200517102321457.png)e());
    }
}

输出如图



如果大家对java架构相关感兴趣，可以关注下面公众号，会持续更新java基础面试题, netty,  spring boot,spring cloud等系列文章，一系列干货随时送达,  超神之路从此展开, BTAJ不再是梦想!

"""
pickle序列化对象和类到数据库,需修改mysql数据库表结构,字段类型设为二进制,如blob类型,参考:
https://www.cnblogs.com/wangchunlan1299/p/7725062.html
| test  | CREATE TABLE `test` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `obj` mediumblob,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 |

<__main__.Person object at 0x0000000002A82A20> zhangsan 18
name:zhangsan,age:18
"""
import pickle
import pymysql


class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print('name:%s,age:%s' % (self.name, self.age))


"""
# 序列化对象
person = Person('zhangsan', 18)
ret = pickle.dumps(person)
# print(ret)

# obj = pickle.loads(ret)
# print(obj, obj.name, obj.age)
# obj.introduce()

conn = pymysql.connect(host='localhost', port=3306, user='root', password='root', database='test', charset='utf8')
cursor = conn.cursor()
cursor.execute('insert into test(obj) values (%s);', [ret])
conn.commit()

cursor.execute('select * from test')
result = cursor.fetchall()
ret = result[0][1]

obj = pickle.loads(ret)
print(obj, obj.name, obj.age)
obj.introduce()
"""

# 序列化类
ret = pickle.dumps(Person)
print(ret)

conn = pymysql.connect(host='localhost', port=3306, user='root', password='root', database='test', charset='utf8')
cursor = conn.cursor()
cursor.execute('insert into test(obj) values (%s);', [ret])
conn.commit()

cursor.execute('select * from test')
result = cursor.fetchall()
ret = result[0][1]

person_class = pickle.loads(ret)
person = person_class('zhangsan', 18)
print(person.name, person.age)
person.introduce()