Day03-java语言基础(上)
Day3-java语言基础(上)
前面是概述和环境搭建，接下来准备语言基础
变量
概念
简单来理解就是:可以改变的量
变量组成三要素
数据类型、变量名、值
public class TestVariable1{
public static void main(String[] args){
//声明变量，数据类型 变量名
int money;
//赋值
money = 100;
//输出
System.out.println(money);
}
}
变量的定义方式
1. 先声明，再赋值
数据类型 变量名;
变量名 = 值;
2. 声明并赋值
数据类型 变量名 = 值;
3. 多个同类型变量的声明与赋值
举例
public class TestVariable2{
public static void main(String[] args){
//1. 先声明，再赋值
int age;
age = 18;
System.out.println(age);
//2. 声明并赋值
int length = 18;
System.out.println(length);
//3. 多个同类型变量的声明与赋值
int a,b,c;
a = 5;
b = 6;
c = 7;
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
数据类型
基本数据类型（四类八种:【整型】【浮点型】【字符型】【布尔型】）
按照数值型非数值型分，如下：
1. 数值型
整型 byte【1字节】、short【2字节】、int【4字节】、long【8字节】
浮点型 float【4字节】、double【8字节】
2. 非数值型
字符型 char【2字节】
布尔型 boolean
引用数据类型
字符串 String
数组
对象
...
public class TestType{
public static void main(String[] args){
//创建byte类型的变量，测试其取值范围
//数据类型 变量名 = 值;
byte b = 127;//取值范围 -2^7~2^7-1 超出报错
System.out.println(b);
//创建short类型的变量，测试其取值范围
//数据类型 变量名 = 值;
short s = 32767;//取值范围 -2^15~2^15-1 超出报错
System.out.println(s);
//创建int类型的变量，测试其取值范围
//数据类型 变量名 = 值;
int i = 2147483647;
System.out.println(i);//取值范围 -2^31~2^31-1 超出报错
//创建long型的变量，测试其取值范围
//数据类型 变量名 = 值;
//【int为整数的默认类型】，如需为long类型赋值较⼤整数时，需在值的后⾯追加“L”。
long l = 2147483647L;
System.out.println(l);//取值范围 -2^63~2^63-1 超出报错
}
}
public class TestFloatAndDouble{
public static void main(String[] args){
//float：单精度 7~8位
//正数1为整数类型，可以赋值 原因:int可表示范围在float之内
float f = 1;
System.out.println(f);
//【注意】float f1 = 1.2 会报错，因为【小数1.2默认为double类型】double比float精度高，将精度高的赋值给低的肯定会报错，所以加后面加个F，这样1.2f为float类型就没问题了
float f1 = 1.2F;
System.out.println(f1);
//double 双精度 15~16位 【小数默认为double类型】
double d = 3.14;
System.out.println(d);
//多种赋值（都可以），【在同种变量类型中，变量名不可重复】
double d1 = 2000;
System.out.println(d1);
double d2 = 2000.0;
System.out.println(d2);
double d3 = 2000D;
System.out.println(d3);
double d4 = 2E3;//相当于2*10^3
System.out.println(d4);
//表示的数字大时会使用科学计数法表示，例如，下面会输出1.7E22（相当于1.7*10^22）
double d5 =17000000000000000000000.0;
System.out.println(d5);
//尽量不使用他们计算
double d6 = (1.4-0.5)/0.9;
System.out.println(d6);
}
}
public class TestBoolean{
public static void main(String[] args){
//boolean变量，不参与运算
//可直接赋值为true/false
boolean b1 = true;
System.out.println(b1);
//可赋值为一个结果为true/false的表达式
boolean b2 = 5>2;
System.out.println(b2);
}
}
public class TestCharacter1{
public static void main(String[] args){
//字符的三种赋值方式
//第一种：字符赋值
char c1 = 'A';
System.out.println(c1);
//第二种：整数赋值 0~65535，【ASCII码十进制数65对应A】
char c2 = 65;
System.out.println(c2);
//第三种：进制赋值【'\u0041'是十六进制的数字65，】
char c3 = '\u0041';
System.out.println(c3);
//转义字符
/* \n 换行符*/
/* \t 缩进（制表符）*/
/* \\ 反斜线*/
/* \' 单引号*/
/* \" 双引号*/
char c4 = '\n';
System.out.println(c4);
char c5 = '\t';
System.out.println(c5);
char c6 = '\\';
System.out.println(c6);
char c7 = '\'';
System.out.println(c7);
char c8 = '\"';
System.out.println(c8);
}
}
public class TestString{
public static void main(String[] args){
//字符串
String s = "HelloJava";
System.out.println(s);
//如果要打两个斜杠“\\”应该String c9 = '\\\\'这样写
String c9 = "\\\\";
System.out.println(c9);
}
}
运算符
运算符分类
1.算术运算符：+ 、 - 、 * 、 / 、 % 、 ++ 、 --
2.赋值运算符：= 、 += 、 -= 、 *= 、 /= 、 %=
3.关系运算符：> 、 < 、 >= 、 <= 、 == 、 !=
4.逻辑运算符：! 、 & 、 | 、 ^ 、 && 、 ||
5.位运算符：& 、 | 、 ^ 、 ~ 、 >> 、 << 、 >>>
6.字符串连接运算符：+
1. 算数运算符
// + 、 - 、 * 、 / 、 %
// 比如一个三位数 求十位上 的数字
// 123十位上对应的数字是2
int a = 123;
// 123/10 -> 12%10 -> 2
int b = a/10%10;
// a%100 -> 23/10 -> 2
int c = a%100/10;
// ++ 、 --
int d = 5;
//【注意】下面"d = "后面的加号是【字符串拼接的运算符】，d++先赋值，所以结果d1是5，再++，这时d这个变量的值已经变为6了，d2直接数据d变量的值，所以结果是6
System.out.println("d1 = "+ (d++));// d1 = 5
System.out.println("d2 = "+ (d));// d2 = 6
int d = 5;
int e = d++ + 6;
//d先赋值给e，e这时的值为5，然后d++，d的值这时为6，e的值加上6结果为11
System.out.println("d = " + d);//d = 6
System.out.println("e = " + e);//e = 11
// 同上面的++一样，-- 放在前面是先自身减一 再参与运算
// -- 放后面 先参与运算 再自身减一
int d = 5;
int f = d-- + 6;
System.out.println("d = " + d);//d = 4
System.out.println(" f = "+ f);// f = 11
byte z = -128;
byte w = --z;
/*【解释一下这里为什么w的值为127】
我们想的是：-128-1=-129，结果不应该是-129么？
我们知道byte的范围是-128~127，正数用源码表示，复数用补码表示，第一位是符号位
所以-129表示为-129的源码为：10000000 00000000 00000000 10000001
因为-129超出了byte范围区间，所以-129为int类型，用补码（源码取反，末位+1）如下：
11111111 11111111 11111111 01111111，byte占8位，所以
11111111 11111111 11111111为溢出位，用byte类型只存储到01111111这一部分，也就是127
*/
System.out.println(" w= "+ w);// w = 127
2. 赋值运算符
int i = 34;
//i = i + 45;
i+=45;
// i = i -45;
i-=45;
//下面同理
i*=45;
i/=45;
i%=45;
System.out.println("i= "+ i);
3. 关系运算符
boolean b = 3>=3; // 结果为true 关系运算符 最终的结果都是boolean类型的
boolean b2 = 3==2; // 结果为false == 判断等号两边是否相等 如果相等就是true
boolean b3 = 3!=2; // 结果为true != 判断等号两边是否不等 如果不等就是true
System.out.println(b3);
int a = 4;
int c = 5;
boolean b4 = ++a>6 & ++c>3;
System.out.println(a);//5
System.out.println(++a>6);//false
System.out.println(++c>3);//true
System.out.println(c);//6
System.out.println(b4);//false
// &&短路与(逻辑与) 如果左边是 false 右边则不再执行，结果为false 一假全假
// ||短路或(逻辑或) 如果左边是true 右边则不再执行，结果为true 一真全真
//&&(短路与)||(短路或)在开发中使用比&(按位与)和|(按位或)用的多
//个人理解: 与->表示一起，并且的意思 或->表示或者的意思 短路就是不看另一侧的【这里可以类比联想到交集并集来理解】，下面详细介绍了逻辑运算符↓
4. 逻辑运算符
// == 判断基本数据类型的值 是否相同的 != 判断基本数据类型的值是否不等
// 引用数据类型判断用 equals
int i = 34;
boolean flag = i != 34;
System.out.println("flag = " + flag);//flag = false
boolean flag2 = false & false;//flag2 = false &必须是左右两边都是true 结果才是true
boolean a = false | false;// | 只要有一个true 结果就是true 两边都是false 结果才为false
System.out.println("flag2 = " + flag2);//flag2 = false
System.out.println("a = " + a);//a = false
// && || 有可能有一部分是执行不到的
// && 左边如果是 false 就不执行右边 最终结果是false
// || 左边是true 不用执行右边了 最终结果就是 true
int b = 5;
int c = 5;
boolean d = ++b > 5 || ++c > 5;// ++z > 5为true，后面并没有被执行
System.out.println("d = " + d + " b=" + b + " c=" + c);
/*
逻辑与,逻辑或在Java中运算符必须是boolean类型的,而按位与,按位或可以是int类型的，&和|也是位运算符
二进制5:101 4:100
二进制3:011 2:010
按位与&:001 000
按位或|:111 110
按位与全是1结果才为1，其余情况都为0
按位或两个中有一个为1，结果为1，否则为0
可以把1，0类比成真假，按位与全真为真，按位或一真则真，如若还有疑问，可以去查阅【离散数学】中如何讲解
*/
System.out.println(5 & 3);//结果为1
System.out.println(5 | 3);//结果为7
System.out.println(4 & 2);//结果为0
System.out.println(4 | 2);//结果为6
// ! 非 取反的意思，!true就为false
boolean e = !true;
System.out.println("e = " + e);
// ^ 异或 简单理解为找不同， 【相同则为false 不同为true】我找到了不同的，结果为true
boolean f = true ^ false;
System.out.println("f = " + f);
5. 位运算符
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100 全1为1，否则0
A | B = 0011 1101 两个中有一个为1，就为1，否则0
A ^ B = 0011 0001 不同为1，否则0
~A= 1100 0011 按位取反，反转操作符的每一位，即0变1，1变0
下面是详细说明↓
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b; /* 12 = 0000 1100 */
System.out.println("a & b = " + c);//a & b = 12
c = a | b; /* 61 = 0011 1101 */
System.out.println("a | b = " + c);//a | b = 61
c = a ^ b; /* 49 = 0011 0001 */
System.out.println("a ^ b = " + c);//a ^ b = 49
c = ~a; /*-61 = 1100 0011 */
/*
这里解释一下为什么取反为-61
在计算机中，所有数据的表示方式都是以补码的方式存在
正数：符号位为0，原码，反码，补码相同
负数：符号位为1，反码=符号位为1，其余求反，补码 = 反码 + 1
我们接着看，60二进制表示为：00111100(在计算机中补码保存)
取反：11000011(在计算机中补码保存)
我们最终需要它的原码，首先，这是一个负数，我们倒着来，先根据补码求出反码，然后根据反码求出源码，
因为是负数所以为：【1 11000011】(前面的1代表符号位)
它的反码为：补码-1，补码是【1 11000011】(符号位不参与运算)，-1后是【1 11000010】，即为反码
它的原码为：反码求反，反码是【1 11000010】(符号位不参与运算)，求反后是【1 00111101】结果为-61
这里有个结论：
当n为正数时，~(n) = -(n+1) 例如：~(60)=-61
当n为负数时，~(-n) = n - 1，忽略负号 例如：~(-3)=2
*/
System.out.println("~a = " + c);//~a = -61
c = a << 2; /* 240 = 1111 0000 */
System.out.println("a << 2 = " + c);//a << 2 = 240
c = a >> 2; /* 15 = 1111 */
System.out.println("a >> 2 = " + c);//a >> 2 = 15
c = a >>> 2;/* 15 = 0000 1111 */
System.out.println("a >>> 2 = " + c);//a >>> 2 = 15
6. 字符串连接符
//用字符串连接符+连接字符串，如下：
System.out.println("Hello"+"World!");//HelloWorld!
System.out.println("Hello = "+ 5);//Hello = 5 字符串和基本数据类型变量 常量连接以后 都变成了 字符串
System.out.println("Hello = "+ 5 + 8);//Hello = 58
System.out.println(5+"");//5
7.三目运算符
//X ? Y : Z
// 1. X 必须是boolean类型表达式
// 2. Y Z 必须数据类型保持一致
// 执行顺序
// 先执行X true 执行Y,false 执行Z;也就是说,为真执行前面的,为假执行后面的
int score = 99;
boolean flag = score > 80;//true
System.out.println(flag);
String str = score > 80 ? "非常优秀" : "优秀";
System.out.println(str);//非常优秀
char c = '男';
int i = c == '男' ? 5 : (int) (4.0);
// y和z 最好是保持数据类型一致
// 如果不一致 也必须保证【接收的变量】能够【存储 y和z的数据类型】
System.out.println(i);//5
// 大于90 非常优秀 大于等于60 及格 小于60 还需加油
String str2 = score>90?"非常优秀":score>=60?"及格":"还需加油";
System.out.println(str2);
8.表达式
表达式是符合一定语法规则的运算符和操作数的序列,比如:
5.0 + a
(a - b) * c - 4
i < 30 && i % 10 != 0
对表达式中操作数进行运算得到的结果称为表达式的值
类型转换
1. 自动类型转换
public class TestConvert1{
public static void main(String[] args){
/*
类型转换（基本数据类型）
一、自动转换
1、转换的两种数据类型要兼容
2、目标类型大于原类型（自动往高类型转换）
【从小到大】byte--short--int--long--float--double
char--int
*/
byte b = 100;
short s = b;
int i = s;
long l = i;//不需加L，没越界
System.out.println(l);//100
}
}
2.强制类型转换
public classTestConver2{
public static void main(String[] args){
/*
二、强制类型转换
1、转换的两种数据类型要兼容
2、目标类型小于原类型（强制转换称更低的类型）
【从大到小】
*/
short s = 123;
byte b = (byte)s;
System.out.println(b);//123
int i = 65;
char c = (char)i;
System.out.println(c);//A
//double转int，越界，精度有损失，小数点全舍掉了
double d = 3.14;
int ii = (int)d;
System.out.println(ii);//3
}
}
总结：小的赋值给大的，会发生自动类型转换，大的赋值给小的，要强制类型转换
下面是一个类型转换中有趣的例子，涉及类型所占字节位数问题
public class TestConvert3{
public static void main(String[] args){
//扩展内容
short s = 256;
byte b =(byte)s;
System.out.println(b);
/*
涉及进制转换
short占2字节共16位，256为10进制转化为2进制0000 0001 0000 0000
byte占1字节共8位，所以要从右往左截取8位0000 0000
第一位为符号位，0为正，1为负。
输出结果为0
*/
}
}
类型提升
自动类型提升
运算中，不同类型的数据先转化为同一类型，然后进行运算
低 ------------------------------------> 高
【byte,short,char—> int —> long—> float —> double】
具体如下：
两个操作数有一个为double，计算结果提升为double。
如果操作数中没有double，有一个为float，计算结果提升为float。
如果操作数中没有float，有一个为long，计算结果提升为long。
如果操作数中没有long，有一个为int，计算结果提升为int。
如果操作数中没有int，均为short或byte，计算结果仍旧提升为int。
任何类型与String相加（+）时，实为拼接，其结果自动提升为String
总结
1. boolean 类型不能转换成任何其它基本数据类型。
2. 自动类型转换：数据类型取值范围小的转为取值范围大的
byte,short,int,long,float,double
char-> int,long,float,double
short,char不会互相转换
byte,short,char三者在计算时会转换成int类型
3. 强制类型转换：数据类型取值范围大的 转为 取值范围小的. 需要加强制转换符，也就是（要转换的数据类型）如:
long l = 100L;int i = (int)l;
【但有可能造成精度降低或数据溢出，使用时要小心】
浙公网安备 33010602011771号