关于java:零基础学Java第二节运算符输入选择流程控制

本篇文章是《零根底学 Java》专栏的第二篇文章，文章采纳通俗易懂的文字、图示及代码实战，从零根底开始带大家走上高薪之路！

第一章 运算符

1.1 算术运算符的概述和用法

• 运算符

  对常量和变量进行操作的符号称为运算符

• 表达式

  用运算符把常量或者变量连接起来符号 java 语法的式子就能够称为表达式。不同运算符连贯的式子体现的是不同类型的表达式。
  定义两个 int 类型的变量 a,b，做加法(a + b)

• 罕用运算符

  算术运算符
  赋值运算符
  关系运算符
  逻辑运算符
  三元运算符

1.1.1 算数运算符概述

• 什么是运算符

  就是对常量和变量进行操作的符号。

• 算数运算符有哪些

  * +,-,*,/,%,++,--

1.1.2 代码实战

public class OperatorDemo {public static void main(String[] args) {
        // 定义两个 int 类型的变量
        int a = 5;
        int b = 3;
        
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(a%b);
        System.out.println("------------");
        
        System.out.println(5/4);
        System.out.println(5.0/4);
        System.out.println(5/4.0);
    }
}

算数运算符取余和除法的区别：

• %：取余运算符。失去的是两个相除数据的余数。
• /: 除法运算符。失去是两个相除数据的商。
• 应用场景：%：判断两个数据是否整除。

1.1.3 字符和字符串参加加法运算

• 字符参加运算
  其实是拿该字符对应的数值来操作

  ‘a’97‘A’65‘0’48

• 字符串参加运算
  这里其实做的不是加法运算，而是 <mark> 字符串拼接 </mark>。
  字符串和其余类型的数据做拼接，后果是字符串类型的。

1.1.4 代码实战

public class OperatorDemo2 {public static void main(String[] args) {
        // 定义两个变量，一个 int 类型，一个 char 类型
        int a = 10;
        char ch = 'a';
        System.out.println(a + ch);
        System.out.println("----------------");
        
        // 字符串做加法
        System.out.println("hello"+"world");
        System.out.println("hello"+10);
        System.out.println("hello"+10+20);
        System.out.println(10+20+"hello");
    }
}

1.1.5 自增自减运算符的概述和用法

++,--运算符：对变量做加 1 或者减 1 的操作。

++或者 -- 既能够放在变量的前面，也能够放在变量的后面。

独自应用的时候，++或者 -- 无论是放在变量的后面还是前面，后果是一样的。

参加操作的时候：

如果 ++ 或者 -- 在变量的前面，先拿变量参加操作，后变量 ++ 或者--

如果 ++ 或者 -- 在变量的后面，先变量做 ++ 或者--，后拿变量参加操作

1.1.6 代码实战

public class OperatorDemo {public static void main(String[] args) {
        // 定义一个 int 类型的变量
        int a = 10;
        System.out.println("a:"+a);
        
        //a++;
        //a--;
        //++a;
        //--a;
        //System.out.println("a:"+a);
        
        //int b = a++;
        int b = ++a;
        System.out.println("a:"+a);
        System.out.println("b:"+b);
    }
}

1.2 赋值运算符的概述和用法

1.2.1 赋值运算符分类

• 根本的赋值运算符：=

• 扩大的赋值运算符：+=,-=,*=,/=,%=

  a+=20;相当于a =a + 20;

1.2.2 代码实战

public class OperatorDemo {public static void main(String[] args) {
        // 定义变量
        int a = 10; // 把 10 赋值给 int 类型的变量 a
        System.out.println("a:"+a);
        
        // 扩大的赋值运算符：+=
        // 把运算符右边的数据和左边的数据进行运算，而后把后果赋值给右边
        //a = a + 20;
        a += 20;
        System.out.println("a:"+a);
        
        //short s = 1;
        //s = s + 1;
        
        // 扩大的赋值运算符隐含了强制类型转换。//a+=20
        // 等价于
        //a =(a 的数据类型)(a+20);
        short s = 1;
        s += 1;
        System.out.println("s:"+s);
    }
}

1.3 关系运算符的概述和应用

1.3.1 根本应用及注意事项

关系运算符蕴含以下内容:

==,!=,>,>=,<,<=

关系运算符的后果都是 boolean 型，也就是要么是 true，要么是 false。

注意事项：关系运算符“==”不能误写成“=”。

1.3.2 代码实战

public class OperatorDemo {public static void main(String[] args) {
        // 定义三个变量
        int a = 10;
        int b = 20;
        int c = 10;
    
        //==
        System.out.println(a == b);
        System.out.println(a == c);
        System.out.println("------------");
        
        //!=
        System.out.println(a != b);
        System.out.println(a != c);
        System.out.println("------------");
        
        //>
        System.out.println(a > b);
        System.out.println(a > c);
        System.out.println("------------");
        
        //>=
        System.out.println(a >= b);
        System.out.println(a >= c);
        System.out.println("------------");
        
        System.out.println(a == b);
        System.out.println(a = b);//20, 把 b 的值赋值给了 a，并把 a 作为后果输入了
    }
}

1.4 逻辑运算符的概述和应用

1.4.1 逻辑运算符概述

逻辑运算符用于连贯关系表达式，在 Java 中不能够写成3<x<6，应该写成x>3 && x<6。

• 逻辑运算符有哪些
  && ||！

• 论断：

  &&: 有 false 则 false。

  ||: 有 true 则 true。

  !: 非 false 则 true，非 true 则 false。

1.4.2 代码实战

public class OperatorDemo {public static void main(String[] args) {
        // 定义变量
        int a = 3;
        int b = 4;
        int c = 5;
        
        //&& 逻辑与
        System.out.println((a>b) && (a>c)); //false && false
        System.out.println((a<b) && (a>c)); //true && false
        System.out.println((a>b) && (a<c)); //false && true
        System.out.println((a<b) && (a<c)); //true && true
        System.out.println("------------");
        
        //|| 逻辑或
        System.out.println((a>b) || (a>c)); //false || false
        System.out.println((a<b) || (a>c)); //true || false
        System.out.println((a>b) || (a<c)); //false || true
        System.out.println((a<b) || (a<c)); //true || true
        System.out.println("------------");
        
        //! 逻辑非
        System.out.println((a>b));
        System.out.println(!(a>b));
        System.out.println(!!(a>b));
    }
}

1.5 三元运算符的概述和应用

1.5.1 三元运算符概述

• 格局

  (关系表达式)? 表达式 1：表达式 2;

  如果条件为 true，运算后的后果是表达式 1；
  如果条件为 false，运算后的后果是表达式 2；

1.5.2 代码实战

public class OperatorDemo {public static void main(String[] args) {
        // 定义两个变量
        int a = 10;
        int b = 20;
        
        int c = (a>b)?a:b;
        System.out.println("c:"+c);
    }
}

1.5.3 三元运算符练习之比拟两个整数是否雷同

public class OperatorTest {public static void main(String[] args) {
        // 定义两个 int 类型的变量
        int a = 10;
        //int b = 20;
        int b = 10;
        
        boolean flag = (a==b)?true:false;
        System.out.println(flag);
    }
}

第 2 章 键盘输入

2.1 键盘输入的根本步骤

2.1.1 键盘输入 数据概述

咱们目前在写程序的时候，数据值都是固定的，然而理论开发中，数据值必定是变动的，所以，把数据改良为键盘录入，进步程序的灵活性。

键盘录入数据的步骤:

1. 导包(地位放到 class 定义的下面)
   import java.util.Scanner;
2. 创建对象
   Scanner sc = new Scanner(System.in);
3. 接收数据
   int x = sc.nextInt();

2.1.2 代码实战

import java.util.Scanner;
/*
 * 为了进步程序的灵活性，咱们把数据改良为键盘录入。* 如何实现键盘录入数据呢? 目前应用 JDK 提供的类 Scanner。* 如何应用 Scanner 来获取数据呢? 目前大家记住应用步骤即可。* 
 * 应用步骤：*         A: 导包
 *             import java.util.Scanner;
 *             留神：在一个类中，有这样的程序关系
 *                 package > import > class
 *         B: 创立键盘录入对象
 *             Scanner sc = new Scanner(System.in);
 *         C: 获取数据
 *             int i = sc.nextInt();
 */
public class ScannerDemo {public static void main(String[] args) {
        // 创立键盘录入对象
        Scanner sc = new Scanner(System.in);
        
        // 给出提醒
        System.out.println("请输出一个整数：");
        // 获取数据
        int i = sc.nextInt();
        
        // 把获取的数据输入
        System.out.println("i:"+i);
    }
}

2.2 Scanner 录入数据练习之求两个整数的和

键盘录入两个数据，并对这两个数据求和，输入其后果:

import java.util.Scanner;
/*
 * 需要：键盘录入两个数据，并对这两个数据求和，输入其后果
 */
public class ScannerTest {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();
        
        // 对数据求和
        int sum = a + b;
        
        // 输入后果
        System.out.println("sum:"+sum);
    }
}

第 3 章 抉择流程管制语句

在一个程序执行的过程中，各条语句的执行程序对程序的后果是有间接影响的。也就是说程序的流程对运行后果有间接的影响。所以，咱们必须分明每条语句的执行流程。而且，很多时候咱们要通过管制语句的执行程序来实现咱们要实现的性能。

• 流程管制语句分类

  1. 程序构造
  2. 抉择构造
  3. 循环构造

3.1 流程管制语句之程序构造概述和应用

3.1.1 程序构造概述

是程序中最简略最根本的流程管制，没有特定的语法结构，依照代码的先后顺序，顺次执行，程序中大多数的代码都是这样执行的。

3.1.2 程序流程流程图

3.1.3 代码实战

public class OrderDemo {public static void main(String[] args) {System.out.println("开始");
        System.out.println("语句 A");
        System.out.println("语句 B");
        System.out.println("语句 C");
        System.out.println("完结");
    }
}

3.2 if 语句的格局

3.2.1 if 语句格局 1 的概述和应用

if 语句第一种格局：

if(关系表达式) {语句体}

执行流程:

首先判断关系表达式看其后果是 true 还是 false
如果是 true 就执行语句体
如果是 false 就不执行语句体

代码实战

public class IfDemo {public static void main(String[] args) {System.out.println("开始");
        
        // 定义两个 int 类型的变量
        int a = 10;
        int b = 20;
        
        // 判断两个变量是否相等
        if(a == b) {System.out.println("a 等于 b");
        }
        
        // 定义变量
        int c = 10;
        if(a == c) {System.out.println("a 等于 c");
        }
        
        System.out.println("完结");
    }
}

3.2.2 if 语句格局 2 的概述和应用

if 语句第二种格局：

if(关系表达式) {语句体 1;}else {语句体 2;}

执行流程:

首先判断关系表达式看其后果是 true 还是 false
如果是 true 就执行语句体 1
如果是 false 就执行语句体 2

代码实战

public class IfDemo2 {public static void main(String[] args) {System.out.println("开始");
        
        // 判断一个数据是奇数还是偶数
        // 思路：如果一个数据对 2 取余的后果是 0，阐明该数是偶数
        // 定义一个变量
        int a = 100;
        // 从新给 a 赋值
        a = 99;
        
        if(a%2 == 0) {System.out.println("a 是偶数");
        }else {System.out.println("a 是奇数");
        }
        
        System.out.println("完结");
    }
}

3.2.3 if 语句格局 3 的概述和应用

if 语句第三种格局：

if(关系表达式 1) {语句体 1;}else  if (关系表达式 2) {语句体 2;}
    …
    else {语句体 n +1;}

执行流程:

首先判断关系表达式 1 看其后果是 true 还是 false
如果是 true 就执行语句体 1
如果是 false 就持续判断关系表达式 2 看其后果是 true 还是 false
如果是 true 就执行语句体 2
如果是 false 就持续判断关系表达式…看其后果是 true 还是 false
…
如果没有任何关系表达式为 true，就执行语句体 n +1

代码实战

public class IfDemo3 {public static void main(String[] args) {System.out.println("开始");
        
        // 如果 x 和 y 满足如下的关系：//x>=3    y=2x+1
        //-1<=x<3    y=2x
        //x<-1    y=2x-1
        
        // 依据给定的 x 的值，计算出 y 的值
        int x = 5;
        x = 0;
        x = -5;
        
        // 定义变量 y
        int y;
        
        if(x >= 3) {y = 2*x+1;}else if(x>=-1 && x<3) {y = 2*x;}else if(x<-1) {y = 2*x-1;}else {
            y = 0;
            System.out.println("不存在这样的 x 的值");
        }
        
        System.out.println("y:"+y);
        
        System.out.println("完结");
    }
}

3.3 if 语句的练习

3.3.1 if 语句练习之获取两个整数的较大值

import java.util.Scanner;

/*
 * 需要：键盘录入两个数据，获取这两个数据的较大值
 * 
 * 剖析：*         A: 看到了键盘录入，咱们就应该想到键盘录入的三个步骤
 *             导包，创立键盘录入对象，获取数据
 *         B: 获取两个数据的较大值，用 if 语句的格局 2 就能够实现判断
 *         C: 把较大的后果输入即可
 * 
 * 导包：*         A: 手动导包
 *         B: 点击鼠标主动生成
 *         C: 快捷键
 *             ctrl+shift+o
 */
public class IfTest {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();
        
        //if 格局 2 实现判断
        /*
        if(a > b) {System.out.println("较大的值是："+a);
        }else {System.out.println("较大的值是："+b);
        }
        */
        
        // 咱们获取到较大的值未必是输入，可能还会进行其余的操作，所以咱们要改良代码
        // 定义一个变量用于保留较大的值
        int max;
        
        if(a > b) {max = a;}else {max = b;}
        
        // 我能够做
        //max += 10;
        
        System.out.println("较大的值是："+max);
    }
}

3.4 switch 语句的格局和执行流程概述

3.4.1 格局解释

3.4.1 格局解释:

switch(表达式) {
  case 值 1:
        语句体 1;
          break;
  case 值 2:
          语句体 2;
          break;
  case 值 3:
          语句体 3;
          break;
  ...
  default:
          语句体 n +1;
          break;
}

switch 示意这是 switch 语句

表达式的取值：byte,short,int,char

JDK5 当前能够是枚举
JDK7 当前能够是 String

case 前面跟的是要和表达式进行比拟的值

语句体局部能够是一条或多条语句
break 示意中断，完结的意思，能够完结 switch 语句

default 语句示意所有状况都不匹配的时候，就执行该处的内容，和 if 语句的 else 类似。

3.4.2 执行流程

首先计算出表达式的值

其次，和 case 顺次比拟，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到 break 就会完结。

最初，如果所有的 case 都和表达式的值不匹配，就会执行 default 语句体局部，而后程序完结掉。

3.5 switch 语句的练习

switch 语句的案例依据数字输入对应星期

import java.util.Scanner;

/*
 * switch 语句格局：*         switch(表达式) {
 *             case 值 1:
 *                 语句体 1;
 *                 break;
 *             case 值 2:
 *                 语句体 2;
 *                 break;
 *             case 值 3:
 *                 语句体 3;
 *                 break;
 *             ...
 *             default:
 *                 语句体 n +1;
 *                 break;
 *         }
 * 
 * 格局解释：*         表达式：byte,short,int,char
 *             JDK5 当前能够是枚举,JDK7 当前能够是字符串
 *         case 前面的值：是用来和表达式的值进行匹配的
 *         break：示意中断的意思
 *         default：所有的值都和表达式不匹配，就执行 default 对应的内容
 * 
 * 执行流程：*         A: 计算表达式的值
 *         B: 拿着这个值顺次和 case 前面的值进行比对，一旦有匹配的，就执行对应的语句，在执行的过程中，遇到 break 就完结。*         C: 如果所有的 case 都不匹配，就执行语句体 n +1
 * 
 * 案例：*         依据键盘录入的数据 1 -7，输入对应的星期一到星期日
 * 
 * 快捷键：对代码进行格式化
 *         ctrl+shift+f
 */
public class SwitchDemo {public static void main(String[] args) {
        // 创立键盘录入数据
        Scanner sc = new Scanner(System.in);

        // 给出提醒
        System.out.println("请输出一个整数(1-7)：");
        int weekDay = sc.nextInt();

        // 用 switch 语句实现判断
        switch (weekDay) {
        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;
        }
    }
}