Java语言基础学习（二）

一、运算符

• 算术：+、-、*、/、%、++、--

  • %:取模/取余，余数为0即为整除

System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2

• ++/--:自增1/自减1，可在变量前也可在变量后

  • 单独使用时，在前在后都一样

  • 被使用时，在前在后不一样

    • a++的值为a----------(a--的值为a)

    • ++a的值为a+1--------(--a的值为a-1)

//演示++单独使用
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//演示++被使用
int a=5,b=5;
int c = a++; //1)将a++的值5赋值给c  2)a自增1变为6
             //----a++的值为a(5)，所以c的值就是5
int d = ++b; //1)将++b的值6赋值给d  2)b自增1变为6
             //++b的值为b+1(6)，所以d的值就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

//演示--单独使用:
int a=5,b=5;
a--;
--b;
System.out.println(a); //4
System.out.println(b); //4

//演示--被使用:
int a=5,b=5;
int c = a--; //1)将a--的值5赋值给c  2)a自减1变为4
int d = --b; //1)将--b的值4赋值给d  2)b自减1变为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

• 关系：>、<、>=、<=、==、！=

1)>(大于)、<(小于)
  >=(大于或等于)、<=(小于或等于)
  ==(等于)、!=(不等于)
2)关系运算的结果为boolean型，
  关系成立则为true，关系不成立则为false

int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1);   //false
System.out.println(c<b);  //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
System.out.println(a+c>10); //false
System.out.println(a%2==0); //false
System.out.println(a++>5); //false--------a自增1变为6
System.out.println(a++>5); //true---------a自增1变为7

• 逻辑：&&、||、!

  • 逻辑运算是建立在关系运算的基础之上的 逻辑运算的结果也是boolean型

  • &&:短路与(并且)，两边都为真则为真，见false则false

int a=5,b=10,c=5;
boolean b1 = b>=a && b<c;
System.out.println(b1);          //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true

//演示短路
boolean b1 = a>b && c++>2;
System.out.println(b1); //false
System.out.println(c);  //5，发生短路了

                ||:短路或(或者)，有真则为真，见true则true

int a=5,b=10,c=5;
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
​
//演示短路
boolean b2 = a<b || c++>2;
System.out.println(b2); //true
System.out.println(c);  //5，发生短路了

                !:逻辑非(取反)，非真则假，非假则真

int a=5,b=10,c=5;
boolean b2 = !(a<b);
System.out.println(b2);     //!true=false
System.out.println(!(a>b)); //!false=true

• 赋值：=、+=、-=、*=、/=、%=

  • 简单赋值运算符：=

  • 扩展赋值运算符：+=、-=、*=、/=、%= ---注意:扩展赋值运算符自带强转功能

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转: s=(short)(s+10);
s += 10; //相当于: s=(short)(s+10);

• 字符串连接+

  • 若字符串两边位数字，则做加法运算

  • 若两便出现了字符串，则作字符串连接

  • 任意类型的数据只要和字符串连，结果都会变为字符串类型---同化作用

int age = 38;
System.out.println("age="); //age=
System.out.println(age);    //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了

String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了

System.out.println(10+20+""+30); //3030--------String
System.out.println(""+10+20+30); //102030------String
System.out.println(10+20+30+""); //60----------String

• 条件/三目：

  • 语法：boolean？数1：数2

  • 执行过程：

    • 表达式是有值的，他的只要么是问号后的数1，要么是冒号后的数2

    • 判断boolean的值：

      • 若为true，则整个表达式的结果为？号后的数1

      • 若为false，则整个表达式的结果为；号后的数2

int num = 0;
int flag = num>0?1:-1;
System.out.println(flag); //-1

int a=8,b=55;
int max = a>b?a:b;
System.out.println("max="+max);

二、分支结构，基于条件执行的语句

• if结构，1条路

1)语法:
     if(boolean){
          语句块-------------基于条件执行的语句
     }
 2)执行过程:
     判断boolean的值:
         若为true，则执行语句块(整个结束)
         若为false，则直接结束

//1)偶数的判断:
int num = 6;
if(num%2==0){ //带数(6,5)
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//1)满500打8折
double price = 300.0; //消费金额
if(price>=500){ //满500    带数(600.0,300.0)
    price = price*0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

• if...else结构：2条路

1)语法:
     if(boolean){
       语句块1
     }else{
       语句块2
     }
2)执行过程:
     判断boolean的值:
        若为true，则执行语句块1(整个结束)
        若为false，则执行语句块2(整个结束)
3)说明:
     语句块1和语句块2，必走其中之一----------2选1

//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}
System.out.println("继续执行...");


//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){
    price = price*0.8;
}else{
    price = price*0.9;
}
System.out.println("最终结算金额为:"+price);

• if...else结构：多条路

1)语法:
  if(boolean-1){
    语句块1
  }else if(boolean-2){
    语句块2
  }else if(boolean-3){
    语句块3
  }else{
    语句块4
  }
2)执行过程:
  判断boolean-1，若为true则执行语句块1(结束)，若为false则
    再判断boolean-2，若为true则执行语句块2(结束)，若为false则
    再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3)说明:
  语句块1/2/3/4，必走其中之一-------多选1

package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();
        //带数(888,-45,95,85,65,40)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //成绩合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }

    }
}

• switch...case结构：
  • 优点：效率高、结构清晰
  • 缺点，只能对整数判断相等
  • break：跳出switch

面试题：switch后数据的类型可以为：byte,short,char,int,String,枚举类型

 

package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.存款 2.取款 3.查询余额 4.退卡");
        int command = scan.nextInt();
        switch(command){
            case 1: 
                System.out.println("存款操作...");
                break;
            case 2:
                System.out.println("取款操作...");
                break;
            case 3:
                System.out.println("查询余额操作...");
                break;
            case 4:
                System.out.println("退卡操作...");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

三、循环，反复多次执行一段相同或相似的代码

1、循环三要素

• 循环变量的初始化
• 循环的条件（以循环变量为基础）
• 循环变量的改变（向着循环的结束变）

循环变量：在整个循环过程中所反复改变的那个数

 

案例一：
  输出5次"行动是成功的阶梯"
    行动是成功的阶梯
    行动是成功的阶梯
    行动是成功的阶梯
    行动是成功的阶梯
    行动是成功的阶梯
  循环变量:次数times
  1)int times=0;
  2)times<5
  3)times++;
    times=0/1/2/3/4/ 5时结束

案例二：
  输出9的乘法表:
    1*9=9
    2*9=18
    3*9=27
    4*9=36
    5*9=45
    6*9=54
    7*9=63
    8*9=72
    9*9=81
  循环变量:因数num
  1)int num=1;
  2)num<=9
  3)num++;
    num=1/2/3/4/5/6/7/8/9/ 10时结束
     
     1*9=9
     3*9=27
     5*9=45
     7*9=63
     9*9=81
  循环变量:因数num
  1)int num=1;
  2)num<=9
  3)num+=2;
    num=1/3/5/7/9/ 11时结束
    

• 循环结构
  • while结构，先判断后执行，有可能一次都不执行

1)语法:
   while(boolean){
     语句块/循环体----------反复执行的代码
   }
2)执行过程:
    判断boolean的值，若为true则执行语句块，
    再判断boolean的值，若为true则再执行语句块，
    再判断boolean的值，若为true则再执行语句块，
    如此反复，直到boolean的值为false时，while循环结束

//2)输出9的乘法表:     //3*9=27
int num = 1;
while(num<=9){
    System.out.println(num+"*9="+num*9);
    num+=2;     //num++;
}
System.out.println("继续执行...");

//1)输出5次"行动是成功的阶梯":
int times = 0;  //1)循环变量的初始化
while(times<5){ //2)循环的条件
    System.out.println("行动是成功的阶梯");
    times++;    //3)循环变量的改变
}
System.out.println("继续执行...");
*/
/*
   执行过程:
                   times=0
      true   输出   times=1
      true   输出   times=2
      true   输出   times=3
      true   输出   times=4
      true   输出   times=5
      false  while循环结束
      输出继续执行...
 */

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊
		
        //300(大),200(小),250(对)
        System.out.println("猜吧!");
        int guess = scan.nextInt(); //1.
        while(guess!=num){ //2.
            if(guess>num){
                System.out.println("太大了");
            }else{
                System.out.println("太小了");
            }
            System.out.println("猜吧!");
            guess = scan.nextInt(); //3.
        }
        System.out.println("恭喜你猜对了!");

    }
}

• do...while结构：先执行后判断，至少执行一次

当第1要素与第3要素的代码相同时，首选do...while

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //假设num=250
        //300(大),200(小),250(对)
        int guess;
        do{
            System.out.println("猜吧!");
            guess = scan.nextInt();  //1+3
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
        }while(guess!=num); //2
    }
}

• for循环结构：应用率高，与次数相关的循环

1)语法:
  //    1    2    3
  for(要素1;要素2;要素3){
      语句块/循环体---------------反复执行的语句  4
  }
2)执行过程:
  1243243243243243...2

for(int times=0;times<5;times++){
    System.out.println("行动是成功的阶梯");
}

//特殊的: for中的循环变量num的作用域---仅在当前for中
for(int num=1;num<=9;num++){
    System.out.println(num+"*9="+num*9);
}

for(int num=1;num<=9;num+=2){
    System.out.println(num+"*9="+num*9);
}
/*
    执行过程:
       num=1  true  1*9=9
       num=3  true  3*9=27
       num=5  true  5*9=45
       num=7  true  7*9=63
       num=9  true  9*9=81
       num=11 false for循环结束
*/

//演示for的特殊语法格式:
int num=1;
for(;num<=9;num++){
    System.out.println(num+"*9="+num*9);
}

for(int num=1;num<=9;){
    System.out.println(num+"*9="+num*9);
    num++;
}

for(;;){ //没有条件的循环就是一个死循环
    System.out.println("我爱Java");
}

for(int i=1,j=5;i<=5;i+=2,j-=2){
}
/*
   i=1,j=5
   i=3,j=3
   i=5,j=1
   i=7,j=-1
*/

//随机加法运算器
package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //总分
        for(int i=1;i<=10;i++){ //10次     (1)25+65=?
            int a = (int)(Math.random()*100); //加数a--0到99的随机数
            int b = (int)(Math.random()*100); //加数b--0到99的随机数
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
            System.out.println("算吧!");
            int answer = scan.nextInt(); //2)答题
            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

2、三种循环结构如何选择：

• 先看是否与循环次数相关：
  • 若相关-------------------直接选for
  • 若无关，再看第一要素和第三要素的代码是否相同
    • 若相同，------------------直接选do...while
    • 若不同，------------------直接选while

3、break：跳出循环

for(int num=1;num<=9;num++){
    if(num==4){ //在某种特定条件下，提前结束循环
        break; //跳出循环
    }
    System.out.println(num+"*9="+num*9);
}

/*
   执行过程:
      num=1  1*9=9
      num=2  2*9=18
      num=3  3*9=27
      num=4
*/

countinue：跳过循环体中剩余语句而进入下一次循环

//输出9的乘法表，只要不能被3整除
for(int num=1;num<=9;num++){
    if(num%3!=0){
        System.out.println(num+"*9="+num*9);
    }
}

//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
    if(num%3==0){
        continue; //跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(num+"*9="+num*9);
}
/*
  num=1  1*9=9
  num=2  2*9=18
  num=3
  num=4  4*9=36
  num=5  5*9=45
  num=6
  num=7  7*9=63
  num=8  8*9=72
  num=9
  num=10 false
*/

4、嵌套循环

• 循环中套循环，尝尝多行多列时使用，一半外层控制行，内层控制列
• 执行规则：外层循环走一次，内层循环走多次
• 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
• break只能跳出当前一层循环

//九九乘法表
public class MultiTable {
    public static void main(String[] args) {
        for(int num=1;num<=9;num++){ //控制行
            for(int i=1;i<=num;i++){ //控制列
                System.out.print(i+"*"+num+"="+i*num+"\t");
            }
            System.out.println(); //换行
        }
        /*
          执行过程:
            num=3
              i=1  1*3=3
              i=2  2*3=6
              i=3  3*3=9
              i=4  false
              换行
            num=2
              i=1  1*2=2
              i=2  2*2=4
              i=3  false
              换行
            num=1
              i=1  1*1=1
              i=2  false
              换行
         */
    }
}