学习尚硅谷-宋红康 Java基本语法(上): 变量与运算符

狼魂豹速

于 2020-10-17 19:42:54 发布

阅读量202

点赞数

本文链接：https://blog.csdn.net/liufeifeihuawei/article/details/109137176

版权

关键字

文章目录

关键字(keyword)的定义和特点 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词） 特点：关键字中所有字母都为小写 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

保留字(reserved word)

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

标识符(Identifier)

标识符：
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
技巧：凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则：
由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
练习：miles, Test, a++, --a, 4#R, $4, #44, apps, class, public, int, x, y, radius
Java中的名称命名规范 Java中的名称命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
 注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
 注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。
 推荐一本书《代码整洁之道.pdf》《阿里巴巴的开发手册》
2.2 标识符(Identifier)

/*
标识符的使用
1.标识符：凡是自己可以起名字的地方都叫标识符。
比如：类名、变量名、方法名、接口名、包名...

2.标识符的命名规则：--> 如果不遵守如下的规则，编译不通过！需要大家严格遵守

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

3. Java中的名称命名规范： --->如果不遵守如下的规范，编译可以通过！建议大家遵守

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

4.
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。 


*/
class IdentifierTest{

	public static void main(String[] args){
		
		//int myNumber = 1001;
		//System.out.println(myNumber);
		int mynumber = 1002;
		System.out.println(mynumber);
	//int 学号 = 1003;
	//System.out.println(学号);	
	
	}

}

class Hello1_${

}
//class 1Hello{
//}
class staticpublic{
}
class Static{
}

class User{
}

class Account{
}

变量

变量的概念： 内存中的一个存储区域 该区域的数据可以在同一类型范围内不断变化 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值 变量的作用： 用于在内存中保存数据 使用变量注意： Java中每个变量必须先声明，后使用 使用变量名来访问这块区域的数据 变量的作用域：其定义所在的一对{ }内 变量只有在其作用域内才有效 同一个作用域内，不能定义重名的变量

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

*/
public class StringTest {
    public static void main(String[] args) {
        //String 从左向右计算 如果是String 就标识连接符 不然就按规则计算
        System.out .println(3+4+"Hello!");
        System.out.println("Hello!"+3+4);
        System.out.println("*	*");
        System.out.println('*' + '\t' + '*');
        System.out.println("*"+ "\t" + '*');
        System.out.println("*" + '\t' + '*');
        System.out.println('*' + ('\t' + "*"));
        //char String(引用数据类型) int 值转换 加括号就先算括号里面的
        char c='a';
        String a="Hello";
        int num = 10;
        System.out.println(c+a+num);//aHello10
        System.out.println(c+num+a);//107Hello
        System.out.println(c+(num+a));//a10Hello
        System.out.println((c+num)+a);//107Hello
        System.out.println(a+num+c);//Hello10a
        System.out.println(c+a);//ahello
        String s1 = "Hello World!";

        System.out.println(s1);

        String s2 = "a";
        String s3 = "";

        //char c = '';//编译不通过

        //***********************
        int number = 1001;
        String numberStr = "学号：";
        String info = numberStr + number;// +：连接运算
        boolean b1 = true;
        String info1 = info + b1;// +：连接运算
        System.out.println(info1);

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

        //***********************
        //String str1 = 123;//编译不通过
        String str1 = 123 + "";
        System.out.println(str1);//"123"

        //int num1 = str1;
        //int num1 = (int)str1;//"123"

        int num1 = Integer.parseInt(str1);
        System.out.println(num1);//123
        
    }
}

运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符
2.4 运算符
运算符运算范例结果 + 正号 +3 3 - 负号 b=4; -b -4 + 加 5+5 10 - 减 6-4 2 * 乘 3*4 12 / 除 5/5 1 % 取模(取余) 7%5 2 ++ ++ 自增（前）：先运算后取值自增（后）：先取值后运算 a=2;b=++a; a=2;b=a++; a=3;b=3 a=3;b=2 - - 自减（前）：先运算后取值自减（后）：先取值后运算 a=2;b=- -a a=2;b=a- a=1;b=1 a=1;b=2 + 字符串连接 “He”+”llo” “Hello”

public static void main(String[] args) {
		
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;
		System.out.println(result1);//2

		int result2 = num1 / num2 * num2;
		System.out.println(result2);//10

		double result3 = num1 / num2;
		System.out.println(result3);//2.0

		double result4 = num1 / num2 + 0.0;//2.0
		double result5 = num1 / (num2 + 0.0);//2.4
		double result6 = (double)num1 / num2;//2.4
		double result7 = (double)(num1 / num2);//2.0
		System.out.println(result5);
		System.out.println(result6);

		// %:取余运算
		//结果的符号与被模数的符号相同
		//开发中，经常使用%来判断能否被除尽的情况。
		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);

		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);
		
		
		//(前)++ :先自增1，后运算
		//(后)++ :先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1);
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2);
		
		int a3 = 10;
		++a3;//a3++;
		int b3 = a3;
		
		//注意点：
		short s1 = 10;
		//s1 = s1 + 1;//编译失败
		//s1 = (short)(s1 + 1);//正确的
		s1++;//自增1不会改变本身变量的数据类型
		System.out.println(s1);

		//问题：
		byte bb1 =127;
		bb1++;
		System.out.println("bb1 = " + bb1);

		//(前)-- :先自减1，后运算
		//(后)-- :先运算，后自减1
		
		int a4 = 10;
		int b4 = a4--;//int b4 = --a4;
		System.out.println("a4 = " + a4 + ",b4 = " + b4);

	}

*
练习：随意给出一个三位数的整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1

*/
class AriExer {
	public static void main(String[] args) {
		
		int num = 187;
		
		int bai = num / 100;
		int shi = num % 100 / 10;//int shi = num / 10 % 10;
		int ge = num % 10;
		
		System.out.println("百位为：" + bai);
		System.out.println("十位为：" + shi);
		System.out.println("个位为：" + ge);

	}
}

赋值运算符

/*
运算符之二：赋值运算符
=  +=  -=  *=  /=  %= 


*/
class SetValueTest {
	public static void main(String[] args) {
		//赋值符号：=
		int i1 = 10;
		int j1 = 10;

		int i2,j2;
		//连续赋值
		i2 = j2 = 10;

		int i3 = 10,j3 = 20;
		
		//*********************
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2;
		System.out.println(num1);//12

		int num2 = 12;
		num2 %= 5;//num2 = num2 % 5;
		System.out.println(num2);

		short s1 = 10;
		//s1 = s1 + 2;//编译失败
		s1 += 2;//结论：不会改变变量本身的数据类型
		System.out.println(s1);

		//开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
		//方式一：num = num + 2;
		//方式二：num += 2; (推荐)
		
		//开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
		//方式一：num = num + 1;
		//方式二：num += 1; 
		//方式三：num++; (推荐)
		
		//练习1
		int i = 1;
		i *= 0.1;
		System.out.println(i);//0
		i++;
		System.out.println(i);//1

		//练习2
		int m = 2;
		int n = 3;
		n *= m++; //n = n * m++;	
		System.out.println("m=" + m);//3
		System.out.println("n=" + n);//6
		
		//练习3
		int n1 = 10;
		n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);
		System.out.println(n1);//32

	}
}

比较运算符

运算符运算范例结果
== 相等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true
instanceof 检查是否是类的对象 “Hello” instanceof String true

比较运算符的结果都是boolean型，也就是要么是true，要么是false。

比较运算符“==”不能误写成“=” 。

运算符	运算	范例	结果
==	相等于	4==3	false
!=	不等于	4!=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true
instanceof	检查是否是类的对象	“Hello” instanceof String	true

逻辑运算符

a	b	a&b	a&&b	a\|b	a\|\|b	!a	a^b
true	true	true	true	true	true	false	false
true	false	false	false	true	true	false	true
false	true	false	false	true	true	true	true
false	false	false	false	false	false	true	false

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别： 单&时，左边无论真假，右边都进行运算； 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”!

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

&  && |  || ! ^

说明：
1.逻辑运算符操作的都是boolean类型的变量


*/
class LogicTest {
	public static void main(String[] args) {
		
		//区分& 与 &&
		//相同点1：& 与  && 的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		//开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

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

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

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

		// 区分：| 与 || 
		//相同点1：| 与  || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);


		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
	}
}

位运算符

在这里插入图片描述

/*
运算符之五：位运算符（了解）

结论：

位运算符操作的都是整型的数据

<< ：在一定范围内，每向左移1位，相当于 * 2

:在一定范围内，每向右移1位，相当于 / 2

面试题：最高效方式的计算2 * 8 ？ 2 << 3 或 8 << 1
*/
class BitTest {
public static void main(String[] args) {
int i = 21;
i = -21;
System.out.println(“i << 2 :” + (i << 2));
System.out.println(“i << 3 :” + (i << 3));
System.out.println(“i << 27 :” + (i << 27));
  int m = 12;
  int n = 5;
  System.out.println("m & n :" + (m & n));
  System.out.println("m | n :" + (m | n));
  System.out.println("m ^ n :" + (m ^ n));

  //练习：交换两个变量的值
  int num1 = 10;
  int num2 = 20;
  System.out.println("num1 = " + num1 + ",num2 = " + num2);

  //方式一：定义临时变量的方式
  //推荐的方式
  int temp = num1;
  num1 = num2;
  num2 = temp;

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

  //方式三：使用位运算符
  //有局限性：只能适用于数值类型
  //num1 = num1 ^ num2;
  //num2 = num1 ^ num2;
  //num1 = num1 ^ num2;

  System.out.println("num1 = " + num1 + ",num2 = " + num2);
}

}

三元运算符

在这里插入图片描述

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

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

4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
class SanYuanTest {
	public static void main(String[] args) {
		
		//获取两个整数的较大值
		int m = 12;
		int n = 5;

		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n)? 2 : 1.0;

		//(m > n)? 2 : "n大";//编译错误

		//**************************
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);

		//*****************************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中的最大值为：" + max2);

		//不建议
		//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max3);

		//该写成if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}