Java_基础语法02

1.运算符

运算符：对常量或者变量进行操作的符号。

表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

 

+：是运算符，并且是算术运算符。

a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。 

 

1.1 算术运算符

符号（作用）

+（加）、-（减）、*（乘）、/（除）、%（取余）

 

注意：整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

 

1.1.1 字符的“+”操作

　　char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个

字符对应的数值：

　　'a' -- 97  a-z是连续的，所以'b'对应的数值是98，'c'是99，依次递加

　　'A' -- 65  A-Z是连续的，所以'B'对应的数值是66，'C'是67，依次递加

　　'0' -- 48  0-9是连续的，所以'1'对应的数值是49，'2'是50，依次递加

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少 
char ch1 = 'a'; 
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
 
char ch2 = 'A'; 
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
 
char ch3 = '0'; 
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

　　算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：

　　byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。

　　整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型

　　等级顺序：byte,short,char --> int --> long --> float --> double

例如：

byte b1 = 10;
byte b2 = 20;
//byte b3 = b1 + b2; //  该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度 
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); //  或者将结果强制转换为byte类型 
----------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

tips：正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。

 

1.1.2 字符串的“+”操作 

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("Java" + 6666); // 输出：Java6666

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

System.out.println(1 + 99 + "年编程"); // 输出：100年编程
System.out.println(1 + 2 +"zhangxin" + 3 + 4); // 输出：3zhangxin34
// 可以使用小括号改变运算的优先级
System.out.println(1 + 2 + "zhangxin" + (3 + 4)); // 输出：3zhangxin7

 

1.2 赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

　　=（赋值，a = 10, 将10赋值给变量a）

　　+=（加后赋值，a+=b, 将a+b的值给a）

　　-=（减后赋值，a-= b, 将a-b的值给a）

　　*=（乘后赋值，a*=b, 将a×b的值给a）

　　/=（除后赋值 ，a/=b, 将a÷b的商给a）

　　%= （取余后赋值 ，a%=b, 将a÷b的余数给a）

注意：

　　扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报错，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

 

1.3 自增自减运算符

　　++（自增，变量的值加1）

　　--（自减，变量的值减1）

注意事项：

　　++和-- 既可以放在变量的后边，也可以放在变量的前边。

　　单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。

　　参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者--。

　　参与操作的时候，如果放在变量的前边，先拿变量做++或者--，后拿变量参与操作。

int i = 10;
i++; // 单独使用
System.out.println("i: " + i); //i:11

int j = 10;
++j; // 单独使用
System.out.println("j: " + j); //j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x: " + x + ", y: " + y); //x:11, y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m: " + m + ", n: " + n); //m:11, n:11

练习：

int x= 10;
int y = x++ + x++ + x++;
System.out.println(y); 
//解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所以第一次自增时，使用的是 10进行计算，但第二次自增时，x的值已经自增到11了，所以第二次使用的是11，然后再次自增。。。 所以整个式子应该是：int y = 10 + 11 + 12; 输出结果为33。

注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！

 

1.4 关系运算符

关系运算符的结果都是boolean类型，要么是true，要么是false。

　　== （a==b，判断a和b的值是否相等，成立为true，不成立为false）

　　!=  （a!=b，判断a和b的值是否不相等，成立为true，不成立为false）

　　>   （a>b，判断a是否大于b，成立为true，不成立为false）

　　>= （a>=b，判断a是否大于等于b，成立为true，不成立为false）

　　<   （a<b，判断a是否小于b，成立为true，不成立为false）

　　<= （a<=b，判断a是否小于等于b，成立为true，不成立为false）

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量 
boolean flag = a > b; 
System.out.println(flag); // 输出false

 

1.5 逻辑运算符

　　逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程

序中的表达式是否成立，判断 的结果是 true 或 false。

　　& （逻辑与 a&b，a和b都是true，结果为true，否则为false）

　　|  （逻辑或 a|b，a和b都是false，结果为false，否则为true）

　　^ （逻辑异或 a^b，a和b结果不同为true，相同为false）

　　! （逻辑非 !a，结果和a的结果正好相反）

 

1.5.1 短路逻辑运算符 

&& （短路与，作用和&相同，但是有短路效果）

|| （短路或，作用和|相同，但是有短路效果）

　　逻辑与 &，无论左边真假，右边都要执行。

　　短路与 &&，如果左边为真，右边执行；如果左边为假，右边不执行。

　　逻辑或 |，无论左边真假，右边都要执行。

　　短路或 ||，如果左边为假，右边执行；如果左边为真，右边不执行。

int x = 3; 
int y = 4; 
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算 
System.out.println(x); // 4 
System.out.println(y); // 5
 
System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算 
System.out.println(x); // 4 
System.out.println(y); // 4

 

1.6 三元运算符

三元运算符语法格式：

关系表达式 ? 表达式1 : 表达式2;
int a = 10; 
int b = 20; 
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

　　问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为

false时调用表达式2。其 逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行

第二个。

 

2. 数据输入

我们可以通过 Scanner 类来获取用户的输入。使用步骤如下：

1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Scanner; 

2、创建Scanner对象。
Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变

3、接收数据
int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

示例：

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        // 创建对象
        Scanner sc = new Scanner(System.in);
        // 接收数据
        int x = sc.nextInt();
        // 输出数据
        System.out.println("x: " + x);
    }
}

三个和尚案例，数据使用键盘录入。

import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args) {
        //身高未知，采用键盘录入实现。首先导包，然后创建对象。
        Scanner sc = new Scanner(System.in);

        //键盘录入三个身高分别赋值给三个变量。
        System.out.println("请输入第一个和尚的身高：");
        int height1 = sc.nextInt();
        System.out.println("请输入第二个和尚的身高：");
        int height2 = sc.nextInt();
        System.out.println("请输入第三个和尚的身高：");
        int height3 = sc.nextInt();

        //用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int template = height1 > height2 ? height1 : height2;

        //用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int maxHeight = template > height3 ? template : height3;

        //输出结果。
        System.out.println("这三个和尚中身高最高的是：" + maxHeight);
    }
}

 

PS：凡是属于IO流的类，如果不关闭，会一直占用资源。要养成好习惯用完就关掉。

scanner.close();

 

3. 流程控制语句

顺序结构

　　顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后

顺序，依次执行，程序中大多 数的代码都是这样执行的。

 

分支结构(if, switch)

　　if 语句格式1

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

　　

　　if 语句格式2

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

if 语句格式2案例：奇偶数

需求：

　　任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该

整数是奇数还是偶数。

分析：

　　①为了体现任意给出一个整数，采用键盘录入一个数据

　　②判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构

　　③判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0

　　④根据判定情况，在控制台输出对应的内容

import java.util.Scanner;

public class IfTest01 {
    public static void main(String[] args) {
        //为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();

        //判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构
        // 判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
        // 根据判定情况，在控制台输出对应的内容
        if (number % 2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "是奇数");
        }
    }
}

　　

　　if 语句格式3

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

if语句格式3案例：

需求：

　　小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

分析：

　　①小明的考试成绩未知，可以使用键盘录入的方式获取值

　　②由于奖励种类较多，属于多种判断，采用if...else...if格式实现

　　③为每种判断设置对应的条件

　　④为每种判断设置对应的奖励

import java.util.Scanner;

public class Test02 {
    public static void main(String[] args) {
        //小明的考试成绩未知，可以使用键盘录入的方式获取值
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入小明的分数：");
        int score = sc.nextInt();

        //由于奖励种类较多，属于多种判断，采用if...else...if格式实现
        // 为每种判断设置对应的条件
        // 为每种判断设置对应的奖励
        // 数据测试：正确数据，边界数据，错误数据
        if (score > 100 || score < 0) {
            System.out.println("你输入的数据有误！");
        } else if (score >= 95 && score <= 100) {
            System.out.println("奖励为山地自行车一辆！");
        } else if (score >= 90 && score <= 94) {
            System.out.println("奖励为游乐场一日游！");
        } else if (score >= 80 && score <= 89) {
            System.out.println("奖励为变形金刚玩具一个！");
        } else {
            System.out.println("胖揍一顿！");
        }
    }
}

 

 　　switch语句 

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

执行流程：.

　　首先计算出表达式的值

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

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

 

PS：从Java SE 7 开始，switch 支持字符串String类型了。

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "张三";
        //字符的本质还是数字
        switch(name){
            case "张三":
                System.out.println("张三");
                break;
            case"李四":
                System.out.println("李四");
                break;
            case"王五":
                System.out.println("王五");
                break;
            default:
                System.out.println("你干嘛你！？");
        }
    }
}

 

switch语句练习-春夏秋冬:

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季 节，并输出。（春：3、4、5 ；夏：6、7、8 ；秋：9、10、11 ；冬：1、2、12）

示例代码：

import java.util.Scanner;

public class SwitchDemo {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入月份数字：");
        int month = sc.nextInt();
        //case穿透
        switch (month){
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份数字有误");
        }
    }
}

注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。