javaSE基础-运算符、条件、循环

javaSE基础

1. 基本数据类型转换

java中8种基本类型可以从任意类型转换到其他的类型，但是boolean类型除外。

数据类型转换可分为：默认转换和强制转换。

1 默认转换

容量小的类型默认转换为容量大的类型。

数据类型容量有低到高：byte,short,char>int>long>float>double。

byte、short、char三者不会相互转换，但它们在计算时会转换为int类型

2 强制转换

容量大的类型转换为容量小的类型，要加上强制转换符。

long x=1000L;
int y=(int) x;

强制类型转换存在两个问题

1）溢出。数值超过类型小的表示范围。

2）精度降低。浮点型转换为整数型时，只会保留整数部分。

2.运算符

1 算术运算符

+	-	*	/
正数，加法，字符串连接	减法，负数	乘	除

%	++	–
取余	自加	自减
	++a(先自增，再取值)	–a(先自减，再取值)
	a++(先取值，在自增)	a–(先取值，再自减)

2 比较运算符

==(相等于)，!=(不相等)
数值与数值，布尔与布尔，引用类型与引用类型之间进行比较

运算符	运算
<	小于
>	大于
<=	小于等于
>=	大于等于
instanceof	检查是否是类的对象

3 逻辑运算符

逻辑与	逻辑或	逻辑异或	逻辑非	短路与	短路或
&	|	^	!	&&	||

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

&,|,^左右操作数为逻辑值(true/false)为逻辑运算，其余为位运算。

&&(短路与)：遇到第一个false就短路，后面的表达式不再运算。

||(短路或)：遇到第一个true就短路，后面的表达式不再运算。

int a=10;
int b=5;
int c=3;

System.out.println(a<b&&a++<c);//false && false = false
System.out.println(a>b&&a<c);//true && true =true
System.out.println(a);

System.out.println(a<b||++a>c);//false || true =true
System.out.println(a>b||a<c);//true || false =true

4 赋值运算符

符号：=

当"="两侧的类型类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。

扩展赋值运算符:+=,-=,*=,/=,%=.

运算符	用法举例	等效表达式
+=	a+=b	a=a+b
-=	a-=b	a=a-b
*=	a*=b	a=a*b
/=	a/=b	a=a/b
%=	a%=b	a=a%b

5 条件运算符

语法：(条件表达式)？表达式1：表达式2；表达式1和表达式2为同种类型

为true,执行表达式1；为false，执行表达式2.

int a=10;
int b=5;
int h=(a>b)?a:b;
System.out.println(h);//输出m为10

6 位运算

位运算是二进制(bit位)上的运算，因此执行效率高。

左移	右移	无符号右移	与	或	异或	非
<<	>>	>>>	&	|	^	~

无符号右移：被移位二进制最高位无论是0或者是1，空缺位都用0补。

& 二进制位进行&运算，只有1&1时结果是1，否则是0.

| 二进制位运算|运算，只有0|0结果是0，否则是1。

^ 异或，相同为0，不同为1。

运算分三步：1. 求补码 正数的原码，反码，补码，一样。负数是符号位不变，取反加一。

2. 连同符号位取反。
3. 求第二步的原码，正数不用求就是原码，负数是符号位不变，取反加一。

		int a=3;
        int b=5;
        int c=a&b;//c=1
        /*
            0011
            0101
            0001=1
         */
        System.out.println(c);

        int n=a|b;//n=7
        /*
        0011
        0101
        0111=7
         */
        System.out.println(n);

        int m=a^b;//m=6
        /*
        0011
        0101
        0110=6
         */
        System.out.println(m);

7 控制台输入

使用标准输入串System.in

使用Scanner取得一个字符串或一组数字。

在新增一个Scanner对象时需要一个System.in对象，因为实际上是System.in在取得用户输入。Scanner的next()方法用以取得用户输入的字符串;nextInt()将取得的输入字符串转为整数类型；同样，nextFloat()转换浮点型，nextBoolean()转换为布尔型。

import java.util.Scanner;
//在使用Scanner对象时，需要在文件头带入java.util.Scanner
public class ScannerDemo {
    public static void main(String[] args) {
        System.out.println("请输入一个数字");
        Scanner s=new Scanner(System.in);//创建一个Scanner对象
        int read=s.nextInt();
        System.out.println("请输入一个名字");
        String name=s.next();
        System.out.println(read);
        System.out.println("名字是"+name);
    }
}

8 条件语句

根据不同条件，执行不同语句。

1）if语句

if(条件表达式){表达式返回true，执行此语句块}else{表达式返回false，执行此语句块}
if(){}else if(){}
if(){}else if(){}{只有以上的表达式全部为false,才能执行此语句块}

条件表达式必须是一个返回布尔结果的表达式

2）分支语句(switch)

多分支选择语句，根据表达式的值，来执行多个操作中的一个。

switch(表达式){
    case value1:语句序列1;
        [break];
    ……    
    case valueN:语句序列2; 
        [break];
    [default:缺省语句;]    
}

表达式可以是byte、short、int、char、枚举类型。JDK7以后，可以使用String类型。

case语句后面只能使用常量表达式。

case后的值不能重复。

如果某个case分支如果没有提供break语句，则继续执行下个case后的语句。

当表达式的值与任一case中的值都不匹配时，将执行default后面的语句；如果没有default子句，则程序直接跳出switch语句。

public class Switch {
    public static void main(String[] args) {
        int age=18;
        switch (age){
            case 18:
                System.out.println("年轻人");
                break;
            case 19:
                System.out.println("大学生");

        }
    }
}

if语句和switch语句语句的对比

1. 如果判断的数值不多，而且符合byte、short、int、char这四种类型。建议使用switch语句，效率会高一点。
2. 对区间判断，对结果为boolean类型判断，使用if，它的范围更广。

9 循环

循环语句功能：在某些条件满足的情况下，反复执行特定代码的功能。

循环语句的四个组成部分：循环变量的初始化，循环部分，循环体部分，循环变量的更新。

循环语句分类：while循环，do/while循环，for循环

1.while循环

语法：

while(逻辑表达式){语句；……；先判断表达式，若=true.则执行其后面的语句，然后再次判断条件并反复执行，直到条件不成立}

public class While {
    public static void main(String[] args) {
        int i=2;
        while(i<20){
            System.out.println(i);
            i=i*i;
        }
    }
}

2.do while循环

语法：

do{

循环体

}while(逻辑表达式)

先执行语句，再判断逻辑表达式的值，若为true，再执行语句，否则结束循环。

public class DoWhile {
    public static void main(String[] args) {
        int i=2;
        do{
            i=i*2;
            System.out.println(i);
        }while(i<50);
    }
}

3 for循环

语法：

for(初始化变量；条件；变量迭代){

循环体；

}

for循环体除了标准式之外，还有两种变式，和一种死循环。

for的死循环语句，相比于while的死循环语句，由于while循环体需要进行判断，因此for死循环更加的效率。

public class For {
    public static void main(String[] args) {
        /*for(int i=0;i<50;i++) {
            int j = i * i;
            System.out.println(j);
        }*/
        //99乘法表
        for (int i=1;i<10;i++){
            for(int j=1;j<=i;j++){
                System.out.print(i);
                System.out.print("*");
                System.out.print(j);
                System.out.print("=");
                System.out.print(i*j);
                System.out.print(' ');
            }
            System.out.println();
        }
    }
}

10 break&continue

break:用于终止某个语句块的执行，用在循环体语句中，可以强行推出循环。

break终止语句有两种类型：1.只能终止紧挨的上层语句块

2.通过标签终止指定语句块

int i = 1;
        //当i = 7跳出这个循环
        while(i <= 10){
            System.out.println(i);
            i++;
            if(i == 7){
                break;
            }
        }

continue:用在循环语句体中，用于终止某次循环过程，跳过循环体中continue语句下面未执行的循环，开始下一次循环过程。

 int k = 0;
        while(k < 10){
            if(k == 7){//当i = 7，跳过这次循环
                continue;
            }
            System.out.println(k);
            k++;
        }

11 嵌套循环

将一个循环放在另一个循环体内，就形成了嵌套循环。其中for、while、do……while均可作为外层循环和内层循环。

实践上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完成跳出内层循环，才可结束外层的当次循环，开始下一次的循环

结束外层循环：如果需要从多层循环跳出，则需要使用标签，先定义再使用。