从零学Java（14）之逻辑运算符01

柔情只为你懂 2021-09-22 02:28 322阅读 0赞

# 作者简介 #

> 作者名：编程界明世隐  
> 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA57yW56iL55WM5piO5LiW6ZqQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

# 导航 #

[✪ 从零学Java系列目录索引][_Java]  
[◄上一篇  13.关系运算符][13.]  
►下一篇待更新

# 引言 #

> ♀ 小AD：明哥，好几天没学习了，怎么回事呢？  
> ♂ 明世隐：明哥累了  
> ♀ 小AD：屁，还不知道你，去冲星星了吧，还不叫我，难道非得学Java才带我？  
> ♂ 明世隐：不不不，完全不是你想的那样，不是学Java才能上星星，而且你想上星星就得先学Java。  
> ♀ 小AD：？？？，这不是一个意思吗？我读书少你别骗我。  
> ♂ 明世隐：那怎么会一样呢？学Java才能上星星，这是什么意思呢，这就是“被动”，被逼着学Java。  
> ♀ 小AD：你想上星星就得先学Java，就是因为我先学了Java然后就能上星星，得主动，这意思是不？  
> ♂ 明世隐：对，乖！  
> ♀ 小AD：那个，明哥我想上。。。，哦不，我想学Java。  
> ♂ 明世隐：来来来，今天来学习逻辑运算符。

# 概述 #

逻辑运算符把各个运算符的关系表达式连接起来组成一个相对复杂的逻辑表达式，以判断程序中的表达式是否成立，结果是boolean类型（true/false）。  
在Java中要表达a大于10小于20，需要先拆解为：  
a>10和a<20  
合并来写：a>10&&a<20  
&&就是逻辑运算符，a>10其结果就是boolean类型，不是true就是false，也就是逻辑运算符可以直接连接boolean类型的常量或者变量。

# 分类 #

<table> 
 <thead> 
  <tr> 
   <th>逻辑运算符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>逻辑与，同真为真，一假全假</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>逻辑或，有真为真，全假为假</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>逻辑异或，相同为假，不同为真</td> 
  </tr> 
  <tr> 
   <td>！</td> 
   <td>逻辑非，真假互换</td> 
  </tr> 
 </tbody> 
</table>

# 逻辑与 #

> ♀ 小AD：明哥，啥叫真假，是不是“我真的好想再活500年”的那个“真”。  
> ♂ 明世隐：对，真是那个真，但其实这个结果是假，没人能活500年。  
> ♀ 小AD：那我懂了，就是非此即彼呗，也就是你前面讲过的boolean布尔类型的值，true or flase。  
> ♂ 明世隐：嗯，小家伙掌握的不错吗，没有白费我的苦心，还带你上那么多分。  
> ♀ 小AD：谢明哥，那逻辑与同真为真就是 & 两边都是真的话，那就是真，否则就不是真，对吧。  
> ♂ 明世隐：是的呀，我给你写段代码，你就明白了。

package learnJava;
    
    public class Learn14 { 
    	public static void main(String[] args) { 
    		//& 的两边都是true，结果才是true，否则都是false
    		//两边都是true
    		System.out.println(true&true);//true
    		//先true后false
    		System.out.println(true&false);//false
    		//先false后true
    		System.out.println(false&true);//false
    		//都是false
    		System.out.println(false&false);//false
    	}
    }

运行结果

> true  
> false  
> false  
> false

> ♀ 小AD：明哥，你这样写，我一下就懂了，也就是 & 旁边有一个出现false就肯定是false，只有全部true才是结果true。   
> ♂ 明世隐：对啊，就是这个意思，所以“同真为真，一假全假”  
> ♀ 小AD：嗯，这个我理解了，但程序中不可能这样用的吧，一般不是这样的代码呢  
> ♂ 明世隐：那确实，现在我们就来写一段代码  
> ♀ 小AD：好嘞明哥，明哥加油！

package learnJava.P14;
    
    public class Learn1 { 
    	public static void main(String[] args) { 
    		//& 的两边都是true，结果才是true，否则都是false
    		int a = 10;
    		int b = 20;
    		int c = 30;
    		//a>b为flase b>c 为false 返回false
    		System.out.println(a>b&b>c);
    		//a>b为flase b<c 为true 返回false
    		System.out.println(a>b&b<c);
    		//a<b为true b<c 为true 返回true
    		System.out.println(a<b&b<c);
    	}
    }

运行结果：

> false  
> false  
> true

> ♀ 小AD：也就是& 符号两边计算的结果本身就是要boolean类型的呗  
> ♂ 明世隐：那是必须的  
> ♀ 小AD：那我懂了，我也来写一段代码，明哥来指导一下。  
> ♂ 明世隐：可以，不是那些七七八八的鬼东西吧。  
> ♀ 小AD：那怎么会，当然是很正常的。  
> ♂ 明世隐：我信你一次。

package learnJava.P14;
    
    public class Demo1 { 
    	public static void main(String[] args) { 
    		//& 的两边都是true，结果才是true，否则都是false
    		String ming = "最强王者";
    		String adc = "荣耀黄金";
    	
    		boolean res1=false;
    		boolean res2=false;
    		if("最强王者".equals(ming)){ 
    			res1=true;
    		}
    		if("最强王者".equals(adc)){ 
    			res2=true;
    		}
    		System.out.println("明哥这赛季任务达标了吗？");
    		System.out.println(res1&res2);
    	}
    }

运行结果：

> 明哥这赛季任务达标了吗？  
> false

> ♀ 小AD：明哥，我这代码没毛病吧？  
> ♂ 明世隐：毛病是没毛病，知识点掌握的也不错，就是感觉你代码里有话要说。  
> ♀ 小AD：没有啊，我单纯写个代码。  
> ♂ 明世隐：你就是在暗示。  
> ♀ 小AD：不敢不敢  
> ♂ 明世隐：放心吧了，你先把代码写好了再说   
> ♀ 小AD：哦。知道了。

# 逻辑或 #

> ♂ 明世隐：“有真为真，全假为假”，能看明白不？  
> ♀ 小AD：意思就是只要有true就是true，否则就是false  
> ♂ 明世隐：看来你语文学的不错撒，就是这个意思。  
> ♀ 小AD：老规矩，写个代码给我看看。  
> ♂ 明世隐：那必须的

package learnJava.P14;
    
    public class Learn2 { 
    	public static void main(String[] args) { 
    		//| 的两边有一个true就为true，否则就是false
    		//两边都是true
    		System.out.println(true|true);//true
    		//先true后false
    		System.out.println(true|false);//true
    		//先false后true
    		System.out.println(false|true);//true
    		//都是false
    		System.out.println(false|false);//false
    	}
    }

运行结果：

> true  
> true  
> true  
> false

> ♀ 小AD：这个我懂，一看就明白，只要有一边出现 true就是true，两边都是false才是false。  
> ♂ 明世隐：对，真聪明  
> ♀ 小AD：那我直接写个代码，不需要你举例了。  
> ♂ 明世隐：行，我相信你  
> ♀ 小AD：这就安排

package learnJava.P14;
    
    public class Demo2 { 
    	public static void main(String[] args) { 
    		//| 的两边有一个true就为true，否则就是false
    		String java = "小菜鸟";//小AD的java水平
    		String wangzhe = "荣耀黄金";//小AD的王者水平
    	
    		boolean res1=false;
    		boolean res2=false;
    		if("最强王者".equals(java)){ 
    			res1=true;
    		}
    		if("最强王者".equals(wangzhe)){ 
    			res2=true;
    		}
    		System.out.println("明哥这赛季任务达标了吗？");
    		System.out.println(res1 | res2);
    	}
    }

运行结果：

> 明哥这赛季任务达标了吗？  
> false

> ♂ 明世隐：行啊你，我真服你了，代码用的炉火纯青了吧。  
> ♀ 小AD：没有没有，要多向明哥学习、  
> ♂ 明世隐：你这用代码变着法暗示呢？还没有。  
> ♀ 小AD：我就是写真顺手  
> ♂ 明世隐：看来不需要明哥教Java和带王者了吧。  
> ♀ 小AD：哪能，明哥YYDS。  
> ♂ 明世隐：算你识相，下一个吧，大聪明  
> ♀ 小AD：O滴K

# 逻辑异或 #

♂ 明世隐：“相同为假，不同为真”，这样很好理解咯。  
♀ 小AD：那就是两边不一样就为真咯。  
♂ 明世隐：是的，上代码看看

package learnJava.P14;
    
    public class Learn4 { 
    	public static void main(String[] args) { 
    		//^ 两边不同为true，相同是false
    		//两边都是true
    		System.out.println(true^true);//false
    		//先true后false
    		System.out.println(true^false);//true
    		//先false后true
    		System.out.println(false^true);//true
    		//都是false
    		System.out.println(false^false);//false
    	}
    }

运行结果：

> false  
> true  
> true  
> false

> ♀ 小AD：明哥，这就是两边不能相同咯，同性相斥，是这个意思吧。  
> ♂ 明世隐：额。。。是吧，现在的年轻人，说话我老年人顶不住。  
> ♀ 小AD：没有啊，没有什么难以理解的话呀。  
> ♂ 明世隐：得，这次到我来举个例子吧，每次都是你搞事情。  
> ♀ 小AD：明哥，抢我表现的机会。  
> ♂ 明世隐：你表现的还少吗？  
> ♀ 小AD：好，行，你来。

package learnJava.P14;
    
    public class Demo3 { 
    	public static void main(String[] args) { 
    		String ming = "最强王者";
    		String adc = "荣耀黄金";
    	
    		boolean res1=false;
    		boolean res2=false;
    		if("最强王者".equals(ming)){ 
    			res1=true;
    		}
    		if("最强王者".equals(adc)){ 
    			res2=true;
    		}
    		System.out.println("明哥这赛季任务达标了吗？");
    		System.out.println(res1^res2);
    	}
    }

运行结果：

> 明哥这赛季任务达标了吗？  
> true

> ♀ 小AD：明哥，你这就没意思了吧，照抄我代码。  
> ♂ 明世隐：这就合理利用资源，不要浪费。  
> ♀ 小AD：行吧，算你厉害。  
> ♂ 明世隐：还不是被我拿捏了，小样。  
> ♀ 小AD：。。。。。。

# 逻辑非 #

> ♂ 明世隐： “真假互换”，这个应该好理解，就是加上 !后，真的就变假，假的就变真了。  
> ♀ 小AD：真假美猴王？  
> ♂ 明世隐：别扯好吧，正经点  
> ♀ 小AD：那你举个实例吧

package learnJava.P14;
    
    public class Learn5 { 
    	public static void main(String[] args) { 
    		System.out.println(!true);//false
    		System.out.println(!false);//true
    	}
    }

运行结果：

> false  
> true

> ♂ 明世隐：这个应该很好看明白吧  
> ♀ 小AD：嗯，我明白了，不就是true加一个!在前面就变成false，false加一个!在前面就变成了true，好简单的。  
> ♂ 明世隐：那又来举个例子  
> ♀ 小AD：那是肯定的呀，走你！

package learnJava.P14;
    
    public class Demo4 { 
    	public static void main(String[] args) { 
    		String ming = "最强王者";
    		String adc = "荣耀黄金";
    	
    		boolean res1=false;
    		boolean res2=false;
    		if("荣耀王者".equals(ming)){ 
    			res1=true;
    		}
    		if(!"最强王者".equals(adc)){ 
    			res2=true;
    		}
    		System.out.println("明哥这赛季任务达标了吗？");
    		System.out.println(res1);
    		System.out.println("小AD这赛季任务达标了吗？");
    		System.out.println(res2);
    	}
    }

运行结果：

> 明哥这赛季任务达标了吗？  
> false  
> 小AD这赛季任务达标了吗？  
> true

> ♂ 明世隐：哦豁，果然是这样，站在学Java这方面来讲还是很不错的。  
> ♀ 小AD：那站在别的角度呢？  
> ♂ 明世隐：你就是找打。  
> ♀ 小AD：哥我不敢，我就想要3个小星星，不多，不过分！  
> ♂ 明世隐：行吧，看你今天还挺活跃，得嘞，走吧。  
> ♀ 小AD：timi

# 小结 #

这节总结了“逻辑运算符01”，希望能对大家有所帮助，请各位小伙伴帮忙 【点赞】\+【收藏】\+ 【评论区打卡】， 如果有兴趣跟小明哥一起学习Java的，【关注一波】不迷路哦。

评论区打卡一波让我知道你，明哥会持续关注你的学习进度哦！

# 导航 #

[✪ 从零学Java系列目录索引][_Java]  
[◄上一篇  13.关系运算符][13.]  
►下一篇待更新

# 热门专栏推荐 #

[1.Java小游戏系列（俄罗斯方块、飞机大战、植物大战僵尸等）][1.Java]  
[2.JavaWeb项目实战（图书管理、在线考试、宿舍管理系统等）][2.JavaWeb]  
[3.JavaScript精彩实例（飞机大战、扫雷、贪吃蛇、验证码等）][1.Java]  
[4.Java小白入门200例][4.Java_200]  
[5.从零学Java、趣学Java、以王者荣耀角度学Java][5._Java_Java_Java]

# 另外 #

为了帮助更多小白从零进阶Java工程师，从CSDN官方那边搞来了一套 《Java 工程师学习成长知识图谱》，尺寸 870mm x 560mm，展开后有一张办公桌大小，也可以折叠成一本书的尺寸，原件129元现价 29 元，先到先得，有兴趣的小伙伴可以了解一下！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RrbTEyMzQ1Ng_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA57yW56iL55WM5piO5LiW6ZqQ_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20210920/99cb87b7856a4d38b208b16d10754fbe.png
[_Java]: https://blog.csdn.net/dkm123456/article/details/119947298
[13.]: https://blog.csdn.net/dkm123456/article/details/119394138
[1.Java]: https://blog.csdn.net/dkm123456/category_11085592.html
[2.JavaWeb]: https://blog.csdn.net/dkm123456/category_11085433.html
[4.Java_200]: https://blog.csdn.net/dkm123456/category_11268762.html
[5._Java_Java_Java]: https://blog.csdn.net/dkm123456/category_11168573.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RrbTEyMzQ1Ng_size_16_color_FFFFFF_t_70_pic_center]: /images/20210920/619e2b5046e142bb80654d771b4f5064.png