1.数据类型
1.2 小数类型
public class Type1 {
public static void main(String[] args) {
//小数类型： float（4字节），double(8字节)
//小数的值，默认为double类型,加后缀F,代表float类型值
float a = 3.5F; //Type mismatch: cannot convert from double to float
double b = 2e3; //2*10*10*10
System.out.println(b);
double c = 3e5; //3*10^5
System.out.println(c); //300000
}
}
1.3 布尔类型
//布尔类型： boolean,取值为true或false，true表示真，false表示假 boolean d = true; //直接赋值true或false System.out.println(d); //true boolean e = 5>3; //间接赋值true和false (关系运算：结果为true或false) System.out.println(e); //true //boolean f = "false"; //Type mismatch: cannot convert from String to boolean //注意：boolean不能接收其他类型的值，只有true或false的结果，例如： //boolean g = 1+2;
1.4 字符类型
public class Type2 {
public static void main(String[] args) {
//字符类型： 用于存储''括住的单个字符，例如‘a’，‘A’
//字符类型，也叫做小整型，也就是字符与整数之间有一个对应关系； ‘a’--97，‘A’--65
//学习字符类型，需要关注两张表ASCII表，Unicode表
//ASCII表是字符与整数值之间的对应关系
//Unicode表是中文与整数值之间的对应关系（万国码表）
char a = 'A';
System.out.println(a); //A
char b = 65; //char本身是小整型
System.out.println(b); //A
char c = 'u0041'; //转义 \u代表16进制的数值 61进制的41==十进制65
System.out.println(c); //A
char d = '企';
System.out.println(d); //企
char e = 'u4f01';
System.out.println(e); //企
}
}
1.5 转义字符
public class Type3 {
public static void main(String[] args) {
//转义字符：将原本字符进行含义转变
//char a = '''; //单引号括起来的',无法识别，所以需要转义
//转义字符包含：n(换行), t(制表符), \, ', "
//案例：请打印自我介绍
System.out.println("姓名：王震；n年t龄："18"；性\别：'女'");
}
}
1.6 字符串类型
public class Type4 {
public static void main(String[] args) {
//字符串：引用类型，用于存储“”括起来的内容
String a = "hello";
System.out.println(a);
String b = a+",world"; //字符串的拼接符，任何类型与字符串拼接，最终结果为字符串
System.out.println(b); //hello,world
}
}
2. 类型转换（重点）
有两种转换方式：
a：自动转，低类型转高类型（注意：只有布尔类型不能与其他类型转换）
b：强转, 高类型转低类型
2.1 低类型转高类型
public class Change1 {
public static void main(String[] args) {
//1.低类型转高类型----默认转
byte a = 3;
short s = a; //byte -->short
int i = s; //short-->int
long l = i; //int -->long
float f = l; //long -->float(小数类型高于整数类型)
double d = f; //float-->double
}
}
2.2 高类型转低类型
public class Change2 {
public static void main(String[] args) {
//2.高类型转低类型----强转
double d = 3.5;
float f = (float)d; //double强转为float类型
long l = (long)f; //3 小数转整数，小数部分截断
System.out.println(l);
int i = (int)l;
short s = (short)i;
byte b = (byte)s;
System.out.println(b); //3
}
}
2.3 强转的隐患（扩展说明-原码反码补码）
public class Change3 {
public static void main(String[] args) {
//强转的隐患：如果强转时，足够容纳所存的值，则强转后没问题，
//如果容纳不了，则不是原来的值，需要计算; 例如下面的案例：
int i = 257;
byte b = (byte)i; //i为3则没有隐患 为257有隐患
System.out.println(b); //超出部分，截断
int ii = 130;
byte c = (byte)ii; //具体结果需要进行原码，反码，补码的换算
System.out.println(c);
//字符与整数可以互转,int转char强转
char a = 'A';
int d = a;
System.out.println(d); //65
char e = (char)d;
System.out.println(e); //A
}
}
3.运算符（重点）
//运算符：特殊的符号参与的式子
3.1 算数运算符
//算数运算符：+ - * / % ++ --
public class YunSuan1 {
public static void main(String[] args) {
int a = 1+2; //两个整数相加，最终结果为整数
double b = 1+2.5; //如果有一方为小数，最终结果为小数
int c = 6/4; //两个整数相除，最终取整，小数舍弃
double d = 6/4.0; //算数运算，只要有一方为小数，结果为小数
//%运算符： 取余(模)运算符
System.out.println(6%4); //2
//i++:后置自增：先计算表达式的值，变量的值后+1
//++i：前置自增：变量的值先+1，再计算表达式的值
//i--：后置自减：先计算表达式的值，变量的值后-1
//--i: 前置自增：变量的值先-1，再计算表达式的值
int i=3;
System.out.println(i++); //3 打印完后变量再+1 i=4
System.out.println(++i); //5 变量的值先+1
System.out.println(i--); //5 打印完后变量再-1 i=4
System.out.println(--i); //3 变量的值先-1
}
}
3.2 赋值运算符
public class YunSuan2 {
public static void main(String[] args) {
//赋值运算符： 基本赋值和复合赋值
//基本赋值：=
//复合赋值：+= -= *= /= %=
//1. 基本赋值
int a = 3; //初始化赋值
System.out.println("初始化赋值："+a); //3
a = 5;
System.out.println("基本赋值："+a); //3
//2.复合赋值
a += 3; //a=a+3
System.out.println("复合赋值:"+a); //8
a -= 5; //a=a-5
System.out.println("复合赋值:"+a); //3
a *= 2; //a=a*2
System.out.println("复合赋值:"+a); //6
}
}
3.3 关系运算符（重点）
public class YunSuan3 {
public static void main(String[] args) {
//关系运算符：> >= < <= == !=
//规则：关系运算符的最终结果为true或false
System.out.println(2>1); //true
System.out.println(2>=1); //true
System.out.println(2<1); //false
System.out.println(2<=1); //false
System.out.println(2==1); //false
System.out.println(2!=1); //true
//为什么关系运算符很重要？
//因为后面的条件判断，循环判断都需要用到关系运算
}
}
3.4 逻辑运算符(重点)
public class YunSuan4 {
public static void main(String[] args) {
//逻辑运算符： 短路与&& 短路或|| 逻辑非！ [&, |]
//规则：最终结果都是true或false
//&&: 操作数两边全为true，最终才是true
//||： 操作数两边有一边为true，则结果为true
//！： ！true->false ！false->true 取反
//说明：一般逻辑运算符会包含关系运算符，关系运算符的优先级比逻辑大，或加()
System.out.println(2>1&&0>2); //false
System.out.println(true&&true); //true
System.out.println(true||false); //true
System.out.println(!true); //false--单目运算符(只有一个操作数)
//应用场景：可以用在数学的判断中，例如： 99&&x<12); //true
//&& VS &: 最终结果是一致的，但是过程不同
//短路与&&：如果第一个式子为false，则不会执行第二个式子
//逻辑与&: 如果第一个式子为false，依然会执行第二个式子
//|| VS |： 最终结果是一致的，但是过程不同
//短路或||：如果第一个式子为true，则不会执行第二个式子
//逻辑或| ：如果第一个式子为true，依然会执行第二个式子
//验证结果：把第二个式子作为可改变值的式子即可
boolean a = true;
//System.out.println(false&&(a=false)); //第二个操作数没有执行
//System.out.println(false&(a=false)); //第二个操作数已经执行
//System.out.println(true||(a==false)); //第二个操作数没有执行
System.out.println(true|(a=false)); //第二个操作数已经执行
System.out.println("a的结果为--->"+a);
//结论：后续一般都会使用&& ||，很少使用& |; 短路的效率更高
}
}
3.5 三目运算符
public class YunSuan5 {
public static void main(String[] args) {
//表达式：由运算符和操作数组成的式子
//例如：算数运算符参与--算数表达式； 关系运算符参与--关系表达式
//三目运算符(三个操作数)： (关系表达式)?值1:值2
//规则：关系表达式成立，则值1为最终结果；否则值2为最终结果
String a = (5<3)?"是true":"是false";
System.out.println(a);
//应用场景：用于求最大值和最小值
int x=2,y=1;
int max = (x>y)?x:y;
System.out.println("最大值为："+max);
int min = (x
4. 自动类型提升与控制台录入
4.1 自动类型提升
public class Control1 {
public static void main(String[] args) {
//自动类型提升：
//a.算数运算时,操作数是高类型，则最终结果为高类型
//b.如果操作数为byte和short的运算，最终结果为int
byte a = 3;
short b = 5;
//short s = a+b; //Type mismatch: cannot convert from int to short
int s = a+b;
System.out.println(s);
}
}
4.2 控制台录入
public class Control2 {
public static void main(String[] args) {
//控制台录入： 用于接收控制台输入的值（有不同类型值，所以接收时需要调用不同的方法及不同的数据类型）
//步骤：1.导包
// 2.实例化对象(面向对象-后续会讲)
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个值：");
// 3.调用方法接收不同类型的值
//int num = scanner.nextInt(); //接收int类型的值--阻塞方法（常用）
//String num = scanner.next(); //接收String类型的值（常用）
//double num = scanner.nextDouble(); //接收double类型的值
char num = scanner.next().charAt(2); //获取字符串中的指定下标位置字符值，下标从0开始
System.out.println("打印："+num);
//注意：如果输入的数不匹配类型，则会提示：InputMismatchException
}
}
总结梳理：
每日必备单词：
1. relation [rɪˈleɪʃn] 关系 2．logic [ˈlɒdʒɪk] 逻辑
3.arithmetic [əˈrɪθmətɪk] 算数/算术 4.break [ breik ]中断
5. return [rɪˈtɜːn] 返回 6. console [kənˈsəʊl] 控制台
7．scanner [ 'skænə ]扫描仪 8. binary [ˈbaɪnəri] 二进制
9. octal ['ɒktəl] 八进制 10. decimal [ˈdesɪml] 十进制
11. hexadecimal[ˌheksəˈdesɪml]十六进制 12. assign [əˈsaɪn] 赋值/指定
13. expression [ɪkˈspreʃn] 表达式 14. input [ˈɪnpʊt] 输入
15. mismatch [ˌmɪsˈmætʃ] 不匹配 16. exception [ɪkˈsepʃn] 异常
