如鹏网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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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类型

1. == 等于运算符 ！=   不等于运算符

> 大于运算符 >=  大于或者等于运算符

< 小于运算符 <=  小于等于运算符

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.二元运算符（+、-、>等）、一元运算符（ ++、-- 等）

1. &&：二元运算符，两边都是true结果才是true。
2. ||：二元运算符，只要有一个是true结果就是true。
3. ！  一元运算符，取反，真的变假，假的变真。

短路运算：

下面程序执行结果是什么？

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，

就没必要算第二个了。

1. ||“或”运算符，||当第一个为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。

练习一：

如鹏网JAVA培训笔记2(晓伟整理)

标签：

原文地址：http://www.cnblogs.com/xiaoweiwangwang/p/4298788.html