您现在的位置是：首页 > Java

当前栏目

【Java基础】运算符

JAVA 基础输出

2023-03-02 11:00:45 时间

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

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

一元运算符就是只有一个元素参加的运算，如【 !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

猜你喜欢

WebGL 着色器偏导数dFdx和dFdy介绍
JavaScript 一元正号运算符
JavaScript展开操作符(Spread operator)介绍
绕圆弧动画的向量解决方式
程序员进阶之道（一）
JavaScript 转换数字为整数的方法
给面试者的一点建议
春节过年见闻录
canvas反向裁剪技巧
canvas 绘制双线技巧
如何优雅的构建排序公式
canvas高效绘制10万图形,你必须知道的高效绘制技巧
WebGL2系列之实例数组(Instanced Arrays)
Linux命令对应的英文及整体学习法
分享两个故事
前端内存泄漏的分析案例
JavaScript指定断点操作
年轻程序员如何快速成长
nodejs的路径问题
发现一个可以赚钱的手机应用

zl程序教程

当前栏目

【Java基础】运算符

相关文章