如鹏网JAVA培训笔记2(晓伟整理)
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一:
输入输出:
我们使用System.out.println(“abc”);作用:向控制台输入东西。
Scaner sc=new Scanner(System.in);//从输入流中去读取
int age=sc.nextInt();//等待接受用户输入的一个整型
String name=sc.nextLine();//阻塞函数,等待用户输入一行字符串
基本数据类型赋值:
基本数据类型是:复制传递
int i=10;
int j=i;//在此处将i的值拷贝过来传递给了j
i=20;
System.out.println(j);//结果是10
交换两个变量的值(两种方法解决):
int i=10; int j=20;
方法一: int temp=0;
Temp=i;//10
i=j;//20
j=i;//10
System.out.println(“i=”+i+“;j=”+j);
//输出i=20,j=10
方法二:
i=i+j; // i=30,j=20
j=i-j; // j=10,i=30
i=i-j; // i=20,j=10
比较运算符:
1.比较运算符(又称关系运算符)用来进行值得真假性判断,结果是boolean类型
- == 等于运算符 != 不等于运算符
> 大于运算符 >= 大于或者等于运算符
< 小于运算符 <= 小于等于运算符
3. System.out.println(3==5);//false
int i=9;
System.out.println(i>=3);//true
System.out.println(i==3);//false
//也可以把比较的结果赋值给boolean类型变量
int a=4;
int b=5;
boolean flag=a==b;
System.out.println(flag);//false
4.除了int、boolean等这些基本类型之外,字符串(String)等对象的相等判断要用equals方法。
String s1="abcdefg";
String s2="abc";
System.out.println(s1.equals(s2));//false
String s3="abc";
System.out.println(s3.equals(s2));//true
System.exit(0);//退出程序,加入这句代码,防止系统报错
注意:
1.下面程序的执行结果是什么?
int a=3;
int b=4;
System.out.println(a==b);//false
System.out.println(a=b);//4
2.赋值运算本身也是一个值,这个值就是赋值之后左边的值
int i=(a=b)+3;//结果为7
System.out.println(i);
逻辑运算符:
1.逻辑运算符用来对布尔类型的值运行运算的,主要有:
&&(与/并且)、 ||(或)、 !(非)
2.二元运算符(+、-、>等)、一元运算符( ++、-- 等)
- &&:二元运算符,两边都是true结果才是true。
- ||:二元运算符,只要有一个是true结果就是true。
- ! 一元运算符,取反,真的变假,假的变真。
短路运算:
下面程序执行结果是什么?
1.int i=8;
boolean b=(i>5)&&((i=i+5)>10);//true&&true
System.out.println(b);//true
System.out.println(i);//13
2.把第二句改成:
boolean b=(i>10)&&((i=i+5)>10);//false&&(不在执行)
System.out.println(b);//false
System.out.println(i);//8
结论:
1. &&当第一个为false的时候,整个运算结果一定是false,
就没必要算第二个了。
- ||“或”运算符,||当第一个为true的时候,整个运算结果一定是true,就没必要算第二个了。
3.!“非”运算符就是一个参与运算,没有短路问题。
三元运算符:
1.条件表达式?表达式1:表达式2
2.如果“条件表达式”为true,则表达式的值为“表达式1”,
否则为“表达式2”
int i=9;
int j=(i>15?888:666);
System.out.println(j);
If 判断语句:只能为“true”或者“false”
if(比较表达式)//必须是boolean类型,不可以是int类型
{
//一行或多行语句
}
当“比较表达式”为true时执行{}括号内的代码。
注:if语句中的大括号写不写?
如果if语句的大括号中只有一句话,那么可以省略大括号。
但是不建议这样做 养成良好的编程习惯,事倍功半。
练习一:
练习二:
练习三:
switch语句:
switch(表达式)
{ case 取值1: (取值1确定值,不能为表达式)
{
//语句;
}
break;
case 取值2: (取值2确定值,不能为表达式)
{
//语句;
}
break;
..........
defalut:
//语句;
break;
}
注:
1.表达式可以是byte、short、int、char类型。JDK5以后还可以是枚举类型(enum),JDK7以后还可以是String类型。
2.break意味着switch的结果。default相当于if的else,当所有都不匹配的时候,执行default。
练习一: