二、语法基础

目录

1.变量

2. 数据类型（重点）

3.类型转换（重点）

4. 运算符（重点）

5.控制台录入

---

1.变量

概述：是计算机内存中的存储空间，用于存储数据的基本单元

变量的定义：数据类型  变量名 = 数值;

int是整数数据类型，用于约束存储的值为整数值

Java是强类型语言：数据类型非常规范和具体，整数有整数类型，小数有小数类型

int money = 100;
System.out.println(money);  //100
//System.out.println(100);    //100
//变量定义方式：
//1.先声明，再赋值
int a;
a = 10;
System.out.println(a);   //10

//2.声明的同时进行赋值：(最常用)
int b = 5;
System.out.println(b);   //5

//3.同时声明多个变量
int aa=2,bb; 
bb = 3;
System.out.println(aa);  //2
System.out.println(bb);  //3

2. 数据类型（重点）

概述： 用于约束变量所存储的数值

数据类型分类：基本数据类型、引用数据类型

基本数据类型： 整数、小数、布尔、字符

引用数据类型： 字符串、对象、数组

进制：人为定义的一种进位方式；十进制就是逢十进一，二进制就是逢二进一，n进制就是逢n进一

为什么需要有二进制和十进制？

        二进制：计算机最容易识别的进制：101010

        十进制：程序员最容易识别的进制

        

         

 整数数据类型：   

//整数类型：byte,short,int,long
byte b = 5;
//byte b = 257;   //超出范围的数值，则变为了int类型数值
System.out.println(b);  //5

short s = 257;
//short s = 32768;  //超出范围的数值，则变为了int类型数值
System.out.println(s);  //257

//int i = 2147483648;  //int数值过大了
long i = 2147483648L;   //后面加‘L’，表示long类型的数值
System.out.println(i);

小数类型：

//小数类型：double，float
double d = 2E3;  //科学计数法  E
System.out.println(d);  //2*10^3

//float f = 3.1;  //小数数值默认是double类型值
float f = 3.1F;   //需要后缀+F,表示float类型数值
System.out.println(f);  //3.1

布尔类型：

//布尔类型：所存储的值只有两个关键字：true和false
//true表示成功，false表示失败
//定义布尔类型的变量
boolean b = true;  //直接赋值
System.out.println(b);  //true

//boolean bb = "true";  //注意：定义变量名不能重名 带“”，表示字符串类型数值
boolean bb = (3>2);   //间接赋值  通过计算得到结果成功
System.out.println(bb);  //true

字符类型：存储单个字符，用''括起来

        俗称小整型,每个字符都有对应的整数值，这样的值叫做ASCII码值

        记住两个ASCII值，'a'->97  'A'->65

        注意：ASCII是英文字符对应整数值(关注ASCII), unicode是中文字符对应整数值    

问：在java中有了二进制和十进制，为什么还需要十六进制

答：因为十六进制是二进制的扩展与延伸，具备二进制特点，且写法更简洁

        

//字符类型：存储用‘’括起来的单个字符
char c1 = 'A';
System.out.println(c1);  //A

char c2 = 65;
System.out.println(c2);  //A

char c3 = '\u0041';  //\\u代表转义 表示16进制的数值
System.out.println(c3);  //A

转义字符：改变原有字符的含义  例如： \n  \t  \\  \"  \'

char a = '\'';   //只需加入反斜杠进行转义
//System.out.println(a);

//案例：打印自我介绍  println换行打印    print：不换行打印
//"xx"+'\n'=>“xx\n”: 字符串拼接任意类型，最终都为字符串
System.out.print("姓名:周\'杰伦\n");   //\\n：回车    \\': 代表单引号
System.out.print("年\\龄:25\t");  //  \\: 一个反斜杠 \\t: 制表符
System.out.print("爱好:\"唱歌\"");  //\\": 就是双引号

引用类型-字符串

        字符串： 用“”括起来的内容

//引用类型：字符串
String s = "周杰伦";
System.out.println(s);  //周杰伦
//注意字符串的拼接符：'+' 字符串拼接任意类型都得字符串
System.out.println(s+666);  //周杰伦666

3.类型转换（重点）

类型转换有两种：自动类型转换，强制类型转换

//自动类型转换：1.类型要兼容  2.目标类型高于源类型
byte b = 5;
int a = b;  //b为byte类型(源类型)自动转为int类型(目标类型)
long l = a;
float f = l;
System.out.println(f);  //5.0

//强制类型转换： 1.类型要兼容  2.目标类型低于源类型
//注意：强制类型转换，可能会丢失数据
int aa = 257;
byte bb = (byte)aa;  //(目标类型)aa
//如果值超出范围，需要将值转二进制进行换算，超出部分截断
System.out.println(bb);  //1

aa = 129;
byte cc = (byte)aa; 
System.out.println(cc);  //-127

double d = 3.14;
long ll = (long)d;
System.out.println(ll); //3 小数部分截断

//字符和整数互转
char c = 65;
int i = c;
System.out.println(i);  //65

//boolean类型不能与其他类型互转

        

4. 运算符（重点）

运算符：参与运算的符号

分类： 算数运算符，赋值运算符，关系运算符，逻辑运算符，三目运算符

//算数运算符： + - * /  %(模)  ++  --
double a = 3+4.5;  //算数运算的结果等于操作数中最高的类型
System.out.println(a);   //7.5

int b = 5%3;
System.out.println(b);  //2  取余数

//int c = 5/3;  //1 两整数相除，取整
double c = 5.0/3;
System.out.println(c);  //1.666

//++ 和 --
int i = 3;
//i++:后置自增，先执行表达式的值，变量的值后+1
//++i:前置自增, 变量的值先+1，再执行表达式的值
//i--:后置自减，先执行表达式的值，变量的值后-1
//--i:前置自减, 变量的值先-1，再执行表达式的值
System.out.println(i++);  //3  i=4
System.out.println(++i);  //5  i=5
System.out.println(i--);  //5  i=4
System.out.println(--i);  //3  i=3

//赋值运算符：=  += -= *= /= %=
//基本赋值： =
//复合赋值： += -= *= /= %=
int a = 3;  //定义变量时赋值(初始化赋值)
a = 5;     //基本赋值
System.out.println(a);  //5

a += 3;  //8 等价：a=a+3  先加再赋值
System.out.println(a);  //8
a *= 2;  //16 等价：a=a*2 先乘在赋值
System.out.println(a);  //16

//关系运算符：> >= < <= == != (注意：两个==是等于，一个=是赋值)
//关系运算符的结果为boolean类型  成立则为true，不成立则为false
System.out.println(3>2);  //true
System.out.println(3>=2); //true
System.out.println(3<2);  //false
System.out.println(3<=2); //false
System.out.println(3==2); //false
System.out.println(3!=2); //true

/*
	逻辑运算符： && || ！
	规则： 
	   逻辑与&&：操作数两边，如果有一边为false，则最终结果为false
	   逻辑或||: 操作数两边，如果有一边为true，则最终结果为true
	   逻辑非!:  只有一个操作数，如果值为false，则取反后为true;如果值为true，取反后为false
*/
System.out.println((3>2)&&(5<3));  //false

System.out.println(false&&true);   //false
System.out.println(false||true);   //true
System.out.println(!false);        //true

//扩展：  逻辑与&   逻辑或| --规则和上面的&&  ||是一样的 
System.out.println(false&true);   //false
System.out.println(false|true);   //true

//区别：
//&&：如果第一个操作数为false，则不执行第二个操作数
//&:  如果第一个操作数为false，还会执行第二个操作数

//||: 如果第一个操作数为true，则不执行第二个操作数
//|： 如果第一个操作数为true，还会执行第二个操作数

//验证结果:
boolean b = false;
//System.out.println(false&(b=true));  
System.out.println(false&&(b=true));
System.out.println("b="+b);   //b=false

//结论：后续操作基本上使用&&，||； 因为效率更高

//应用场景： 数学中的式子： 10<x<20;
int x = 15;
//System.out.println(10<x<20);  //true
System.out.println((x>10)&&(x<20));   //true

/*
	三目运算符： 拥有三个操作数的运算符     
	格式： (关系表达式)?操作数1:操作数2
	说明： 关系表达式如果成立，最终结果为操作数1；不成立，最终结果为操作数2
	应用场景：往往用在求最大值和最小值
*/

int a = (5<3)?5:3;
System.out.println(a);  //3

//案例：求两个变量，x，y的最大值
int x = 5;
int y = 8;
System.out.println((x>y)?x:y);  //8 最大值
System.out.println((x<y)?x:y);  //5 最小值

表达式：由操作数和运算符组成的式子

        例如：关系运算符参与的式子--->关系表达式

                   算数运算符参与的式子--->算数表达式

自动类型的提升：

        1.算数运算的最终结果，为操作数中最大的那个类型

        2.操作数中为byte和short类型，最终运算结果提升为int

        3.String类型和任意类型拼接(+),都为String类型 

5.控制台录入

        从命令提示符中输入一个值，传给变量

步骤：
        1. 导包  2.实例化对象  3.接收录入的值  

import java.util.Scanner;  //1.导包
public class Control{
	public static void main(String[] args){
		//2.实例化对象
		Scanner sc = new Scanner(System.in);
		//3.调用方法，接收录入的值
		int num = sc.nextInt();  //接收int类型值(常用)   阻塞方法
		//double num = sc.nextDouble();  //接收double类型值
		//String num = sc.next();  //接收字符串类型值(常用)
		//char num = sc.next().charAt(0);  //接收字符串的第0个字符，下标从0开始
		System.out.println("输出："+num);  //打印接收的值
		
		//注意：如果控制台录入的值不匹配，则会提示InputMismatchException
	}
}