2017.3.26

1.几个概念：
 1：运算
  对常量和变量进行操作的过程称为运算。

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

 3：操作数
  参与运算的常量或者变量称为操作数。

 4：表达式
  用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
     不同运算符连接的式子体现的是不同类型的表达式。
  a
  a + b
  a > b

 运算符：
  算术运算符
  赋值运算符
  比较运算符
  逻辑运算符
  三目运算符

 算术运算符：
  +,-,*,/,
  %,++,--
 
2./和%的区别?
  /：除法，得到商
   符号相同为正,不同为负
  %：除法，得到余数
   符号和第一个操作数相同

 %的应用：
  x%3 等于 0 说明x能被3整除
  x%2 等1    说明x是奇数 
   等0    说明x是偶数 
   
3. ++,--运算符（讲完之后做练习）（重点）
  作用：++就是加1,--就是减1。
     自增自减运算符

 ++,--在运算的时候，可以放在操作数的前面，也可以放在操作数的后面
  A:单独使用
   没有区别
  B:参与其他操作使用
   后面：先操作，再自增
   前面：先自增，再操作
class OperatorDemo3 {
 public static void main(String[] args) {
  int a = 3;
  System.out.println(a);
  System.out.println("-------------");
  //a++;
  //++a;
  //System.out.println(a);

  //int b = a++;
  int b = ++a;
  System.out.println(a);
  System.out.println(b);
 }
}

例如以下代码：

int a = 10;
  //a++;
  //++a;
  
  //int b = a++;//10
  //int b = ++a;//11
  
  //System.out.println(b);

如下例题：

 int a = 10;
  int b = 10;
  int c = 10;

  a = b++;//a=10,b=11,c=10
  c = --a;//a=9,b=11,c=9
  b = ++a;//a=10,b=10,c=9
  a = c--;//a=9,b=10,c=8

  

4.赋值运算符：
  基本：=
  扩展：+=

 扩展的赋值运算符隐含了强制类型转换：
  int a = 10;
  a += 20;
  a = (a的数据类型)(a + 20)

  
5. 关系运算符：
  ==,!=,>,>=,<,<=

 注意：
  A:比较运算符的结果肯定是boolean。
  B:你到底是使用"="还是使用"==",你自己要清楚。

  “=” 代表的是赋值语句；

  “==”代表的是判断语句； 

6. 逻辑运算符：
  &,|,!,^
  &&,||

 注意：
  逻辑运算符用于连接关系表达式

 结论：
  &: 有false则false（关系与：有false整体为false）
  |: 有true则true(关系或：有true整体为true）
  !：改变结果，取反
  ^：相同false,不同true
   记忆：情侣关系(男男,男女,女男,女女) 
  
7. 最常用的逻辑运算符；
  !,&&,||

 &&和&:（相比之下效率更高）
  结果一样,但是&&具有短路效果,左边如果是false，右边不执行。
 ||和|:
  结果一样,但是||具有短路效果,左边如果是true，右边不执行。
  
8. 操作数据的个数。
 三元运算符：
  格式：?:

  (比较表达式)?表达式1:表达式2；
 
  执行流程：
   如果条件为true，运算后的结果是表达式1；
   如果条件为false，运算后的结果是表达式2；
 需求：获取两个数据中的最大值
 嵌套使用(获取三个数的最大值)

9. 我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，
 所以，我准备把数据改进为键盘录入，提高程序的灵活性。

 键盘录入数据的步骤：（键盘录入三部曲）1.导包 2.创建键盘录入对象 3.获取键盘录入数据
  A:导包
   import java.util.Scanner;
   位置：class之前,上面
  B:创建键盘录入对象
   Scanner sc = new Scanner(System.in);
  C:获取键盘录入数据
   int i = sc.nextInt();  
 
 需求：键盘录入两个数据，并对这两个数据求和，输出其结果

 分析：
  A:键盘录入两个数据
   三步实现
  B:对这两个数据求和
  C:输出其结果
  
 需求：键盘录入两个数据，获取这两个数据中的最大值
 
 需求：键盘录入两个数据，比较这两个数据是否相等
 
10. 流程控制语句：
  A:顺序结构(没有基本格式,从上往下依次执行)
  B:选择结构(有格式)
   if
   switch
  C:循环结构(有格式)
   for
   while
   do...while

 顺序结构:
  写在前面的先执行，写在后面的后执行
  
11. if语句
  三种格式。

 11.1 if语句格式1：
  if(比较表达式) {
       语句体
  }

  执行流程：
   首先判断比较表达式看其结果是true还是false
   如果是true就执行语句体
   如果是false就不执行语句体
  
  需求：1.如果我得了100分爸爸就给我买飞机
     2.如果数字是10，就输出10这个数字
      int score = 90;
  if(score==100){
   System.out.println("老爸答应我买一架飞机");
  }
  
  //2.如果数字是10，就输出10这个数字
  int num = 9;
  if(num==10){
   System.out.println(num);
  }
  if语句的注意事项：
  A:比较表达式无论简单还是复杂，结果必须是boolean类型
  B:一般来说：
   有左大括号就没有分号，有分号就没有左大括号

 11.2 if语句格式2：
  if(比较表达式) {
       语句体1;
  }else {
       语句体2;
  }

  执行流程：
   首先判断关系表达式看其结果是true还是false
   如果是true就执行语句体1
   如果是false就执行语句体2
  需求：1.判断两个数的最大值（用if和三元实现）
     2.判断两个数是否相等（用if和三元实现）
  
 11.3 if语句的三种格式：
  格式1：适合做一种情况的判断
  格式2：适合做二种情况的判断
  格式3：适合做多种情况的判断

 if语句格式3：
  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。

 需求：
  键盘录入学生成绩，根据学生成绩判断，输出学生等级
   90-100 A
   80-89 B
   70-79 C
   60-69 D
   60以下 E

import    java.util.Scanner;
   Scanner sc = new Scanner(System.in);
  
  //获取键盘录入数据
  System.out.println("请输入你的学生成绩");
  int score = sc.nextInt();
  
  //拿到成绩使用if做判断
  if(score>=90&&score<=100){
   System.out.println("成绩等级是A");
  }else if(score>=80&&score<=89){
   System.out.println("成绩等级是B");
  }else if (score>=70&&score<=79) {
   System.out.println("成绩等级是C");
  }else if(score>=60&&score<=69){
   System.out.println("成绩等级是D");
  }else if (score>=0&&score<60) {
   System.out.println("不及格");
  }else {
   System.out.println("输入成绩不再考核范围内");
  }
  

 练习：
   需求：键盘录入x的值，计算出y的并输出。
   x>=3 y = 2x + 1;
   -1<=x<3 y = 2x;
   x<=-1 y = 2x – 1;

  

import java.util.Scanner;

public class IfDemo4 {
 public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);
  
  //获取键盘录入数据
  System.out.println("请输入数字");
  int num = sc.nextInt();//先写右边，自动补全左边，快捷键ctrl+1+回车
  
  if (num>=3) {
   System.out.println(2*num+1);
  }else if (num>=-1&&num<3) {
   System.out.println(2*num);
  }else {
   System.out.println(2*num-1);
  }
  
 }

}

   需求：键盘录入月份的值，输出对应的季节。
   春 3,4,5
   夏 6,7,8
   秋 9,10,11 
   冬 12,1,2
   

package com.edu_07;

import java.util.Scanner;
public class IfDemo5 {
 public static void main(String[] args) {
  Scanner sc = new Scanner(System.in);
  
  //接受键盘录入数据
  System.out.println("请输入月份值");
  int month = sc.nextInt();
  
  //拿着月份值做判断
  if (month==3||month==4||month==5) {
   System.out.println("春天");
  }else if (month==6||month==7||month==8) {
   System.out.println("夏天");
  }else if (month==9||month==10||month==11) {
   System.out.println("秋天");
  }else if (month==12||month==1||month==2) {
   System.out.println("冬天");
  }
  
 }

}

   

   获取三个数据中的最大值
   if语句的嵌套。
    if() {
     if语句
    }
  
12 .switch语句的格式：
  switch(表达式) {
   case 值1：
    语句体1;
    break;
      case 值2：
    语句体2;
    break;
      …
      default： 
    语句体n+1;
    break;
  } 

  格式解释：
   A:switch表示这是switch语句
   B:表达式
    表达式的取值：byte,short,int,char
    JDK5以后可以是枚举
    JDK7以后可以是String
   C:case后面跟的是要和表达式进行比较的值
   D:语句体部分可以是一条或多条语句
   E:break表示中断，结束的意思，可以结束switch语句
   F:default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

  执行流程：
   首先计算出表达式的值
   其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
   最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

 需求：
  键盘录入一个数字(1-7),输出对应的星期几。

package com.edu_08;
/**
12 .switch语句的格式：
  switch(表达式) {
   case 值1：
    语句体1;
    break;
      case 值2：
    语句体2;
    break;
      …
      default： 
    语句体n+1;
    break;
  } 

  格式解释：
   A:switch表示这是switch语句
   B:表达式
    表达式的取值：byte,short,int,char
    JDK5以后可以是枚举
    JDK7以后可以是String
   C:case后面跟的是要和表达式进行比较的值
   D:语句体部分可以是一条或多条语句
   E:break表示中断，结束的意思，可以结束switch语句
   F:default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

  执行流程：
   首先计算出表达式的值
   其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
   最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

 需求：
  键盘录入一个数字(1-7),输出对应的星期几。
 *
 */
import java.util.Scanner;

public class SwitchDemo {
 public static void main(String[] args) {
  int a = 4;
  
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);
  
  //获取键盘录入数据
  System.out.println("请输入数字");
  int day = sc.nextInt();
  
  switch(day){
  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;
   /**
    * break不建议省略，因为会出现 case穿透：
    * case穿透：省略了break，程序在执行过程中没有遇见break之前是不会停止的
    * 程序会继续向下执行，直到遇见下一个break，程序才会停止
    */
  case 6:
   System.out.println("星期六");
   break;
  case 7:
   System.out.println("星期日");
   break;
  default:
   System.out.println("您输入的数据不存在");
   break;
  }
 

}

}

13. switch语句的注意事项：
  A:case后面只能是常量，不能是变量。
  B:多个case后面的值不能出现相同的。
  C:default可以省略吗?
   可以。但是不建议。
  D:break可以省略吗?
   可以。但是不建议。
   容易出现case穿透。
  E:default的位置一定要在最后吗?
   可以在任意位置，建议在最后。
  F:switch语句的结束条件
   a:遇到break
   b:执行到末尾

  练习：
  1.class SwitchTest {
   public static void main(String[] args) {
    int x = 2;
    int y = 3;

    /*
    switch(x){
     default:
      y++;
      break;
     case 3:
      y++;
     case 4:
      y++;
    }
    */

    /*
    switch(x){
     default:
      y++;
     case 3:
      y++;
     case 4:
      y++;
    }
    */

    switch(x){
     case 3:
      y++;
     case 4:
      y++;
    }

    System.out.println("y="+y);

   }
  }
  1.输入数字，输出对应的星期
  
  2.模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况)
  
  3.用switch语句实现键盘录入月份，输出对应的季节
   if语句和switch语句的各自使用场景：
    if语句使用场景：
     A:针对结果是boolean类型的判断
     B:针对一个范围的判断
     C:针对几个常量值的判断

    switch语句使用场景：
     针对几个常量值的判断

    switch语句能够实现的，if一定能够实现。反之不成立
  
14. 循环语句组成：
  A:初始化语句
   一条或者多条语句，这些语句完成一些初始化操作。
  B:判断条件语句：
   这是一个boolean表达式，这个表达式能决定是否执行循环体。
  C:循环体语句
   这个部分是循环体语句，也就是我们要多次做的事情。
  D:控制条件语句
   这个部分在一次循环体结束后，下一次循环判断条件执行前执行。
   通过用于控制循环条件中的变量，使得循环在合适的时候结束。

  循环：
   for
   while
   do..while

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

    执行流程：
     A:执行初始化语句
     B:执行判断条件语句
      如果是true：就继续执行。
      如果是false：就结束循环。
     C:执行循环体语句
     D:执行控制条件语句
     E:回到B

    执行次数：
     A:初始化语句
      只执行一次
     B:判断条件语句
      一次以上
     C:循环体语句和控制条件语句
      0次以上  
15.  需求：
  A:请在控制台输出数据1-10
  B:请在控制台输出数据10-1

package com.edu_09;

public class ForDemo3 {
 public static void main(String[] args) {
  /**
   * 15.需求：
   A:请在控制台输出数据1-10
   B:请在控制台输出数据10-1
   */
  //A:请在控制台输出数据1-10
//  for(int i =1;i<=10;i++){
//   System.out.println(i);
//  }
  
  //B:请在控制台输出数据10-1
  for(int i =10;i>=1;i--){
   System.out.println(i);
  }
  
 }

}

16.
 求出1-10之间数据之和

 分析：
  A:获取1-10的数据
   for循环就OK了。
  B:定义一个求和变量，用于保存求和的结果。
   求和变量的初始化值是0。
  C:看如下的格式：
   0+1=1
    1+2=3
     3+3=6
      6+4=10
       10+5=15
        ...

   看每一个式子：
    int sum = 0;
    1 = 0 + 1 // sum = sum + 1;
    3 = 1 + 2 // sum = sum + 2;
    6 = 3 + 3 // sum = sum + 3;
    10 = 6 + 4 //...
    15 = 10 + 5 //...
    ...

   求和公式：
    
    int sum = 0;

    for(int x=start; x<=end; x++) {
     sum += x;
    }

    System.out.println(sum);

   现场做：
    求和1-100案例：
    
    int sum = 0;
    for(int x=1; x<=100; x++) {
     sum += x;
    }
    System.out.println(sum);  
  
17. 需求：求出1-100之间偶数和

 分析：
  如何判断数据是偶数。

  什么样子的数据是偶数。（取余等于等于0的数）

  2,4,6,8,10,...

  x%2 == 0  
  

package com.edu_09;

public class ForDemo5 {
 public static void main(String[] args) {
  int sum = 0;
  for(int i = 1;i<=100;i++){
   //取余操作，判断偶数
   if (i%2==0) {
    sum+=i;
   }
  }
  
  System.out.println(sum);
 }

}

18. 需求：求5的阶乘

 规则：
  n! = n*(n-1)*(n-2)*...*3*2*1

package com.edu_09;

public class ForDemo6 {
 public static void main(String[] args) {
  int sum = 1;
  for(int i = 1;i<=5;i++){
   //累乘
   sum*=i;
  }
  System.out.println(sum);
 }

}

19. while循环的格式：
  while(判断条件语句) {
   循环体语句;
  }

  变形格式：
  
  初始化语句;
  while(判断条件语句) {
   循环体语句;
   控制条件语句;
  }

  执行流程：
   A:执行初始化语句
   B:执行判断条件语句
    如果是true：就继续执行。
    如果是false：就结束循环。
   C:执行循环体语句
   D:执行控制条件语句
   E:回到B

 比对for循环：
  for(初始化语句;判断条件语句;控制条件语句) {
   循环体语句

}

20. for循环和while循环的区别
  控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，
  而while循环结束还可以继续使用，如果你想继续使用，就用while，
  否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

 使用场景：
  for循环适合针对一个范围判断进行操作
   什么到什么之间，三位数等
  while循环适合判断次数不明确操作

21. 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

 分析：
  A:定义统计变量，初始化值是0
  B:折叠一次，厚度就是以前的2倍
  C:折叠次数不明确，用while循环  
  
 class WhileTest2 {
 public static void main(String[] args) {
  int count = 0;

  int end = 884800;
  int start = 1;

  while(start<=end) {
   //折叠一次
   start*=2;

   count++;
  }

  System.out.println(count);
 }
}

22. do...while的格式：
  do {
   循环体语句;
  }while((判断条件语句);

  变形格式：

  初始化语句;
  do {
   循环体语句;
   控制条件语句;
  }while(判断条件语句);

  执行流程：
   A:执行初始化语句
   B:执行循环体语句
   C:执行控制条件语句
   D:执行判断条件语句
    如果是true：就继续执行。
    如果是false：就结束循环。
   E:回到B

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

23. 三种循环的区别?
  A:do…while循环至少会执行一次循环体。
  B:for循环和while循环只有在条件成立的时候才会去执行循环体
    他们是可以相互转换的。

 我们在使用循环的时候到底该选择谁呢?
  优先考虑for循环，再考虑while循环，最后考虑do…while循环。

package com.edu_10;

public class WhileFor {
 public static void main(String[] args) {
  /**
   * 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，
           而while循环结束还可以继续使用，如果你想继续使用，就用while，
   否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

   */
  for (int i = 0; i < 10; i++) {
   System.out.println(i);
  }
  
  //想要用到for循环中的i变量,是引用不到的
  //System.out.println(i);
  System.out.println("-----------");
  
  int i  = 0;
  while (i<10) {
   System.out.println(i);
   i++;
  }
  
  System.out.println(i);
 }

}

 注意事项：
  死循环
   for(;;){}

   while(true){}
  
24. break的使用场景：
  A:在选择结构switch语句中
  B:在循环语句中

  注意：
   离开使用场景的存在是没有意义的

package com.edu_12;

public class BreakDemo {
 public static void main(String[] args) {
  
  for (int i = 0; i < 10; i++) {
   if (i==5) {
    break;//可以中断整个循环体
   }
   System.out.println(i);
  }
  
 }

}

 break:
  遇到break,就中断整个循环。
  默认情况下，break只能中断它所属的那个循环。

25. continue的使用场景：
  在循环语句中
  
  注意：
  离开使用场景的存在是没有意义的
 
 continue  退出本次循环 （本次结果不输出）

package com.edu_12;

public class ContinueDemo {
 public static void main(String[] args) {
  for (int i = 0; i < 10; i++) {
   if (i==5) {
    continue;//中断本次循环，并不是中断整个循环
   }
   System.out.println(i);
  }
  
  
 }

}