1运算符
1.1算术运算符
运算符是用来计算数据的符号。
数据可以是常量，也可以是变量。
被运算符操作的数我们称为操作数。
算术运算符最常见的操作就是将操作数参与数学计算：
|
运算符 |
运算规则 |
范例 |
结果 |
|
+ |
正号 |
+3 |
3 |
|
+ |
加 |
2+3 |
5 |
|
+ |
连接字符串 |
“中”+“国” |
“中国” |
|
- |
负号 |
int a=3;-a |
-3 |
|
- |
减 |
3-1 |
2 |
|
* |
乘 |
2*3 |
6 |
|
/ |
除 |
5/2 |
2 |
|
% |
取模 |
5/2 |
1 |
|
++ |
自增 |
int a=1;a++/++a |
2 |
|
-- |
自减 |
int b=3;a--/--a |
2 |
1.1.1使用算术运算符注意事项
1）加法运算符在连接字符串时，只有直接与字符串相加才会转成字符串。
例：
class Test01
{
public static void main(String[] args)
{
double a=100L;
System.out.println("a的值为："+a+1);
}
}
class Test01 { public static void main(String[] args) { double a=100L; System.out.println("a的值为："+(a+1)); } }
2）除法“/”当两边为整数时，取整数部分，舍余数。当其中一边为浮点型时，按正常规则相除。
3）“%”为整除取余符号，小数取余没有意义。结果符号与被取余符号相同。
4）整数做被除数，0不能做除数，否则报错。
1.2算数运算符++、--的使用
a++：先赋值，自己再加1
++a：自己先加1，再赋值
a--：先赋值，自己再减1
--a：自己先减1，再赋值
示例1：
class Test01
{
public static void main(String[] args)
{
int a = 3;
int b = 3;
a++;
b--;
System.out.println(a);
System.out.println(b);
}
}
示例2：
class Test01
{
public static void main(String[] args)
{
int a = 3;
int b = 3;
++a;
--b;
System.out.println(a);
System.out.println(b);
}
}
示例3：
class Test01
{
public static void main(String[] args)
{
int a = 3;
int b;
b = a++ + 10;
System.out.println(a);
System.out.println(b);
}
}
示例4：
class Test01
{
public static void main(String[] args)
{
int a = 3;
int b;
b = ++a + 10;
System.out.println(a);
System.out.println(b);
}
}
1.3赋值运算符
赋值运算符就是为变量赋值的符号
|
运算符 |
运算规则 |
范例 |
结果 |
|
|
= |
赋值 |
int a=2 |
2 |
|
|
+= |
加后赋值 |
int a=2，a+=2，（a=a+2） |
4 |
|
|
-= |
减后赋值 |
int a=2，a-=2 (a=a-2) |
0 |
|
|
*= |
乘后赋值 |
int a=2，a*=2 （a=a*2） |
4 |
|
|
/= |
整除后赋值 |
int a=2，a/=2 |
1 |
|
|
%= |
取模后赋值 |
int a=2，a%=2 |
0 |
注意：诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型
例：
class Demo01
{
public static void main(String[] args)
{
//赋值运算符
int a=1;
int sum=0;
sum+=a; //sum=sum+a
System.out.println(sum);
}
}
1.4比较运算符
比较运算符，又叫关系运算符，它是用来判断两个操作数的大小关系及是否相等关系的，结果是布尔值true或者false。
|
运算符 |
运算规则 |
范例 |
结果 |
|
== |
相等于（判断） |
4==3 |
False |
|
!= |
不等于 |
4!=3 |
True |
|
< |
小于 |
4<3 |
False |
|
> |
大于 |
4>3 |
True |
|
<= |
小于等于 |
4<=3 |
False |
|
>= |
大于等于 |
4>=3 |
True |
注意：
1）Java里面没有===
2）赋值运算符的 = 符号与比较运算符的 == 符号是有区别的：
赋值运算符的 = 符号，是用来将 = 符号右边的值，赋值给 = 符号左边的变量；
比较运算符的 == 符号，是用来判断 == 符号 左右变量的值是否相等的。
例：
class Demo01
{
public static void main(String[] args)
{
int a = 3;
int b = 4;
System.out.println( a=b );
System.out.println( a==b );
}
}
1.5逻辑运算符
逻辑运算符，它是用于布尔值进行运算的，运算的最终结果为布尔值true或false。
|
运算符 |
运算规则 |
范例 |
结果 |
|
& |
与 |
false&true |
False |
|
| |
或 |
false|true |
True |
|
^ |
异或 |
true^flase |
True |
|
! |
非（取反） |
!true |
Flase |
|
&& |
短路与 |
false&&true |
False |
|
|| |
短路或 |
false||true |
True |
1.5.1
与：一假必假
或：一真必真
异或：两边相同为false，不同为true
非：真假相对
短路与：一假必假
短路或：一真必真
1.5.2 &和&&，|和||的区别
&：不管左边的值是true还是false，右边都会进行判断
&&：如果左边的值是false，则右边不再判断
|：不管左边的值是true还是false，右边都会进行判断
||：如果左边的值是true，则右边不再判断
所以实际开发中用&&和||，效率更高
例：
class Demo02 {
public static void main(String[] args) {
//&和&&区别
int x=1;
int y=2;
System.out.println(x==y&y==x++);
System.out.println(x);
System.out.println(y);
}
}
class Demo02 {
public static void main(String[] args) {
//&和&&区别
int x=1;
int y=2;
System.out.println(x==y&&y==x++);
System.out.println(x);
System.out.println(y);
}
}
class Demo02 {
public static void main(String[] args) {
//|和||区别
int x=1;
int y=2;
System.out.println(x==1|y==x++);
System.out.println(x);
System.out.println(y);
}
}
class Demo02 {
public static void main(String[] args) {
//|和||区别
int x=1;
int y=2;
System.out.println(x==1||y==x++);
System.out.println(x);
System.out.println(y);
}
}
class Demo02 {
public static void main(String[] args) {
//|和||区别
int x=1;
int y=2;
System.out.println(x==y||y==x++);
System.out.println(x);
System.out.println(y);
}
}
1.6三元运算符
格式：(条件表达式)？表达式1：表达式2；
三元运算符会得到一个结果，通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。
表达式的概念：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：
3+2，使用算数运算符将操作数联系起来，称为算数表达式。
3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，称为条件表达式。
还有其他一些表达式
例：
class Demo03
{
public static void main(String[] args)
{
//三元运算符
System.out.println(3>2?"正确":"错误");
}
}
三元运算符就是if，else的简写方式，可以提高效率。当两个条件比较确定时，就可以用三元运算符。三元运算符也可以嵌套。
例：键盘录入三个整数，并将三个数据中的最大值打印在控制台。
import java.util.Scanner;
class e13
{
public static void main(String[] args)
{
//键盘录入三个整数，并将三个数据中的最大值打印在控制台
Scanner sc=new Scanner(System.in);
System.out.println("请输入第一个整数");
int a=sc.nextInt();
System.out.println("请输入第二个整数");
int b=sc.nextInt();
System.out.println("请输入第三个整数");
int c=sc.nextInt();
System.out.println("最大的数是"+(a>b?(a>c?a:c):(b>c?b:c)));
}
}
1.7运算符优先级
按照运算先后顺序排序（优先级相同的情况下，按照从左到右的顺序依次运算）
|
优先级 |
描述 |
运算符 |
|
1 |
括号 |
()、[] |
|
2 |
正负号 |
+、- |
|
3 |
自增自减，非 |
++、--、! |
|
4 |
乘除，取余 |
*、/、% |
|
5 |
加减 |
+、- |
|
6 |
移位运算 |
<<、>>、>>> |
|
7 |
大小关系 |
>、>=、<、<= |
|
8 |
相等关系 |
==、!= |
|
9 |
按位与 |
& |
|
10 |
按位异或 |
^ |
|
11 |
按位或 |
| |
|
12 |
逻辑与 |
&& |
|
13 |
逻辑或 |
|| |
|
14 |
条件运算 |
?: |
|
15 |
赋值运算 |
=、+=、-=、*=、/=、%= |
|
16 |
位赋值运算 |
&=、|=、<<=、>>=、>>>= |
1.8实例练习
输出下图效果：
知识点：
打印tab空格：System.out.println(" ");
定义字符串：String str="字符串";
代码：
2引用数据类型
Java的数据类型分两种：
基本数据类型
引用数据类型
2.1引用数据类型的使用
所有的类都是引用数据类型。
与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
数据类型 变量名 = new 数据类型();
每种引用数据类型都有其功能，可以调用该类型实例的功能。
变量名.方法名();
2.2 Scanner类
Scanner类是引用数据类型的一种，可以使用该类来完成用户键盘录入，获取到录入的数据。
使用步骤：
1）导包：import java.util.Scanner;
在安装的jdk目录中，有一个包文件，里面就是java自带的基础类库：
可以看到里面全是.java文件
2）创建对象实例：Scanner sc = new Scanner(System.in); //括号里是传参
3）调用方法：
int i = sc.nextInt(); 用来接收控制台录入的数字
String s = sc.next(); 用来接收控制台录入的字符串
例：
import java.util.Scanner; //导包
class Demo04
{
public static void main(String[] args)
{
//创建Scanner对象
Scanner sc=new Scanner(System.in);
//调用方法
System.out.println("请输入一个整数：");
int i=sc.nextInt(); //只能输入int类型的数字
System.out.println("输入的整数为："+i);
//输入double类型的数字
System.out.println("请输入一个小数：");
double a=sc.nextDouble();
System.out.println("输入的小数为："+a);
//输入字符串
System.out.println("请输入一个字符串：");
String str=sc.next();
System.out.println("输入的字符串为："+str);
}
}
2.3 随机数类Random
Random类，可以产生多种数据类型的随机数。
2.3.1使用方式
import导包：所属包java.util.Random
创建实例格式：Random 变量名 = new Random();
2.3.2方法
public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
public double nextDouble() 产生[0,1)范围的随机小数，包含0.0，不包含1.0。
例：
import java.util.Random;
class Demo05
{
public static void main(String[] args)
{
//创建对象
Random r=new Random();
//调用方法
int rand=r.nextInt(5);
System.out.println("产生的随机整数为："+rand);
double doub=r.nextDouble();
System.out.println("产生的随机小数为："+doub);
}
}
//1-10的随机整数
int num=r.nextInt(10)+1;
System.out.println(num);
3流程控制语句
3.1选择结构if
3.1.1 if语句
if语句是指如果满足某种条件，就进行某种处理。
if (条件语句){
执行语句;
……
}
判断条件是一个布尔值，当判断条件为true时，{}中的执行语句才会执行。
3.1.2 if…else语句
if…else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理。
语法格式：
if (判断条件){
执行语句1
……
}else{
执行语句2
……
}
判断条件是一个布尔值。当判断条件为true时，if后面{}中的执行语句1会执行。当判断条件为false时，else后面{}中的执行语句2会执行。
3.1.3 if…else if…else语句
if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。
语法格式：
if (判断条件1) {
执行语句1
} else if (判断条件2) {
执行语句2
}
...
else if (判断条件n) {
执行语句n
} else {
执行语句n+1
}
判断条件是一个布尔值。当判断条件1为true时，if后面{}中的执行语句1会执行。当判断条件1为false时，会继续执行判断条件2，如果为true则执行语句2，以此类推，如果所有的判断条件都为false，则意味着所有条件均未满足，else后面{}中的执行语句n+1会执行。
例：
import java.util.Scanner;
class Demo06
{
public static void main(String[] args)
{
//用户输入一个数
Scanner sc=new Scanner(System.in);
System.out.println("请输入您的分数");
double grade=sc.nextDouble();
//判断等级
if(grade>=0&&grade<60){
System.out.println("不及格");
}else if(grade>=60&&grade<80){
System.out.println("及格");
}else if(grade>=80&&grade<90){
System.out.println("中等");
}else if(grade>90&&grade<=100){
System.out.println("优秀");
}else{
System.out.println("输入有误");
}
}
}
3.2循环语句while
while循环语句和选择结构if语句有些相似，都是根据条件判断来决定是否执行大括号内的执行语句。区别在于，while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。
语法结构：
while(循环条件){
执行语句
………
}
在上面的语法结构中，{}中的执行语句被称作循环体，循环体是否执行取决于循环条件。当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。
3.3循环语句for
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。
语法格式：
for（初始化表达式; 循环条件; 操作表达式）{
执行语句
………
}
for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。
用①表示初始化表达式、②表示循环条件、③表示操作表达式、④表示循环体，
for（① ; ② ; ③）{
④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环
例：
class Demo09
{
public static void main(String[] args)
{
//1到4求和
int sum=0;
for(int i=1; i<=4; i++){
sum+=i;
}
System.out.println("1-4的和为"+sum);
}
}
3.4循环语句do…while
do…while循环语句和while循环语句功能类似，语法结构：（注意while条件后面的分号）
do {
执行语句
………
} while(循环条件);
关键字do后面{}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。这也就意味着，循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。
3.5无限循环（死循环）
最简单无限循环格式：
while(true){}
或
for(;;){}
无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
在cmd控制台中结束，可以用ctrl+C
3.6循环嵌套
嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环，格式如下：
for(初始化表达式; 循环条件; 操作表达式) {
………
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
………
}
………
}
一般是用来遍历数据用的。
例：打印*（外层循环控制行，内层控制列）
class Demo01
{
public static void main(String[] args)
{
//打印*
for(int i=0;i<4;i++){
for(int j=0;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
3.7跳转语句（break、continue）
break：
1）在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。
2）当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环则需要对外层循环添加标记。
continue：
continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。
例1：
class Demo02
{
public static void main(String[] args)
{
//break和continue区别
for(int i=0;i<4;i++){
for(int j=0;j<=i;j++){
if(j==2){
continue;
}
System.out.print("*");
}
System.out.println();
}
}
}
例2：
class Demo02
{
public static void main(String[] args)
{
//break和continue区别
for(int i=0;i<4;i++){
for(int j=0;j<=i;j++){
if(j==2){
break;
}
System.out.print("*");
}
System.out.println();
}
}
}
例3：
class Demo03
{
public static void main(String[] args)
{
//加标记
a:for(int i=0;i<4;i++){
for(int j=0;j<=i;j++){
if(j==2){
break a;
}
System.out.print("*");
}
System.out.println();
}
}
}
例：猜数字
import java.util.Scanner;
import java.util.Random;
class GuessNumber
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
Random r=new Random();
int num=r.nextInt(100)+1;
System.out.println("请输入1到100之间的数");
while(true){
int inNum=sc.nextInt();
if(inNum>num){
System.out.println("猜大了，请重输");
}else if(inNum<num){
System.out.println("猜小了，请重输");
}else{
System.out.println("猜对了");
break;
}
}
}
}
4 流程控制语句
switch 条件语句也是一种很常用的选择语句，它和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。
4.1 if和switch区别
if的条件，可以是一个范围
switch的条件只能是一个值
4.2基本语法格式
switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
例：
import java.util.Scanner;
class Demo033
{
public static void main(String[] args)
{
//如果用户输入1-5，显示工作日；输入6和7，显示休息日
Scanner sc=new Scanner(System.in);
int day=sc.nextInt();
switch(day){
case 1:
System.out.println("工作日");
break;
case 2:
System.out.println("工作日");
break;
case 3:
System.out.println("工作日");
break;
case 4:
System.out.println("工作日");
break;
case 5:
System.out.println("工作日");
break;
case 6:
System.out.println("休息日");
break;
case 7:
System.out.println("休息日");
break;
default:
System.out.println("输入有误");
break;
}
}
}
4.3注意
1）default可以放在任意的位置，所以最好加一个break
2）穿透性，如果case后面没有break，则会继续执行下一个case中的语句（不论条件是否还满足），直到遇到break才跳出。
3）在switch语句中的表达式只能是byte、short、int、char（注意没有double）
类型的值，如果传入其它类型的值，程序会报错。
在JDK5.0中引入的新特性enum枚举也可以作为switch语句表达式的值，
在JDK7.0中也引入了新特性，switch语句可以接收一个String类型的值。
例：
import java.util.Scanner;
class Demo033
{
public static void main(String[] args)
{
//如果用户输入1-5，显示工作日；输入6和7，显示休息日
Scanner sc=new Scanner(System.in);
int day=sc.nextInt();
//利用穿透，简化代码
switch(day){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("输入有误");
break;
}
}
}