Java教程

第二章、Java基本语法(上):变量与运算符

本文主要是介绍第二章、Java基本语法(上):变量与运算符,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java基本语法(上)

1.1 关键字

1.1.1、关键字的定义与特点

定义:被Java语言赋予了特殊含义,用做专门用途的字符串(单词)

特点:关键字中所有字母都为小写

1.1.2、所有的关键字在这里插入图片描述

在这里插入图片描述

1.2 保留字

1.2.1 保留字的定义

  • Java保留字:现有Java版本尚未使用,但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字

  • 现有两个保留字:goto 、const

1.3 标识符

1.3.1 标识符的定义

标识符:Java 对各种变量、方法和类等要素命名时使用的字符序列

1.3.2 标识符命名的规则

  • 由26个英文字母大小写,0-9 ,_或 $ 组成
  • 数字不可以开头。
  • 不可以使用关键字和保留字,但能包含关键字和保留字。
  • Java中严格区分大小写,长度无限制。
  • 标识符不能包含空格。

注意:如果不遵守如下的规则,编译不通过!需要大家严格遵守

1.3.3 Java中的名称命名规范

  • 包名:多单词组成时所有字母都小写:xxxyyyzzz
  • 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
  • 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
  • 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

注意:如果不遵守如下的规范,编译可以通过!建议大家遵守

1.3.4 标识符命名代码演示

package com.atguigu.java1;

/*
1. 标识符的命名规则:--->如果不遵守如下的规范,编译不用过通过! 一定要遵守

> 由26个英文字母大小写,0-9 ,_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字,但能包含关键字和保留字。
> Java中严格区分大小写,长度无限制。
> 标识符不能包含空格。

Java中的名称命名规范: --->如果不遵守如下的规范,编译可以通过!建议大家遵守

包名:多单词组成时所有字母都小写:xxxyyyzzz
类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ


*/
public class IdentifierTest {
	public static void main(String[] args) {
		
	}
}

class Aa1_${
	
}

//class 1A{ 数字不能打头
//	
//}

//class static{ // 不能使用关键字
//	
//}

//class const{  // 不能使用保留字
//	
//}

class publicstatic{ // 可以包含关键字保留字
	
}

class A{ // 严格区分大小写
	
}

class a{ // 严格区分大小写
	
}

1.4 变量

1.4.1 变量的定义

  • 定义:
    • 内存中的一个存储区域。
    • 该区域的数据可以在同一类型范围内不断变化(其数据值可以改变的量)。
    • 变量是程序中最基本的存储单元。

1.4.2 变量的三要素

  • 数据类型

  • 变量名

1.4.3 变量的作用

作用:用于在内存中保存数据

1.4.4 变量的使用

1.4.4.1 变量的定义格式

1.变量的声明:
    数据类型 变量名;
2.变量的赋值:
	变量名 = 数据值;
3.变量声明的同时初始化值:
	数据类型 变量名 = 数据值;

1.4.4.2 变量的使用的注意点(变量的代码演示)

package com.atguigu.java1;

/*
变量的使用

 说明:
   ① 变量必须先声明,后使用
   ② 变量都定义在其作用域内。在作用域内,它是有效的。换句话说,出了作用域,就失效了
   ③ 同一个作用域内,不可以声明两个同名的变量
   ④使用变量名来访问这块区域的数据

注意:此时研究的是局部变量。
	  局部变量应声明且初始化后才能使用。
*/
public class VariableTest1 {
	public static void main(String[] args) {
		// 变量的定义
		int age = 12;
		// 变量的使用
		System.out.println(age); // 通过变量名来访问这块区域
		
		//变量必须先声明后使用
//		System.out.println(name); // name cannot be resolved to a variable(未声明name)
		// 变量的声明
		String name;
//		System.out.println(name); // The local variable name may not have been initialized (局部变量name要初始化了才能使用)
		name = "卢本伟";
		System.out.println(name);
		
		// 变量的作用域
//		System.out.println(myClassNumber); // myClassNumber cannot be resolved to a variable 在main方法这块区域没声明过myClassNumber
		
		// 同一个作用域内,不可以声明两个同名的变量
//		String name = "周淑怡"; // Duplicate local variable name (重复定义name)
	}
	
	public void method(){
		int myClassNumber = 1;
	}
}

1.4.5 变量的分类

1.4.5.1按数据类型来分

在这里插入图片描述

1.4.5.1按声明的位置的不同来分

在这里插入图片描述

1.5 常量(constant

1.5.1 常量的定义

常量:在程序执行的过程中,其值不可以发生改变的量

1.5.2 常量的分类

  • 常量的分类:

    • 自定义常量:通过final关键字定义(后面在面向对象部分讲解)

    • 字面值常量:

      字面值常量举例
      字符串常量”HelloWorld“
      整数常量12,-23
      浮点常量12.34
      字符常量‘a’,‘0’,‘我’
      布尔常量true,false
      空常量null

1.5.3 常量的代码演示

package com.atguigu.java1;

/*
 * 	常量:
 *		自定义常量:通过final关键字定义(后面在面向对象部分讲解)
 *
 *		字面值常量:字符串常量、基本类型那几种常量(整型常量、浮点型常量。。。)、空常量(null)
 */
public class ConstantTest {
	public static void main(String[] args) {
		
		// 字符串常量
		System.out.println("卢本伟");
		
		// 整型常量
		System.out.println(26);
		System.out.println(-26);
		
		// 浮点型常量
		System.out.println(-23.3);
		System.out.println(23.3);
		
		// char型常量
		 //字符常量,单引号里面有且仅有一个字符
       
		System.out.println('1');
		System.out.println('a');
		System.out.println('中');
		
		// 布尔型常量
		System.out.println(true);
		System.out.println(false);
		
		 //空常量,不可以在输出语句中直接打印
//		System.out.println(null);
		
	}

}

注意事项:!!!

字符常量,单引号里面有且仅有一个字符

空常量,不可以在输出语句中直接打印

1.6 数据类型

1.6.1 数据类型的分类

在这里插入图片描述

1.6.2 基本数据类型

  • bit: 计算机中的最小存储单位。
  • byte:计算机中基本存储单元。

1.6.2.1 整型:byte、short、int、long

  • Java各整数类型有固定的表数范围和字段长度,不受具体OS的影响,以保证java程序的可移植性。
  • java的整型常量默认为 int 型,声明long型常量须后加‘l’或‘L’
  • java程序中变量通常声明为int型,除非不足以表示较大的数,才使用long

在这里插入图片描述

1.6.2.2 浮点型:float、double

  • 与整数类型类似,Java 浮点类型也有固定的表数范围和字段长度,不受具体操作系统的影响。
  • float:单精度,尾数可以精确到7位有效数字。很多情况下,精度很难满足需求。
  • double:双精度,精度是float的14~15。通常采用此类型。
  • Java 的浮点型常量默认为double型。
  • 声明float型常量,须后加‘f’或‘F’。

在这里插入图片描述

1.6.2.3 字符型:char

  • char 型数据用来表示通常意义上“字符”(2字节)
  • Java中的所有字符都使用Unicode编码,故一个字符可以存储一个字 母,一个汉字,或其他书面语的一个字符。
  • 字符型变量的四种表现形式:详细看代码
  • char类型是可以进行运算的。因为它都对应有Unicode码。

1.6.2.4 布尔型:boolean

  • 只能取2个值:true、false
  • 常常在条件判断、循环结构中使用

1.6.3 数据类型代码演示

package com.atguigu.java1;

/*
 * 八种基本数据类型
 * 整型:byte、short、int、long
 * 浮点型:float、double
 * 字符型:char
 * 布尔型:boolean
 * 
 */
public class VariableTest2 {
	public static void main(String[] args) {
		// 整型:表示整数
		// 整型: byte(1个字节 = 8个bit)、short(2个字节)、int(4个字节)、long(8个字节)
		// byte的范围:-128 ~ 127
		byte b1 = 12;
		byte b2 = 127;
//		byte b3 = 128; // 报错,超过byte的取值范围
		
		short s1 = 123;
		
		// 通常,定义整型变量时,使用int型。 
		// 整型的默认类型为:int
		int i1 = 12345;
		System.out.println(i1);
		
		// 声明long型变量,必须以"l"或"L"结尾
		long l1 = 123456789L;
		long l2 = 123;// 为什么long型没加L结尾也没有报错,因为整型的默认类型为int,自动类型转换为long
        //long l3 = 11561651561615656; // 超过了int的取值范围就不能自动类型转换了,须手动添加L
		long l3 = 11561651561615656L;
		System.out.println(l1);
		System.out.println(l2);
		
		//****************************************************************************
		
		// 浮点型:表示小数
		// 浮点型:float(4个字节)、double(8个字节)
		//float的取值范围比long的取值范围要大
		// 为什么float和long同样是4个字节,但是float的取值范围比long要大?  二者底层存储方式不一样
		
		// 定义float类型变量时,变量要以"f"或"F"结尾
		float f1 = 12.3F;
		System.out.println(f1);
		
		// 通常,定义浮点型变量时,使用double型。
		// 浮点型的默认数据类型为:boolean
		double d1 = 12.3;
		System.out.println(d1);
	
		//****************************************************************************
		
		// 字符型:char(2个字节)
		// 定义char型变量,通常使用一对'',内部有且仅有有一个字符
		// char c1 = 'ab'; 报错
		
		// 字符型四种定义方式:
		// ①一个字符
		char c2 = 'a';
		char c3 = '中';
		System.out.println(c2);
		System.out.println(c3);
		
		// ②转义字符
		char c4 = '\n';
		char c5 = '\r';
		
		// ③\ u字符的Unicode编码值的十六进制型
		char c6 = '\u5c1a';
		System.out.println(c6);
		
		// ④直接给char类型变量赋值十进制的0~65535之间的Unicode编码值
		char c7 = 97;// a
		System.out.println(c7);
		
		//****************************************************************************
		
		// 布尔型:boolean
		// 只能取2个值:true、false
		// 常常在条件判断、循环结构中使用
		boolean isMarried = true;
		if(isMarried){
			System.out.println("你已经结婚了,不能参加单身派对了");
		}else{
			System.out.println("你可以多谈谈恋爱");
		}
	}
}

1.7 基本数据类型——自动类型转换

1.7.1 自动类型转换的定义

  • 自动类型转换:容量小的类型自动转换为容量大的数据类型
  • 说明:此时的容量大小指的是,表示数的范围的大和小。比如:float容量要大于long的容量

1.7.2 自动类型转换适用前提

适用前提:这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1.7.3 自动类型转换规则

  • 结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时,结果自动提升为容量大的数据类型。
  • byte 、char 、short --> int --> long --> float --> double
  • 特别的:当byte、char、short三种类型的变量做运算时,结果为int型
  • 自动类型转换的三种转换形式
    • 当把存储范围小的值(常量值、变量的值、表达式计算的结果值)赋值给了存储范围大的变量时
    • 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时,会按照其中最大的类型运算
    • 当byte,short,char数据类型进行算术运算时,按照int类型处理

1.7.4 自动类型转换代码演示

package com.atguigu.java1;

/*
基本数据类型之间的运算规则:

前提:这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升:
    结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时,结果自动提升为容量大的数据类型。
	byte 、char 、short --> int --> long --> float --> double 

	特别的:当byte、char、short三种类型的变量做运算时,结果为int型
	
2. 强制类型转换:见VariableTest3.java


说明:此时的容量大小指的是,表示数的范围的大和小。比如:float容量要大于long的容量
*/
public class VariableTest3 {
	public static void main(String[] args) {
		
		// 当把存储范围小的值(常量值、变量的值、表达式计算的结果值)赋值给了存储范围大的变量时
		byte b1 = 12;
		int i1 = 123;
		
        //b1 = b1 + 1;// 1是int型,右边整体是int型,编译报错
//		byte b2 = i1 + b1;// 超出byte的范围,报错
		
		int i2 = i1 + b1;
		long l1 = i1 + b1;
		System.out.println(i2);
		System.out.println(l1);
		
		// 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时,会按照其中最大的类型运算
		byte b2 = 6;
		int i3 = 125;
		double d1 = 12.3;
		
		double sum = b2 + i3 + d1; // 结果转为double
		System.out.println(sum); 
		
		// 当byte,short,char数据类型进行算术运算时,按照int类型处理
		byte b3 = 12;
		char c1 = 32;
		short s1 = 25;
		
//		short s2 = b3 + s1; // 报错
//		char c2 = s1 + c1;// 报错
	
		int i4 = b3 + c1 + s1;
		System.out.println(i4);
		
	}
}

1.8 基本数据类型——强制类型转换

1.8.1 强制类型转换的定义

强制类型转换:将容量大的数据类型转换为容量小的数据类型。

1.8.2 强制类型转换使用规则

  • 强制转换符:()
  • **可能**造成精度降低或溢出

1.8.3 强制类型转换代码演示

package com.atguigu.java1;

/*
强制类型转换:自动类型提升运算的逆运算。
1.需要使用强转符:()
2.注意点:强制类型转换,可能导致精度损失。

*/
public class VariableTest4 {
	public static void main(String[] args) {
		
		// 损失精度示例1
		double d1 = 12.34;//截断操作
		int i1 = (int)d1;
		System.out.println(i1);// 12
		
		// 损失精度示例2
		int i2 = 128;
		byte b1 = (byte)i2;
		System.out.println(b1); // -128
		
		// 没有损失精度
		long l1 = 123L;
		short s1 = (short)l1;
		System.out.println(s1); // 123
	}
}

1.9 String简述

1.9.1 String的使用规则

  • String属于引用数据类型,翻译为:字符串
  • 声明String类型变量时,使用一对""
  • String可以和8种基本数据类型变量做运算,且运算只能是连接运算:+ ,运算的结果仍然是String类型

1.9.2 String代码演示

package com.atguigu.java1;

/*
String类型变量的使用
1. String属于引用数据类型,翻译为:字符串
2. 声明String类型变量时,使用一对""
3. String可以和8种基本数据类型变量做运算,且运算只能是连接运算:+ ,运算的结果仍然是String类型

*/
public class StringTest {
	public static void main(String[] args) {

		// String的定义:
		String s1 = "Hello,world!";
		String s2 = "a";
		String s3 = "";// 空串

		// String的运算
		int number = 1001;
		String numberStr = "学号:";
		String str1 = numberStr + number; // 只要与字符串运算,结果必然是字符串
		System.out.println(str1);

		// ***********************
		// 考察:char与基本数据类型运算时,化为其ASCII码值
		// 练习1
		char c = 'a';// 97 A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);// 107hello
		System.out.println(c + str + num);// ahello10
		System.out.println(c + (num + str));// a10hello
		System.out.println((c + num) + str);// 107hello
		System.out.println(str + num + c);// hello10a

		// 练习2
		// * *
		System.out.println("*	*");
		System.out.println('*' + '\t' + '*');
		System.out.println('*' + "\t" + '*');
		System.out.println('*' + '\t' + "*");
		System.out.println('*' + ('\t' + "*"));
	}
}

1.9 进制

1.9.1 进制在Java中的表示

  • 对于整数,有四种表示方式:
  • 二进制(binary):0,1 ,满2进1.以0b或0B开头。
  • 十进制(decimal):0-9 ,满10进1。
  • 八进制(octal):0-7 ,满8进1. 以数字0开头表示。
  • 十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。

1.9.2 进制代码演示

package com.atguigu.java1;

/*
 对于整数,有四种表示方式:
 二进制(binary):0,1 ,满2进1.以0b或0B开头。
 十进制(decimal):0-9 ,满10进1。
 八进制(octal):0-7 ,满8进1. 以数字0开头表示。
 十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
 
    如:0x21AF +1= 0X21B0
 */
public class BinaryTest {
	public static void main(String[] args) {

		int i1 = 0b10; 	//二进制
		int i2 = 010;	//八进制
		int i3 = 10;	//十进制
		int i4 = 0x10;	//十六进制
		
		// 输出时,都以十进制位数输出
		System.out.println(i1);
		System.out.println(i2);
		System.out.println(i3);
		System.out.println(i4);
	}
}

1.10 运算符

  • 表达式:用运算符连接起来的式子

1.10.1 算数运算符

+(正号)
-(减号)
+(加号)
-(减号)
*(乘)
/(除)
%(取模)
(前)++
(后)++
(前)--
(后)--
+:字符串连接

具体内容看代码

1.10.1.1 算数运算符代码演示:

package com.atguigu.java2;

/*
 * 算数运算符
 * 
 * + -   + - * / % (前)++ (后)++ (前)-- (后)-- +
 */
public class AriTest {
	public static void main(String[] args) {
		// +(正号)
		int i1 = +12;
		// -(减号)
		int i2 = -12;
		System.out.println(i1);
		System.out.println(i2);

		//***********************************************************
		
		// +(加号)
		int i3 = 13;
		int i4 = 15;
		System.out.println(i3 + i4);
		// -(减号)
		System.out.println(i3 - i4);
		// *(乘)
		System.out.println(i3 * i4);
		
		//***********************************************************

		// / (除)
		// 整数之间做除法时,只保留整数部分而舍弃小数部分。
		int i5 = 12;
		int i6 = 5;
		System.out.println(i5 / i6); // 2 (舍去小数部分)
		System.out.println(i5 / i6 * i6); // 10
		// 整数之间做除法时,只保留整数部分而舍弃小数部分。 即使我使用double接收也没有用
		double d1 = i5 / i6;
		System.out.println(d1);
		// 那怎么才能使得数变成2.4,那么我就要从等号右边做文章
		// 把其中一个数变成浮点型就好了
		double d2 = (double) i5 / i6;
		double d3 = i5 / (double) i6;
		System.out.println(d2);
		System.out.println(d3);
		
		//***********************************************************
		
		// %(取模)
		// 结果的符号与被模数的符号相同
		// 开发中,经常使用%来判断能否被除尽的情况。
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2); // -2
		
		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);

		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4); // -2
		
		//***********************************************************

		// (前)++:先自增一,后运算
		// (后)++:先运算,后自增一
		int a1 = 10;
		int a2 = ++a1;
		System.out.println("a1 = " + a1 + " a2 = " + a2);

		int a3 = 10;
		int a4 = a3++;
		System.out.println("a3 = " + a3 + " a4 = " + a4);
		
		int a5 = 10;
		a5++;// ++a5   (这种情况这样写,无论如何都会自增一)
		System.out.println(a5);
		
		// 区分一下例子
		short s1 = 10;
//		s1 = s1 + 1; // 报错
		s1++; // 不会改变自身的数据类型
		System.out.println(s1);
		
		//***********************************************************
		
		// (前)--
		// (后)--
		 // 与 ++同理
		
		//***********************************************************
		
		// +:字符串连接
		String myNumber = "学号:";
		int number = 1001;
		System.out.println(myNumber + number);
		
	}
}

1.10.2 赋值运算符

注意:所有的赋值运算符的=左边一定是一个变量

赋值运算符符号解释
=将符号右边的值,赋值给左边的变量
+=将符号**左边的值右边的值进行相加操作,最后将结果赋值给左边的变量**
-=将符号**左边的值右边的值进行相减操作,最后将结果赋值给左边的变量**
*=将符号**左边的值右边的值进行相乘操作,最后将结果赋值给左边的变量**
/=将符号**左边的值右边的值进行相除操作,最后将结果赋值给左边的变量**
%=将符号**左边的值右边的值进行取余操作,最后将结果赋值给左边的变量**
  • += -= *= /= %= (扩展赋值运算符)
  • 扩展赋值运算符在将最后的结果赋值给左边的变量前,都做了一步强制类型转换

1.10.2.1 赋值运算符代码演示

package com.atguigu.java2;

/*
运算符之二:赋值运算符
= 
 
+=  -=  *=  /=  %= (扩展赋值运算符)

*/
public class SetValueTest {
	public static void main(String[] args) {
		// =
		int i1 = 10;
		// 连续赋值
		int i2, i3;
		i2 = i3 = 10;
		int i4 = 10, i5 = 10;

		// ***********************************************************
		// 扩展赋值运算符在将最后的结果赋值给左边的变量前,都做了一步强制类型转换。

		// +=
		int j1 = 10;
		j1 += 5;// 相当于 j1 = j1 + 5
		System.out.println(j1);

		short s1 = 10;
		// s1 = s1 + 1; // 报错
		s1 += 1; // 编译通过,且没有改变s1的数据类型
		// 因为在得到int类型的结果后,JVM自动完成一步强制类型转换,将int类型强转成short
		
		// ***********************************************************
		
		// -=
		int j2 = 10;
		j2 -= 2;
		System.out.println(j2);
		
		// ***********************************************************
		
		// /=
		int j3 = 10;
		j3 /= 2;
		System.out.println(j3);
		
		// ***********************************************************

		// %=
		int j4 = 10;
		j4 %= 3;
		System.out.println(j4);
		
		// ***********************************************************

		// 开发中,如果希望变量实现+2的操作,有几种方法?(前提:int num = 10;)
		// 方式一:num = num + 2;
		// 方式二:num += 2; (推荐)

		// 开发中,如果希望变量实现+1的操作,有几种方法?(前提:int num = 10;)
		// 方式一:num = num + 1;
		// 方式二:num += 1;
		// 方式三:num++; (推荐)

	}
}

1.10.3 比较运算符

关系运算符符号解释
<比较符号左边的数据是否小于右边的数据,如果小于结果是true。
>比较符号左边的数据是否大于右边的数据,如果大于结果是true。
<=比较符号左边的数据是否小于或者等于右边的数据,如果大于结果是false。
>=比较符号左边的数据是否大于或者等于右边的数据,如果小于结果是false。
==比较符号两边数据是否相等,相等结果是true。
!=不等于符号 ,如果符号两边的数据不相等,结果是true。
instanceof检查左边数据是否是类的对象,如果是结果为true
  • 比较运算符,是两个数据之间进行比较的运算,运算结果一定是boolean值true或者false

  • 其中>,<,>=,<=不支持boolean,String类型,==和!=支持boolean和String。

  • 上面的一个说明换句话说

    • > ,<,>=,<= 只能使用在数值类型的数据之间
    • == 和 != 不仅可以使用在数值类型数据之间,还可以使用在其他引用类型变量之间。
  • 区分 == 和 =

1.10.3.1 比较运算符代码演示

package com.atguigu.java2;

/*
运算符之三:比较运算符
==  !=  >  <  >= <=  instanceof

结论:
1.比较运算符的结果是boolean类型
2.区分 ==  和  = 
3.>  <  >=  <= :只能使用在数值类型的数据之间。
4. == 和 !=: 不仅可以使用在数值类型数据之间,还可以使用在其他引用类型变量之间。

*/

public class CompareTest {
	public static void main(String[] args) {
		
		// 区分 == 和 =
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);
		System.out.println(i1 = i2); // 20
		
		int i3 = 10;
		int i4 = 20;
		System.out.println(i3 == i4);
		System.out.println(i3 != i4);
		System.out.println(i3 > i4);
		System.out.println(i3 < i4);
		System.out.println(i3 >= i4);
		System.out.println(i3 <= i4);
		
		
	}
}

1.10.4 逻辑运算符

在这里插入图片描述

  • 逻辑运算符操作的都是boolean类型的变量,其结果也是boolean类型
  • && 与 &的区别
    • 相同点1:& 与 && 的运算结果相同
    • 相同点2:当符号左边是true时,二者都会执行符号右边的运算
    • 不同点:当符号左边是false时,&继续执行符号右边的运算。&&不再执行符号右边的运算。
    • 开发中,推荐使用&&
  • || 与 |的区别
    • 相同点1:| 与 || 的运算结果相同
    • 相同点2:当符号左边是false时,二者都会执行符号右边的运算
    • 不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
    • 开发中,推荐使用||

1.10.4.1 逻辑运算符代码演示

package com.atguigu.java2;

/*
运算符之四:逻辑运算符

&  && |  || ! ^

说明:
1.逻辑运算符操作的都是boolean类型的变量
2.其运算结果也是boolean类型

*/

public class LogicTest {
	public static void main(String[] args) {

		boolean bool1 = false;
		boolean bool2 = true;
		// !
		System.out.println(!bool2);
		// ^
		System.out.println(bool1 ^ bool2);

		// *****************************************

		// 区分& 与 &&
		// 相同点1:& 与 && 的运算结果相同
		// 相同点2:当符号左边是true时,二者都会执行符号右边的运算
		// 不同点:当符号左边是false时,&继续执行符号右边的运算。&&不再执行符号右边的运算。
		// 开发中,推荐使用&&

		// &
		boolean b1 = true;
		b1 = false;
		int i1 = 10;
		if (b1 & (i1++ > 0)) {
			System.out.println("我在北京");
		} else {
			System.out.println("我在广州");
		}
		System.out.println("i1 = " + i1);

		// &&
		boolean b2 = true;
		b2 = false;
		int i2 = 10;
		if (b2 && (i2++ > 0)) {
			System.out.println("我在北京");
		} else {
			System.out.println("我在广州");
		}

		System.out.println("i2 = " + i2);

		// *****************************************

		// 区分:| 与 ||
		// 相同点1:| 与 || 的运算结果相同
		// 相同点2:当符号左边是false时,二者都会执行符号右边的运算
		// 不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
		// 开发中,推荐使用||
		
		boolean b3 = false;
		b3 = true;
		int i3 = 20;
		
		if(b3 | (i3++ > 0)){
			System.out.println("我在深圳");
		}else{
			System.out.println("我在上海");
		}
		System.out.println("i3 = " + i3);
		
		boolean b4 = false;
		b4 = true;
		int i4 = 20;
		
		if(b4 || (i4++ > 0)){
			System.out.println("我在深圳");
		}else{
			System.out.println("我在上海");
		}
		System.out.println("i4 = " + i4);

	}
}

1.10.5 位运算符

位运算符符号解释
&按位与,当两位相同时为1时才返回1
|按位或,只要有一位为1即可返回1
~按位非,将操作数的每个位(包括符号位)全部取反
^按位异或。当两位相同时返回0,不同时返回1
<<左移运算符
>>右移运算符
>>>无符号右移运算符

1.10.5.1 位运算符细节

在这里插入图片描述

1.10.5.2 位运算符代码演示

package com.atguigu.java2;

/*
运算符之五:位运算符 (了解)

& | ^ ~
<< >> >>>

结论:
1. 位运算符操作的都是整型的数据
2. << :在一定范围内,每向左移1位,相当于 * 2
   >> :在一定范围内,每向右移1位,相当于 / 2

面试题:最高效方式的计算2 * 8 ?  2 << 3  或 8 << 1
*/
public class BitTest {
	public static void main(String[] args) {
		
		// & | ^ ~
		int i1 = 12;
		int i2 = 5;
		// 把数据化成二进制,按位操作
		System.out.println(i1 & i2);
		System.out.println(i1 | i2);
		System.out.println(i1 ^ i2);
		System.out.println(~i2);
		
		//******************************************
		
		// <<:在一定范围内,每向左移1位,相当于 * 2(在二进制的层面,左移)
		int i3 = 12;
		System.out.println(i3 << 2);
		
		// 超出范围会变成一个极大或极小的数
		System.out.println(i3 << 28); // -1073741824
		
		//******************************************
		
		// >>:>> :在一定范围内,每向右移1位,相当于 / 2
		// 被移位的二进制最高位是0,右移后,空缺位补0; 最高位是1,空缺位补1。
		
		int i4 = 12;
		int i5 = -12;
		System.out.println(i4 >> 2);
		System.out.println(i5 >> 2);
		
		// >>>:被移位二进制最高位无论是0或者是1,空缺位都用0补。
		int i6 = 5;
		int i7 = -5;
		System.out.println(i6 >>> 2);
		System.out.println(i7 >>> 2); // 1073741822
		


	}
}

1.10.5.3 交换两个数的三种方式

package com.atguigu.java2;

/*
 *  交换两个数
 *  
 *  
 */
public class Swap {

	public static void main(String[] args) {

		// 方式一:使用临时变量
		int i = 10;
		int j = 20;

		System.out.println("i = " + i + " j = " + j);

		int temp = i;
		i = j;
		j = temp;

		System.out.println("i = " + i + " j = " + j);

		// ***********************************************

		// 方式二:好处:不用定义临时变量
		// 弊端:① 相加操作可能超出存储范围 ② 有局限性:只能适用于数值类型

		int i1 = 10;
		int j1 = 20;

		System.out.println("i1 = " + i1 + " j1 = " + j1);

		i1 = i1 + j1;
		j1 = i1 - j1;
		i1 = i1 - j1;

		System.out.println("i1 = " + i1 + " j1 = " + j1);

		// ***********************************************
		// 方式三:使用位运算符
		// 有局限性:只能适用于数值类型
		int i2 = 10;
		int j2 = 20;

		System.out.println("i2 = " + i2 + " j2 = " + j2);

		i2 = i2 ^ j2;
		j2 = i2 ^ j2;
		i2 = i2 ^ j2;

		System.out.println("i2 = " + i2 + " j2 = " + j2);
	}

}

1.10.6 三元运算符

  • 三元运算符格式:
(条件表达式)?表达式1:表达式2
  • 条件表达式的结果为boolean类型
  • 三元运算符计算方式:
    • 条件判断的结果是true,条件运算符整体结果为表达式1,赋值给变量。
    • 判断条件的结果是false,条件运算符整体结果为表达式2,赋值给变量。
  • 表达式1和表达式2要求是一致的(兼容,类型能满足自动类型转换)。
  • 三元运算符可以嵌套使用
  • 三元运算符和if-else结构的联系
    • 凡是可以使用三元运算符的地方,都可以改写为if-else。反之,不成立。
    • 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。

1.10.6.1 三元运算符代码演示

package com.atguigu.java2;

/*
运算符之六:三元运算符
1.结构:(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
  	如果表达式为true,则执行表达式1。
  	如果表达式为false,则执行表达式2。
③ 表达式1 和表达式2要求是一致的(兼容,类型能满足自动类型转换)。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方,都可以改写为if-else
反之,不成立。

4. 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。
*/
public class SanYuanTest {
	
	public static void main(String[] args) {
		//获取两个整数的较大值
		int i1 = 10;
		int i2 = 20;
		
		int max = (i1 > i2)? i1 : i2;
		
		System.out.println(max);
		
		// 嵌套使用三元运算符
		int i3 = 30;
		int i4 = 30;
		String max1 = (i3 > i4)? "i3大" :((i3 == i4)? "i3 == i4" : "i4大");
		System.out.println(max1);
		
		
		//*******************************************************
		
		//获取三个数的最大值
		int i = 10;
		int j = 20;
		int k = 30;
		
		int max2 = (i > j)? i : j;
		int max3 = (max2 > k)? max2 : k;
		
		System.out.println(max3);
	}

}

1.10.7 运算符的优先级

image-20210409191502644

提示说明:

(1)表达式不要太复杂

(2)先算的使用()

大体的排序:算术->位–>比较–>逻辑–>三元–>赋值

写为if-else。反之,不成立。

  • 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。

1.10.6.1 三元运算符代码演示

package com.atguigu.java2;

/*
运算符之六:三元运算符
1.结构:(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
  	如果表达式为true,则执行表达式1。
  	如果表达式为false,则执行表达式2。
③ 表达式1 和表达式2要求是一致的(兼容,类型能满足自动类型转换)。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方,都可以改写为if-else
反之,不成立。

4. 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。
*/
public class SanYuanTest {
	
	public static void main(String[] args) {
		//获取两个整数的较大值
		int i1 = 10;
		int i2 = 20;
		
		int max = (i1 > i2)? i1 : i2;
		
		System.out.println(max);
		
		// 嵌套使用三元运算符
		int i3 = 30;
		int i4 = 30;
		String max1 = (i3 > i4)? "i3大" :((i3 == i4)? "i3 == i4" : "i4大");
		System.out.println(max1);
		
		
		//*******************************************************
		
		//获取三个数的最大值
		int i = 10;
		int j = 20;
		int k = 30;
		
		int max2 = (i > j)? i : j;
		int max3 = (max2 > k)? max2 : k;
		
		System.out.println(max3);
	}

}

1.10.7 运算符的优先级

在这里插入图片描述

提示说明:

(1)表达式不要太复杂

(2)先算的使用()

大体的排序:算术->位–>比较–>逻辑–>三元–>赋值

这篇关于第二章、Java基本语法(上):变量与运算符的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!