[Java知识库]Java SE之基础篇(三)——java基础语法(下)

前言

??上篇文章给大家介绍了java的部分基础语法，主要包括注释的使用、java中的关键字以及常量、变量和数据类型的介绍。最后通过xmind将本文所介绍的内容做成了思维导图，更方便大家学习以及总结。本文将给大家介绍java中剩下的基础语法。首先给大家介绍的java中的运算符。

一、运算符

1、算术运算符

??在写代码的时候，我们会遇到各种各样的实际问题，当然java也不例外，也需要算术运算符的。运算符是指对常量或者变量进行操作的符号。而与之呼应的是表达式；即用运算符把常量或者变量连接起来符合java语法的式子。其中， 不同运算符连接的表达式体现的是不同类型的表达式。接下来，我们通过案例将这个小知识点加以说明：

public class OperatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println (c);

??具体执行的结果如下：

??针对以上的代码，需要说明的是：

?? 1、 +：是运算符，并且是算术运算符。
?? 2、 a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

??我们在java中常见的运算符如下：

??这里需要注意的是：

• /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
• 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
  ??我们通过一个案例来对其加以说明：

public class OperatorDemo01 {
	public static void main(String[] args) {
		//定义两个变量
		int a = 6;
		int b = 4;
		
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b);
		System.out.println(a / b);
		System.out.println(a % b);
		//除法得到的是商，取余得到是余数
		
		//整数相除只能得到整数，要想得到小数，必须有浮点数的参与
		System.out.println(6.0 / 4);
	}
}

??具体的执行结果如下：

??其实算术运算符中也有很多种类，比如字符之间的“+”操作，字符串之间“+”操作。我们首先介绍字符之间的“+”操作。char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：

?? ‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
??‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
??‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加

??我们通过一个案例来演示字符之间的“+“运算：

/*
	字符的"+"操作
*/
public class OperatorDemo02 {
	public static void main(String[] args) {
		//定义两个变量
		int i = 10;
		char c = 'A'; //'A'的值是65
		c = 'a'; //'a'的值是97
		c = '0'; //'0'的值是48
		System.out.println(i + c);
		
		//char ch = i + c;
		//char类型会被自动提升为int类型
		int j = i + c;
		System.out.println(j);
		
		//int k = 10 + 13.14;
		double d = 10 + 13.14;
	}
}

??具体执行结果如下：

??在这里，算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。提升到额规则如下：

??byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
??整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
??等级顺序：byte,short,char --> int --> long --> float --> double

??具体案例如下：

public class CharacterTest {
    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
        int i3 = b1 + b2; // 应该使用int接收
        System.out.println (i3);
        byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
        System.out.println (b3);
        System.out.println ("-------------------------------");
        int num1 = 10;
        double num2 = 20.0;
        double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
        System.out.println (num3);
    }
}

??其代码执行结果如下：

??在上述的这段代码中，正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。
??最后，我们介绍的是字符串的“+”操作。当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。例如System.out.println("Stefan"+ 666); // 输出：Stefan666。另外在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。具体我们案例如下：

/*
	字符串的"+"操作
*/
public class OperatorDemo03 {
	public static void main(String[] args) {
		System.out.println("Ste" + "fan");
		System.out.println("Stefan" + 666);
		System.out.println(666 + "Stefan");

		System.out.println("一技之长" + 6 + 66);
		System.out.println(7 + "年的编程经验");
	}
}

??具体执行结果如下：

2、赋值运算符

??接下来，我们给大家介绍java中的赋值运算；赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。我们常见的赋值运算符主要包括以下几个：

??这里需要我们注意的是：扩展的赋值运算符隐含了强制类型转换。具体我们通过一个案例将其说明：

/*
	赋值运算符
*/
public class OperatorDemo {
	public static void main(String[] args) {
		//把10赋值给int类型的变量i
		int i = 10;
		System.out.println("i:" + i);
		
		// += 把左边和右边的数据做加法操作，结果赋值给左边
		i += 20;
		//i = i + 20;
		System.out.println("i:" + i);
		
		//注意：扩展的赋值运算符底层隐含了强制类型转换
		short s = 10;
		s += 20;
		//s = (short)(s + 20);
		System.out.println("s:" + s);
	}
}

??具体运行的结果如下：

3、 自增自减运算符

??接下来给大家介绍的是自增自减运算符。这个对于初学者来说会很容易混淆i++和++i的区别。首先我们给大家介绍自增自减运算符的作用以及相关的说明：

??在学习这部分内容的时候，我们应该特别注意以下几点：

??++和-- 既可以放在变量的后边，也可以放在变量的前边。 ?
??单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
???参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
??参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。 ?
??最常见的用法：单独使用。

??具体我们通过案例来说明这个知识点：

public class TestPlusAndReduction {
    public static void main(String[] args) {
        int i = 10;
        i++; // 单独使用
        System.out.println("i:" + i); // i:11

        int j = 10;
        ++j; // 单独使用
        System.out.println("j:" + j); // j:11

        int x = 10;
        int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
        System.out.println("x:" + x + ", y:" + y); // x:11，y:10

        int m = 10;
        int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
        System.out.println("m:" + m + ", m:" + m); // m:11，m:11
    }
}

??具体执行的结果如下：

??为了检测大家对这个小知识点掌握的情况，接下来，作者小小的测试一下大家：

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); 

??那么y值是多少呢？大家一定要自己先做一下，然后在看答案！！！(1分钟过去了)，接下来我们揭晓答案：

??分析：三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。所以整个式子应该是：int y = 10 + 11 + 12；因此最终答案：y=33。(那么问题来了，你做对了吗？！！！)

??不过需要我们注意的是：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码，因为没人这么写代码的，一定注意哈！！！！

4、关系运算符

??在Java中，我们常见的关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于，具体如下：

??这里需要我们注意的是：关系运算符的结果都是boolean类型，要么是true，要么是false。千万不要把“等于”误写成“=”，"==“是判断是否相等的关系，”="是赋值。 接下来我们通过一个案例将其说明：

/*
	关系运算符
*/
public class OperatorDemo04 {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		int j = 20;
		int k = 10;
		
		//==
		System.out.println(i == j);
		System.out.println(i == k);
		System.out.println("--------");
		
		//!=
		System.out.println(i != j);
		System.out.println(i != k);
		System.out.println("--------");

		//>
		System.out.println(i > j);
		System.out.println(i > k);
		System.out.println("--------");
		
		//>=
		System.out.println(i >= j);
		System.out.println(i >= k);
		System.out.println("--------");
		
		//不小心把==写成了=
		//把j的值赋值给了i，然后输出i的值
		System.out.println(i = j);
	}
}

??具体执行结果如下：

5、逻辑运算符

??逻辑运算符在java中是很重要的一部分，因此，大家一定要将其学会。逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。具体的符号以及与之对应的作用如下：

??接下来，我们通过一个案例来对上面提到的符号进行演示：

/*
	逻辑运算符
*/
public class OperatorDemo05 {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//& 有false则false
		System.out.println((i > j) & (i > k)); //false & false
		System.out.println((i < j) & (i > k)); //true & false
		System.out.println((i > j) & (i < k)); //false & true
		System.out.println((i < j) & (i < k)); //true & true
		System.out.println("--------");
		
		//| 有true则true
		System.out.println((i > j) | (i > k)); //false | false
		System.out.println((i < j) | (i > k)); //true | false
		System.out.println((i > j) | (i < k)); //false | true
		System.out.println((i < j) | (i < k)); //true | true
		System.out.println("--------");
		
		//^ 相同为false，不同为true
		System.out.println((i > j) ^ (i > k)); //false ^ false
		System.out.println((i < j) ^ (i > k)); //true ^ false
		System.out.println((i > j) ^ (i < k)); //false ^ true
		System.out.println((i < j) ^ (i < k)); //true ^ true
		System.out.println("--------");
		
		//!
		System.out.println((i > j)); //false
		System.out.println(!(i > j)); //!false
		System.out.println(!!(i > j)); //!!false
		System.out.println(!!!(i > j)); //!!!false
	}
}

??具体执行的结果如下：

??在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。具体运算符如下：

??逻辑与&，无论左边真假，右边都要执行。
??短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
??逻辑或|，无论左边真假，右边都要执行。
??短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。由于这个在我们日后的程序中异或用的很多，尤其是在条件分支和循环中用的很平凡，为了让大家更好的掌握这个知识点，我们通过一个案例来将其的用法加以说明：

/*
	短路逻辑运算符
*/
public class OperatorDemo06 {
	public static void main(String[] args) {
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//&& 有false则false
		System.out.println((i > j) && (i > k)); //false && false
		System.out.println((i < j) && (i > k)); //true && false
		System.out.println((i > j) && (i < k)); //false && true
		System.out.println((i < j) && (i < k)); //true && true
		System.out.println("--------");
		
		//|| 有true则true
		System.out.println((i > j) || (i > k)); //false || false
		System.out.println((i < j) || (i > k)); //true || false
		System.out.println((i > j) || (i < k)); //false || true
		System.out.println((i < j) || (i < k)); //true || true
		System.out.println("--------");
		
		//&&和&
		//System.out.println((i++ > 100) & (j++ > 100)); //false & false
		System.out.println((i++ > 100) && (j++ > 100)); //false && false
		System.out.println("i:" + i);
		System.out.println("j:" + j);	
	}
}

??具体执行的结果如下：

6、三元运算符

??这是java中唯一的一个三目运算符。其功能类似于下篇文章我们介绍的if语句。其格式为：

关系表达式 ? 表达式1 : 表达式2;

??问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。由于这个知识点对于初学者来说还是比较难理解的。接下来，我们通过三个案例将这个知识点进行说明：
??【案例一】：通过三元运算符来实现比较两个数的大小。

/*
	三元运算符
	
	格式：
		关系表达式 ? 表达式1 : 表达式2;

	范例：
		a > b ? a : b;
	
	执行流程：
		首先计算关系表达式的值
		如果值为true，表达式1的值就是运算结果
		如果值为false，表达式2的值就是运算结果
*/
public class OperatorDemo07 {
	public static void main(String[] args) {
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//获取两个数据中的较大值
		int max = a > b ? a : b;
		
		//输出结果
		System.out.println("max:" + max);
	}
}

??具体执行的结果如下：

??【案例二】：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

/*
	两只老虎
	
	需求：
		动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，
		请用程序实现判断两只老虎的体重是否相同。
*/
public class OperatorTest02 {
	public static void main(String[] args) {
		//1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
		int weight1 = 180;
		int weight2 = 200;
		
		//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
		boolean b = weight1 == weight2 ? true : false;
		
		//3：输出结果
		System.out.println("b:" + b);
	}
}

??这是我们介绍的第一个应用型案例，大家一定要看给出的注释；那就是我们常见的算法，只是比较简单，但是，算法就是从这里慢慢养成的，然后每一个算法后面就是实现的代码，一定要体会一下，这点很重要的！我们以后做大型的项目也是这样的。具体的执行结果如下：

??【案例三】：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。

/*
	三个和尚
	
	需求：
		一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
		请用程序实现获取这三个和尚的最高身高。
*/
public class OperatorTest03 {
	public static void main(String[] args) {
		//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
		int height1 = 150;
		int height2 = 210;
		int height3 = 165;
		
		//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
		int tempHeight = height1 > height2 ? height1 : height2;
		
		//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
		int maxHeight = tempHeight > height3 ? tempHeight : height3;
		
		//4：输出结果
		System.out.println("maxHeight:" + maxHeight);
	}
}

??具体的执行结果如下所示：

??我们通过三个案例对java中唯一的一个三目运算符进行了详细的讲解，相信各位读者对其知识点的应用以及理解都有一个深层次的理解。至此，java中的java基础语法给大家讲解完了，每个知识点都为大家配备了1~2个案例，方便大家更好的理解其知识点的应用，个别难理解以及不太好懂的知识点通过三个案例来让大家理解以及应用该知识点。保证能够让不同层次的读者都会看了文章都有不同程度的收获。最后我们通过一个综合的例子总结这两篇文章给大家介绍的知识点。

二、数据输入

??在java中，我们经常会遇到通过键盘输入一些信息，然后通过代码执行得到我们想要的信息，这个时候我们可以通过 Scanner 类来获取用户的输入。使用步骤如下：

/*
	数据输入：
		导包：
			import java.util.Scanner;
		创建对象：
			Scanner sc = new Scanner(System.in);
		接收数据：
			int x = sc.nextInt();
*/
import java.util.Scanner;

public class ScannerDemo {
	public static void main(String[] args) {
		//创建对象
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		int x = sc.nextInt();
		
		//输出数据
		System.out.println("x:" + x);
	}
}

??我们在启动该程序后，在代码运行区输入数字2022，回车，该程序的执行结果如下：

??另外，我们改写三个和尚案例，数据使用键盘录入。具体实现如下：

/*
	三个和尚
	
	需求：
		一座寺庙里住着三个和尚，他们的身高必须经过测量得出，请用程序实现获取这三个和尚的最高身高。
*/
import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		//身高未知，采用键盘录入实现。首先导包，然后创建对象。
		Scanner sc = new Scanner(System.in);
		
		//键盘录入三个身高分别赋值给三个变量。
		System.out.println("请输入第一个和尚的身高(cm)：");
		int height1 = sc.nextInt();
		
		System.out.println("请输入第二个和尚的身高(cm)：");
		int height2 = sc.nextInt();
		
		System.out.println("请输入第三个和尚的身高(cm)：");
		int height3 = sc.nextInt();
		
		//用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
		int tempHeight = height1 > height2 ? height1 : height2;
		
		//用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
		int maxHeight = tempHeight > height3 ? tempHeight : height3;
		
		//输出结果。
		System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
	}
}

??为了这个程序的可读性以及健壮性，我们在输入之前都在前面加上一句输出的相关信息，这是为程序的使用者考虑的。我们从现在开始，每写一个程序就要站在用你程序的用户考虑，你得想加入它不懂程序，测试你的这个代码可用性，我们就得给出一些提示信息，这种思维方式对于程序员来说特别的重要，因此需要我们特别的注意，需要我们从现在开始就慢慢培养，这样，我们以后写出来的代码可读性是很高的，才会是一名合格的程序员。这点还请大家多在以后的代码中经常使用！我们运行这个代码，根据提示输入数据175, 182,170，最后输出的结果为：

三、知识汇总

??最后，我们将本文介绍的所有知识点通过xmind做一个总结；具体知识点总结如下：

总结

??上篇文章给大家介绍了java的部分基础语法，主要包括注释的使用、java中的关键字以及常量、变量和数据类型的介绍。最后通过xmind将本文所介绍的内容做成了思维导图，更方便大家学习以及总结。本文将给大家介绍java中剩下的基础语法。其中主要包括几种常见的算术符以及数据输入的相关步骤，最后通过xmind做的思维导图将我们的本篇文章介绍的知识点做了总结，方便大家回顾。另外，我们第一次在本文中介绍java的相关案例，大家一定要看给出的注释；那就是我们常见的算法，只是比较简单，但是，算法就是从这里慢慢养成的，然后每一个算法后面就是实现的代码，一定要体会一下，这点很重要的！我们以后做大型的项目也是这样的。还有就是为了这个程序的可读性以及健壮性，我们在输入之前都在前面加上一句输出的相关信息，这是为程序的使用者考虑的。我们从现在开始，每写一个程序就要站在用你程序的用户考虑，你得想加入它不懂程序，测试你的这个代码可用性，我们就得给出一些提示信息，这种思维方式对于程序员来说特别的重要，因此需要我们特别的注意，需要我们从现在开始就慢慢培养，这样，我们以后写出来的代码可读性是很高的，才会是一名合格的程序员。这点还请大家多在以后的代码中经常使用！现在的java发展的如火如荼，在开发这块占据着举足轻重的地位。因此，作为计算机行业的一名开发人员，学习java是很有必要的。让我们一起在java的海洋里遨游吧！！！生命不息，奋斗不止，我们每天努力，好好学习，不断提高自己的能力，相信自己一定会学有所获。正如经典所说：“人不负青山，青山定不负人。”让我们一起向未来！加油！！！最后，在这里祝大家元旦快乐，希望大家在新的一年里学习进步，工作顺利，健康快乐，国泰民安！！！