【Java基础】运算符

╰+攻爆jí腚メ 2022-02-16 19:25 296阅读 0赞

学完基础的变量常量等知识。再往后和变量常量紧密相关的当然是加减乘除等等运算方法了~（当然加减乘除也只是一部分）

首先按照运算过程参与的元素，把运算符号简单粗暴的分为一元运算符、二元运算符、三元运算符等等。

一元运算符就是只有一个元素参加的运算，如【 !a 】；

二元运算符就是只有二个元素参加的运算，如【 a + b 】；

三元运算符就是只有三个元素参加的运算，如【 a ? b : c 】；

……(\*^▽^\*) 后面还有没有我没有去仔细了解，为了严谨，还是加上省略号哈哈。

# 算术运算符 #

咱们先学学小学三年级及之前的运算符‘+’、‘-’、‘\*’、‘/’。

1+1=2，1-1=0 等等算式放到 Java 中呢，我们也是一样的这么写~

来，我们先搞两个变量在这里：

double a = 1998.1109;
    double b = 2019.0413;

然后后面就用这两个变量来算了~

## 加 + ##

double c = a + b; //这里也是用加法让c等于a+b
    
    System.out.println("a+b="+c);

输出结果：![1596190-20190413162657865-921273141.png][]

## 减 - ##

double c = a - b;    // 这里也是同样的减法
    
    System.out.println("a-b="+c);

输出结果：![1596190-20190413163523200-686817576.png][]

## 乘 \* ##

double c = a * b;    // 与手写不一样的是，计算机中乘法用*
    
    System.out.println("a*b="+c);

输出结果：![1596190-20190413163556938-490824707.png][]

## 除 / ##

double c = a / b;    // 除法也与手写不一样，计算机中除法用/
    
    System.out.println("a/b="+c);

输出结果：![1596190-20190413163832976-1864153379.png][]

--------------------

### 除法的补充 - 2019.0414 （感谢提醒我的孙老师） ###

除法中，整数的除法还是会有一定的特殊性的，比如 3 / 2 = 1.5，留有小数点，那我们重新定义两个整型变量, 然后让他们做除法：

int h = 3, i = 2;  
    System.out.println("h/i="+(h/i)); // 数学：3÷2=1.5
    System.out.println("i/h="+(i/h)); // 数学：2÷3=0.666…

来看看结果：![16885258-dff03487f61ca78a.png][]

ei？这里的结果发现小数被舍弃了，1.5 变成了 1，0.6 也变成了 0~ 所以在做除法运算的时候，整数间的除法是不会保留小数的，这个与下面的 “取余” 类似，整数间的除法叫做 “取整”。  
\[补充完毕\]

--------------------

说完上面的加减乘除法，我们还有几个相对比价 “高级” 的计算符号需要去 study：

## 取余 % ##

取余：应该就是 取得余数 的意思了吧~

余数呢，就是在整数的除法中，当不能整除时，就产生了余数。比如 3 除 2，商是 1，余数是 1.

…… 额，我怎么开始解释小学数学了 -\_-|| 上代码吧…

double c =  b % a;    // 整除
    
    System.out.println("a%b="+c);

输出结果：![1596190-20190413165434431-421751029.png][]

额，这我就不验证了… 应该是对的了。

## 自增 ++ （自减 --） ##

自增：就是程序运行到某一行，变量自己就想通了，给自己加了个 1…… 这就是自增（在原有的变量中加 1）

比如：

a = a + 1;
    
    System.out.println("a="+a);

输出结果：![1596190-20190413165848558-997332376.png][]

上面是没有用到自增的运算符的计算，就是一个简单的加法计算。那么用自增呢，就更简单了：

a ++;    // 自增运算符
    
    System.out.println("自增：a="+a);

输出结果：![1596190-20190413170210884-156801252.png][]

此外，关于自增自减，必须要讲到的是自增自减符的位置问题！

先来一段代码：

a = 1998.1109;//重置a的值为1998.1109
    System.out.println("先++：" + ++a);
    a = 1998.1109;//重置a的值为1998.1109
    System.out.println("后++：" + a++);
    //不重置a的值了
    System.out.println("最后a变成了：" + a);

然后看一下结果：![1596190-20190413171511537-1665226379.png][]

发现了什么呢？

*  先进行自增运算的输出的值为 a = 1999.1109，完成了自增运算
 *  后进行自增运算的输出的值仍然为 a 原来的值（1998.1109）。
 *  最后进行 a 值的检查的时候，a 却还是变成了 1999.1109.

So，真相大白了吧：

*  \++a, 会先把 a 做加 1 操作后，把 a 输出，就是算好了的结果。
 *  a++ 会先输出 a，然后再算 ++。

就是这么回事儿，其实按照从左到右的顺序执行代码了 (\*^▽^\*)

自减（每次减一）同理，就不过多论述了~

# 赋值运算符 #

赋值运算符，一般来说就是数学中的 “=”，但是我们不能把它叫做等于哦~

之前的代码大家也都看到了。

double a = 1998.1109;

这样的代码，读作：a 等于 1998.1109 是错的哦，应该是将 1998.1109 赋值给 a。

这个逻辑是什么样的呢？

我的理解：等号左边的 a 是不确定的，右边的 1998.1109 是确定的，将确定的值赋给不确定的变量，使变量的确定就叫赋值。【等于的两边是等价的，而赋值确实右边的值成立后，左边的变量才成立。】

除了上面的 “=” 之外，还有许多其他的赋值运算符，他们由 “=” 前面加上其他的运算符组成，比如：

<table>  表 7 - 1 赋值运算符  
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>用法</td> 
   <td>等效表达式</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>a&nbsp;+= b</td> 
   <td>a = a +b</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>a&nbsp;-= b</td> 
   <td>a = a - b</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>a&nbsp;*= b</td> 
   <td>a = a * b</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>a&nbsp;/=&nbsp;b</td> 
   <td>a = a /b</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>a&nbsp;%=&nbsp;b</td> 
   <td>a = a % b</td> 
  </tr> 
  <tr> 
   <td>&amp;=</td> 
   <td>a&nbsp;&amp;=&nbsp;b</td> 
   <td>a = a &amp; b</td> 
  </tr> 
  <tr> 
   <td>|=</td> 
   <td>a&nbsp;|=&nbsp;b</td> 
   <td>a = a | b</td> 
  </tr> 
  <tr> 
   <td>^=</td> 
   <td>a&nbsp;^=&nbsp;b</td> 
   <td>a = a ^ b</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;=</td> 
   <td>a&nbsp;&gt;&gt;=&nbsp;b</td> 
   <td>a = a &gt;&gt; b</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;=</td> 
   <td>a&nbsp;&lt;&lt;=&nbsp;b</td> 
   <td>a = a &lt;&lt; b</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&gt;=</td> 
   <td>a&nbsp;&gt;&gt;&gt;=&nbsp;b</td> 
   <td>a = a &gt;&gt;&gt; b</td> 
  </tr> 
 </tbody> 
</table>

For example:（以 += 为例）

int a = 0;
    a+=2;
    System.out.println("a="+a);

输出结果：![1596190-20190413184113749-630330560.png][]

# 关系运算符 #

专业一点的话：**关系运算符用来比较两个值，返回布尔类型的值：true 或 false 。关系运算符都是二元运算符**。

两个变量之间的关系，我们可以用仍然用 ab 来作为例子进行比较。

a 与 b 之间，硬要搞点什么关系的话，无非就是谁大谁小或者相等不相等的关系了。类似于 >、< 这样的就叫关系运算符了。那运算的结果呢，无非就是 a 比 b 大是不是真的，是真的就是 true，假的就是 false。

然后常用的关系运算符还是列出来一下：

<table>  表 7 - 2 关系运算符  
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>用法</td> 
   <td>返回 true 需要满足的条件</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>a &gt; b</td> 
   <td>&nbsp;a 大于 b&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>a &lt; b</td> 
   <td>&nbsp;a 小于 b&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>a &gt;= b</td> 
   <td>&nbsp;a 大于等于 b&nbsp;</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>a &lt;=&nbsp;b</td> 
   <td>&nbsp;a 小于等于 b&nbsp;</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>a ==&nbsp;b</td> 
   <td>&nbsp;a 和 b 相等</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>a !=&nbsp;b</td> 
   <td>&nbsp;a 和 b 不相等</td> 
  </tr> 
 </tbody> 
</table>

好，这里列出一段代码来帮助理解：

boolean a = 1>0;    //真的，1确实大于0
    boolean b = 1<0;    //假的
    boolean c = 1>=0;    //真的
    boolean d = 1<=0;    //假的
    boolean e = 1!=0;    //真的
    boolean f = 1==0;    //假的
    System.out.println("a="+a);
    System.out.println("b="+b);
    System.out.println("c="+c);
    System.out.println("d="+d);
    System.out.println("e="+e);
    System.out.println("f="+f);

那么输出结果是不是注释所预料到的呢？来看一下

![1596190-20190413185655426-1417402674.png][]

bingo~~

# 逻辑运算符 #

1. 如果今天出太阳**并且**篮球场还有位置，我就去打篮球。

【出太阳】和【篮球场有位置】都得成立，都得是真的，我才出去【打篮球】。有一个前提条件不满足，我就懒得去了。用逻辑运算符表达就是

【出太阳】&&【篮球场有位置】

“&&” 符号就是 与 逻辑符了。符号两边都成立，都为真才会返回一个 true 值，否则都是 false 。

用代码体验一下：

boolean a = (1 > 0) && (2 > 0);
    // (1 > 0)为真， (2 > 0)为真，两个都成立，&&运算返回true
    System.out.println("a = "+a);
    
    boolean b = (1 < 0) && (2 > 0);
    // (1 < 0)为假， (2 > 0)为真，两个有一个成立，&&运算返回false
    System.out.println("b = "+b);
    
    boolean c = (1 < 0) && (2 < 0);
    // (1 < 0)为假， (2 < 0)为假，两个都不成立，&&运算返回false
    System.out.println("c = "+c);

输出结果：![1596190-20190413193934471-552154028.png][]

2. 如果今天出太阳**或者**下雨了，我就得带把伞出门。

【出太阳】和【下雨】只要有一个成立了，不管是【出太阳】还是【下雨】，我都得【带伞出门】。用逻辑运算符表达就是

【出太阳】||【下雨】

“||” 符号就是 或 逻辑符了。符号两边只有有一个成立，只要有一个为真就会返回一个 true 值，两个条件都是假的话，才会返回 false 值。

用代码体验一下：

boolean a = (1 > 0) || (2 > 0);
    // (1 > 0)为真， (2 > 0)为真，两个都成立，||运算返回true
    System.out.println("a = "+a);
    
    boolean b = (1 < 0) || (2 > 0);
    // (1 < 0)为假， (2 > 0)为真，两个有一个成立，||运算返回true
    System.out.println("b = "+b);
    
    boolean c = (1 < 0) || (2 < 0);
    // (1 < 0)为假， (2 < 0)为假，两个都不成立，||运算返回false
    System.out.println("c = "+c);

输出结果：![1596190-20190413194043111-1096489258.png][]

3. 如果今天**不**上班，我就呆在家里。

不是【上班】的日子，我才呆在家里。不是 \{不【上班】\} 的时候，我当然得去上班了…… 用逻辑运算符表达就是

!【上班】

“!” 符号就是 取反 逻辑符了。表示否则的意思。

用代码体验一下：

boolean a = !(1 > 0);
    // (1 > 0) 为真，经过取反运算之后为假
    System.out.println("a = "+a);
    
    boolean b = !(1 < 0);
    //(1 < 0) 为假，经过取反运算之后为真
    System.out.println("a = "+b);

输出结果：![1596190-20190413193820623-1562966851.png][]

# 补充——短路问题 20190421 #

关于逻辑运算符 &&、|| 两者，有一点要十分注意：  
这两个存在一个短路问题，意思就是前面第一个条件已经能够使表达式得出结果了，后面的条件就不用判断了。

比如：1>2&&2>1，那么这个因为 1>2 已经为假了，&& 要求两个都为真才能返回 True，所以后面的条件就不用计算，直接出返回结果。2>1 || 1>2，也是一样。

//短路与，第一个操作数的值为false，则不需要在计算后面的操作数
    boolean a = 1>2&&2<(3/0);//如果不短路，则会抛出异常（被除数为0）
    System.out.println(a);
    //短路与，第一个操作数的值为true，则不需要在计算后面的操作数
    boolean b = 1<2||2<(3/0);
    System.out.println(b);

# 位运算符 #

位运算符是用来对二进制位进行操作的运算符。（不常用的话可以只了解一下就行了哦~）

<table>  表 7 - 3 位运算符  
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>用法</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>~ a</td> 
   <td>按位取反</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>a &amp; b</td> 
   <td>按位与</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>a | b</td> 
   <td>按位或</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>a ^ b</td> 
   <td>按位异或</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>a &gt;&gt; b</td> 
   <td>a 右移 b 位</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>a &lt;&lt; b</td> 
   <td>a 左移 b 位</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&gt;</td> 
   <td>a &gt;&gt;&gt; b</td> 
   <td>a 无符号右移 b 位</td> 
  </tr> 
 </tbody> 
</table>

什么意思呢？一个个来聊。

1.  按位取反 ~ ，对数据的每个二进制位都取反（0 变 1,1 变 0）ep: ~111000 = 000111
2.  按位与 & ，对两个数据进行按位与运算（同一个位置有一个为 0，则结果为 0，其他情况为 1）ep:![1596190-20190413200044792-1089315583.png][]
    
    这个可以用来对二进制某些位进行清零操作，比如 11111，我想让他第四个变成 0，只需与 11101 进行按位与运算即可。
3.  按位或 | ，对两个数据进行按位或运算（同一个位置有一个为 1，则结果为 1，其他情况为 0）ep:![1596190-20190413200505732-1367977315.png][]
    
    同理，这个可以用来将二进制某些位变成 1，比如 11101，我想让他第四个变成 0，只需与 11111 进行按位或运算即可。
4.  按位异或 ^ ，对两个数据进行按位异或运算（同一个位置两个相同，则结果为 0，不同则为 1）ep:![1596190-20190413200913407-1623324684.png][]
    
    这个可以用来将二进制某些位进行翻转操作，比如 10101，我想让他前三位翻转，只需与 11100 进行按位或运算即可。还可以用于进行两个值的交换：![1596190-20190413201533764-165293483.png][]
5.  左移 << ，将一个数的各二进位全部左移，ep: ![1596190-20190413202525362-1320518883.png][]
    
    在不溢出的情况下可以用来实现 \*2 操作。
6.  右移 >> ，将一个数的各二进位全部右移，第一位是多少就补多少。ep: ![1596190-20190413203346257-453621680.png][]
    
    在不溢出的情况下可以用来实现 /2 操作。
7.  无符号右移 >>> ，将一个数的各二进位无符号全部右移，高位补 0，ep: ![1596190-20190413203526731-846948182.png][]
    
    如果两个数据长度不同，那么在位运算时会先将短型前补满，如果为正，则全补 0，如果为负，则全补 1。

# 其他运算符 #

除了以上几种运算符以外，Java 中还有一些特殊的运算符~

1. Java 实例运算符 instanceof

这个用来测试一个对象是否是一个指定的类的实例。

2. Java 内存分配运算符 new

很多时候我们说 new 一个对象，其实是为这个对象分配一个内存存储它。

3. 三目运算符 a ? b : c

这个的意思就是： a 是真的就输出冒号 : 前面的 b ，a 是假的，就执行冒输出: 后面的 c 。

int a = 1 >2 ? 3 : 6;
    System.out.println("a = "+a);

输出结果：![1596190-20190413204411198-1661235309.png][]

# 补充——二元运算规则 20190421 #

1. 整数运算

*  如果两个数有一个为 long，结果类型为 long
 *  两个操作数没有 long 时，不管原来是什么类型，结果为 int 类型

2. 浮点运算

*  如果两个数有一个为 double，结果类型为 double
 *  只有两个数都是 float 的时候，结果才是 float

4. 取余运算

*  取余的余数的正负取决于左边的数

5. 关系运算

*  ==、!= 是所有（基本 & 引用）数据类型都能使用
 *  >、>=、<、<= 只有数值类型（整型和浮点型）以及 char 能够使用。

# 补充——字符串运算符 #

字符串连接符 “+”

之前代码中经常出现 “System.out.println("xx="+a);”，这样的输出语句，为了提示方便，所以我会在输出变量前加上字符串，然后会有一个加号，这个加好就是字符串连接符。

在使用 “+” 运算符连接字符串和 int 型（或 double 型）数据时，“+” 将 int（或 double）型数据自动转换成 String 类型：（遇到字符串后，往后一行全是连接，括号里的除外（谁让括号是老大呢））

System.out.println(3+4);//  7
    System.out.println(3+"4");//   3(连接)"4" = 34
    System.out.println(3+4+"5");//   3（加法）4（连接）"5" = 75
    System.out.println(3+4+3+"4");// 3（加法）4（加法）3（连接） "4" = 104
    System.out.println(3+4+4+"3"+3);//   3（加法）4（加法）4 （连接） "3" （连接）3 = 1133

这个能看懂嘛⁄(⁄⁄•⁄ω⁄•⁄⁄)⁄

字符串连接符还有一个作用：当字符串很长的时候，可以用字符串连接符分成好几行来写：

System.out.println("我太长啦"
            + "真的，"
            + "不得不分成好几行来写！");

当然，+ 号叫字符串连接符，对于 char 字符型来说，它还是加法哈：（a 在编码中为 97）

System.out.println('a');//a
    System.out.println(4+'a');//4+97=101

# \#运算符的优先级 #

当然，当从小学一年级开始慢慢深入学习，我们肯定不会是一直就是要么加要么减的运算了。多个运算符写在一起的时候，肯定会有优先计算的符号，比如加减乘除中，“先乘除后加减，有括号的先算括号里面的。”

Java 中也一样~ 这里再次贴上一个表：

<table>  表 7 - 4 运算符的优先级  
 <tbody> 
  <tr> 
   <td>优先级</td> 
   <td>运算符</td> 
   <td>综合性</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>()&nbsp; &nbsp;[]&nbsp; &nbsp;.</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>!&nbsp; &nbsp;+(正)&nbsp; &nbsp;-(负)&nbsp; &nbsp;~&nbsp; &nbsp;++&nbsp; &nbsp;--</td> 
   <td>从右到左</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>*&nbsp; &nbsp;/&nbsp; &nbsp;%</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>+(加)&nbsp; &nbsp;-(减)</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>&lt;&lt;&gt;&gt;&nbsp; &nbsp;&gt;&gt;&gt;</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>&lt;&lt;=&gt;=&nbsp; &gt;&gt;&nbsp; instanceof</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>==&nbsp; &nbsp;!=</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>&amp;(按位与)</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>^</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>|</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>&amp;&amp;</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>||</td> 
   <td>从左到右</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>? :(三目运算符)</td> 
   <td>从右到左</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>=&nbsp; &nbsp;+=&nbsp; &nbsp;-=&nbsp; &nbsp;*=&nbsp; &nbsp;/=&nbsp; &nbsp;%=&nbsp; &nbsp;&amp;=&nbsp; &nbsp;|=&nbsp; &nbsp;^=&nbsp; &nbsp;~=&nbsp; &nbsp;&lt;&lt;=&gt;&gt;=&nbsp; &nbsp;&gt;&gt;&gt;=</td> 
   <td>从右到左</td> 
  </tr> 
 </tbody> 
</table>

注：　　优先级为 1 的优先级最高，14 为优先级最低。

综合性是指运算符结合的顺序，一般从左到右。

注意区分正负号与加减号的区别。

注 2：emm 哈哈哈，其实不用刻意记这个表，在该打括号的地方打上括号就什么都不怕了！！！

int a = 1 >2 ? (12 - 8) : (67-3);

像这样的，也会方便代码的阅读性。

\--------------------------------------------------

以上，阿里嘎多，20190413 from ahanwhite。

[1596190-20190413162657865-921273141.png]: /images/20220216/67571c7b7c024bd0875a6ef8dcce3784.png
[1596190-20190413163523200-686817576.png]: /images/20220216/a54bd985e10f4b3cbacff3811921d977.png
[1596190-20190413163556938-490824707.png]: /images/20220216/8089ac3fe0a349669e95c4fd3bd473ea.png
[1596190-20190413163832976-1864153379.png]: /images/20220216/ef37eaf652ee4f0ca364510b6c39adfa.png
[16885258-dff03487f61ca78a.png]: /images/20220216/8bf58664074d45548ca44592182143ac.png
[1596190-20190413165434431-421751029.png]: /images/20220216/1fdd26b29fbe4e4e923cf5242ad1c2e0.png
[1596190-20190413165848558-997332376.png]: /images/20220216/0475811b1a094d709a633bfca54450ec.png
[1596190-20190413170210884-156801252.png]: /images/20220216/165fe0e1f92d487490862bb8d205d537.png
[1596190-20190413171511537-1665226379.png]: /images/20220216/0702d210920a4dc099944bd5d0b3c1e3.png
[1596190-20190413184113749-630330560.png]: /images/20220216/0af00639ebbc456aa2cd85bba993700b.png
[1596190-20190413185655426-1417402674.png]: /images/20220216/5757b0bfaed540c5b78d6f6a2a386816.png
[1596190-20190413193934471-552154028.png]: /images/20220216/8a90ca361b194bb0ba5dcda2f8b44eb7.png
[1596190-20190413194043111-1096489258.png]: /images/20220216/bcbe50d43deb468f8157dfd2495659ab.png
[1596190-20190413193820623-1562966851.png]: /images/20220216/e9de5a168a544fe692c7c148b70ad917.png
[1596190-20190413200044792-1089315583.png]: /images/20220216/cb27ccb7e8c940b5b95b48b7edcbf8a6.png
[1596190-20190413200505732-1367977315.png]: /images/20220216/668801d555fb4e3bad0aefe44eb56f23.png
[1596190-20190413200913407-1623324684.png]: /images/20220216/cd9bdcea7b294662a75716f66bd5a426.png
[1596190-20190413201533764-165293483.png]: /images/20220216/73422ecdc3b9497bb3b8cba19157a9d0.png
[1596190-20190413202525362-1320518883.png]: /images/20220216/7a3ba9261d4d4ccca2f8744a7be95a7b.png
[1596190-20190413203346257-453621680.png]: /images/20220216/3012d555d5ef4aa2abda3014575331d6.png
[1596190-20190413203526731-846948182.png]: /images/20220216/aa37dc6403cb480b98d4cf2a85db4436.png
[1596190-20190413204411198-1661235309.png]: /images/20220216/34060f65ac2e47e19711df31c8568410.png