java的运算 java的运算符与流程控制

Java运算符和流程控制

• 运算符

• 运算符的概述
• 常用运算符
• 算术运算符

• 算术运算符的概述
• 算术运算符的分类

• 使用原则
• ++、--的注意事项

• 赋值运算符

• 赋值运算符的分类

• 赋值运算符的使用
• 赋值运算符的注意事项

• 关系运算符

• 关系运算符的注意事项

• 逻辑运算符

• 逻辑运算符的分类

• 三元运算符

• 三元运算符的概述

• 流程控制

• 三大结构
• 顺序结构

• 顺序结构的概念
• 顺序结构的流程图

• 选择结构

• if语句

• if语句格式1及执行流程(图)
• if语句格式2及执行流程(图)
• if语句格式3及执行流程(图)

• switch语句

• switch语句格式

• 案例

• 循环结构

• for语句
• for语句的格式和执行过程

• for语句案例

• while语句

• while语句格式和执行过程
• while语句案例

• do...while语句

• do...while语句格式和执行过程
• do...while语句案例

• 控制循环语句

• break
• continue

• break和continue案例

• 嵌套循环

• 嵌套循环语句格式和执行过程

运算符

运算符的概述

可以用来对常量和变量进行操作的符号称为运算符。

常用运算符

1.算术运算符
2.赋值运算符
3.逻辑运算符
4.三元运算符
5.关系运算符

算术运算符

算术运算符的概述

就是对常量和变量进行操作的控制

算术运算符的分类

+，-，*，/，%，++，–

使用原则

c=a+b
c=a-b
c=a/b
c=a*b
c=a%b

++、–的注意事项

i++和++i的区别在：i++是先使用在进行加1运算，++i是先进行+1运算在使用，i–与--i同理

int i = 1;
        System.out.println("i++="+(i++));
        System.out.println("i="+i);

        int j = 1;
        System.out.println("++j="+(++j));
        System.out.println("j="+j);

赋值运算符

赋值运算符的分类

1.基本的赋值运算符：=
2.扩展的赋值运算符：+=，-=，/=，*=，%=

赋值运算符的使用

public class Demo2 {
    //赋值运算符
    public static void main(String[] args) {
        byte b = 10;
        byte a = 2;
        b+=a;//此行代码相当与b = b+a;
        System.out.println(b);
    }
}

赋值运算符的注意事项

1.赋值运算符隐性包含了强制转换

public class Demo2 {
    //赋值运算符
    public static void main(String[] args) {
        byte b = 10;
       // b = b+10;此行代码报错，因为属于大转小，需要进行强制转换

        b+=10;//赋值运算符自动进行转换
        System.out.println(b);
    }
}

关系运算符

*>、<、>=、<=、==、!=

关系运算符的注意事项

1.关系运算符构成的表达式返回的结果为true或者false
2.判断一个数在某个范围内时不可以按照数学公式的写法（10<a<12）,应该写成（a>10&&a<12），通过逻辑运算符与来连接。

逻辑运算符

逻辑运算符的分类

1.&&：与，格式：表达式1&&表达式2，当两个表达式均为真的时候，整体表达式的值为true，否则为false
2.||：或，格式：表达式1||表达式2，只要有一个表达式为真，则整体表达式为真
3.&：逻辑与，有0则0
4.|：逻辑或，有1为1
5.^ ：逻辑异或：相同为false，不同为true。
6.!： 逻辑非：非false则true，非true则false。
7.~：加1取反

public class Demo4 {
    /*
    * 位运算符：
    * &：与，有0则0
    * |：位或，有1为1
    * ~：加1取反
    * ^:异或，相同为0，不同为1
    * */

    /*
    移位运算符：
    <<:左移运算符，左移一位，将原来的数*2
    >>:右移运算符，右移一位，将原来的数/2
     */

    public static void main(String[] args) {
        System.out.println("5&2="+(5&2));
        System.out.println("5|2="+(5|2));
        System.out.println("5^2="+(5^2));
        System.out.println("~5="+(~5));

        System.out.println("2<<1="+(2<<1));
        System.out.println("2>>1="+(2>>1));



    }
}

三元运算符

三元运算符的概述

三元运算符就相当于if语句一样，其格式为表达式?值1:值2，当表达式的值为true时，结果为值1，当表达式的值为false时，结果为值2

public class Demo5 {
    public static void main(String[] args) {
        //三元运算符
        //表达式?值1:值2
        //当表达式的值为true时，则为值1，否则为值2
        System.out.println(1>2?9:99.0);
        System.out.println(1<2?'a':99.0);//这里需要注意，由于数据的最高类型是double，故自动转换，输出*.0
    }
}

流程控制

三大结构

1.顺序结构
2.选择结构
3.循环结构

顺序结构

顺序结构的概念

按照程序中语句的顺序依次执行语句的结构称为顺序结构，例如：

public class Demo {
    public static void main(String[] args) {
        System.out.println("这是语句1");
        System.out.println("这是语句2");
        System.out.println("这是语句3");
        System.out.println("这是语句4");
    }
}
/**
 * 输出结果
 *这是语句1
 * 这是语句2
 * 这是语句3
 * 这是语句4 
 */

很明显输出结果和语句对应的顺序是一致的。

顺序结构的流程图

选择结构

if语句

if语句格式1及执行流程(图)

if(布尔值or关系表达式){
	语句体1//此处填写代码，可以是0行或者多行
}

执行流程：当括号内的结果为true时，程序跳转到{}内执行{}内的语句，否则，跳过{}内的代码，执行后面部分剩余的代码

public class Demo {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        if(a<b){
            System.out.println("这是if语句内的语句1");
        }
        System.out.println("这是其余的输出语句");
    }
}
/**
 * 输出结果
 * 这是if语句内的语句1
 * 这是其余的输出语句
 */

public class Demo {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        if(a>b){
            System.out.println("这是if语句内的语句2");
        }
        System.out.println("这是其余的输出语句");
    }
}
/**
 * 输出结果
 * 这是其余的输出语句
 */

观察上述两个程序可以发现，第二个程序比第一个程序少输出一个语句，因为程序2中if语句括号内关系表达式的值为false，所以不执行后面{}内的代码。

if语句格式2及执行流程(图)

if(布尔值or关系表达式){
程序段1//此处写代码
}else{
程序段2//此处写代码
}

执行流程:当括号内关系表达式或者布尔值为真时，执行程序段1，否则执行程序段2

public class Demo {
    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        if(a<b){
            System.out.println("这是语句1");
        }else {
            System.out.println("这是语句2");
        }

    }
}
/**
 * 输出结果
 * 这是语句1
 */

public class Demo {
    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        if(a>b){//上一段程序为a<b
            System.out.println("这是语句1");
        }else {
            System.out.println("这是语句2");
        }

    }
}
/**
 * 输出结果
 * 这是语句2
 */

if语句格式3及执行流程(图)

if(布尔值or关系表达式1){
程序段1//此处写代码
}else if(布尔值or关系表达式2){
程序段2//此处写代码
}...else{
程序段n//此处写代码
}

执行流程：首先判断关系表达式1看其结果是true还是false

如果是true就执行语句体1

如果是false就继续判断关系表达式2看其结果是true还是false

如果是true就执行语句体2

如果是false就继续判断关系表达式…看其结果是true还是false

…

如果没有任何关系表达式为true，就执行语句体n

switch语句

switch语句格式

swith(表达式){
	case 值1：
		程序体1；
		break;
	case 值2：
		程序体2；
		break;
		...
	default:
		程序体n;
		break
}

注意事项：
1.switch括号里的表达式可以是byte,short,int char,JDK5以后支持了枚举（enum），JDK7以后支持了String
2.若case语句后面没有跟break,程序会继续向下执行，知道遇到break，或者switc语句体结束。
3.case后面的值是用来和switch后面的表达式进行匹配的，若case中没有匹配的值，则执行default.

案例

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入（1-7，输入0退出）");
            int n= sc.nextInt();
            switch (n){
                case 1:
                    System.out.println("星期一");
                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.exit(0);break;
            }
        }
    }
}
/**
 * 输出结果
 * 请输入（1-7，输入0退出）
 * 1
 * 星期一
 * 星期二
 * 请输入（1-7，输入0退出）
 * 2
 * 星期二
 * 请输入（1-7，输入0退出）
 * 5
 * 星期五
 * 请输入（1-7，输入0退出）
 * 0
 *
 * Process finished with exit code 0
 */

循环结构

for语句

for语句的格式和执行过程

for(初始化语句①;判断条件语句②;控制条件语句④) {
     循环体语句③;
}

执行过程：①②③④>②③④>②③④…当②的条件不再满足时就跳出循环

for语句案例

import java.util.Scanner;

public class Demo {
    //输出1-20内的偶数
    public static void main(String[] args) {
        for (int i = 1; i < 21; i++) {
            if(i%2==0){
                System.out.print(i+" ");
            }
        }
    }
}
/**
 * 输出结果
 * 2 4 6 8 10 12 14 16 18 20 
 *
 * Process finished with exit code 0
 */

while语句

while语句格式和执行过程

初始化表达式① 
while(布尔表达式②){ 
    循环体语句;③ 
    控制条件语句;④ 
}

执行过程:执行顺序：①②③④>②③④>②③④…②不满足为止。

while语句案例

//while循环语句的基本格式
public class WhileDemo {
	public static void main(String[] args) {
		//输出10次HelloWorld
		/**
		for(int x=1; x<=10; x++) {
			System.out.println("HellloWorld");
		}
		*/
		
		//while循环实现
		int x=1;
		while(x<=10) {
			System.out.println("HellloWorld");
			x++;
		}
	}
}

do…while语句

do…while语句格式和执行过程

初始化表达式① 
do{ 
    循环体③ 
    控制条件语句④ 
}while(布尔表达式②);

执行过程:执行顺序：①③④>②③④>②③④…②不满足为止。

do…while语句案例

//do...while循环的基本格式
public class DoWhileDemo {
	public static void main(String[] args) {
		//输出10次 HelloWorld
		/**
		for(int x=1; x<=10; x++) {
			System.out.println("HelloWorld");
		}
		*/
		
		//do...while改写
		int x=1;
		do {
			System.out.println("HelloWorld");
			x++;
		}while(x<=10);
	}
}

三种循环的基本区别
1.do…while语句不论条件是否满足都会执行一次循环语句体，for和while只有在条件满足时才可以执行
2.若需要使用控制循环的变量，推荐使用while语句，for语句的条件变量在for语句结束后就失效。

控制循环语句

break

break适用于循环语句和switch语句中
break的作用主要是结束本层循环

continue

continue的作用是结束本次循环执行下一次循环

break和continue案例

import java.util.Scanner;

public class Demo {
    //break和continue案例
    public static void main(String[] args) {
        for (int i = 1; i < 7; i++) {
           if(i%3==0){
               break;
           }
            System.out.println("演示break");
        }
        for (int i = 1; i < 7; i++) {
            if(i%3==0){
                continue;
            }
            System.out.println("演示continue");
        }

    }
}
/**
 * 输出结果
 * 演示break
 * 演示break
 * 演示continue
 * 演示continue
 * 演示continue
 * 演示continue
 *
 * Process finished with exit code 0
 */

嵌套循环

嵌套循环语句格式和执行过程

以for语句为例子:

for(初始化表达式①; 循环条件②; 步进表达式⑦) { 
    for(初始化表达式③; 循环条件④; 步进表达式⑥) { 
        执行语句⑤; 
    } 
}

执行过程:：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥

外循环一次，内循环多次。

//打印出n行的金字塔图案
import java.util.Scanner;

public class Test{

	public static void main(String[] args){
		
		int n=0; //输入的行数
		int r=0; //当前行
		int s=0; //的数量
		int p=0; //空格的数量

		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();

		for(r=1;r<=n;r++){
			//打印空格
			for(p=1;p<=n-r;p++){
				System.out.print(" ");
			}
			//打印
			for(s=1;s<=2r-1;s++){
				System.out.print("");
			}
			//行换
			System.out.print("n");
		}
	}
}