Day02 数据类型、变量、操作符
1、数据类型
1.1、分类
1.2 整型案例
public class DT_01_Int {
/**
- 十进制 : 非0开始
- 八进制 : 0开始的数字
- 十六进制 : 0x开始的数字
-
-
@Date 2021年3月23日
*/
public static void main(String[] args) {
// 使用int创建一个 32位大小的空间,并取名为 i_1 ,把29 放进去
// 同域中,不能有相同的名字(同一个大括号中)
int i_1 = 29;
int i_2 = 027;
int i_3 = 0xaf;
// 向控制台打印数据,根据名字找到即可
System.out.println( i_1 );
System.out.println( i_2 );
System.out.println( i_3 );// 这个123 是int类型,然后自动转换为 long类型
// 因为 java中 整数 默认是整型int
// 小数 默认是 双浮点 double
long l_1 = 2147483647;
// 这种 是直接创建long类型的值,不需要转换
// 小写和大写的 L/l 都可以 建议大写,否则 l 和 1 不太好区分
long l_2 = 9223372036854775807L;
}
}
1.3 浮点型案例
package _01_DataType;
-
/**
-
小数默认是double
-
float声明方式,需要在值的后面追加 F/f
-
@Date 2021年3月23日
*/
public class DT_02_Double {public static void main(String[] args) {
// 1.4 就是double类型,不需要转换
double d_1 = 1.41;// 强制类型转换为 float float f_1 = (float)1.42; // 直接赋值为 float类型的值 F/f float f_2 = 1.43F; System.out.println(d_1); System.out.println(f_1); System.out.println(f_2);}
}
1.4 字符型案例
package _01_DataType;
/**
-
char是字符型,使用 ‘’ 英文单引号表示,有且只有一个数据
-
占用2字节 16位 范围是 0~65535 没有负数
-
short 短整型 16位 -32768 ~ 32767
-
ASCII a 97 A 65 0 48
-
unicode 编码 \ uxxxx
-
编码和解码不一致,就乱码
-
@Date 2021年3月23日
*/
public class DT_03_Char {
public static void main(String[] args) {
char c_1 = ‘a’;
char c_2 = ‘A’;
char c_3 = ’ ';
char c_4 = ‘中’;
System.out.println(c_1);
System.out.println(c_2);
System.out.println(c_3);
System.out.println(c_4);// 转移符, 把有意义字符串 转换为 无意义字符, 用 \ 表示 // 单引号中只能出现一个字符,那如果我们想用字符保存一个单引号 怎么办? // char c_5 = '''; char c_5 = '\''; char c_6 = '\\'; System.out.println(c_5); System.out.println(c_6); // \r\n 换行, \s 空格 , \t 制表符 System.out.println('\r'); System.out.println('\r'); System.out.println('\t'); // unicode编码 char c_7 = '\u4E02'; // /u4E00-/uFA29 System.out.println(c_7);}
}
1.5 布尔型案例
package _01_DataType;
/**
-
java中的boolean类型,值只有 true/false 不是 bool
-
1 不能参与任何类型转换
-
2 主要用于流程控制
-
3 内存中,占用1字节, 0000 0000 表示false , 0000 0001 表示true
-
4 布尔型表达式 : 结果为true/false的运算,比如 1 小于 2 结果为 true
-
@Date 2021年3月23日
*/
public class DT_04_Boolean {public static void main(String[] args) {
boolean flag = true;
boolean flag1 = false;
if(flag){
System.out.println(“为真”);
}else{
System.out.println(“为假”);
}
}
}
1.6 类型转换
/**
-
1 boolean不参与转换
-
2 低精度到高精度是自动转换,高精度到低精度是强制转换
-
自动类型转换
-
byte -> short -> int -> long -> float -> double
-
char -> -
@Date 2021年3月23日
*/
public class DT_05_DataChange {public static void main(String[] args) {
byte b_1 = 123;
short s_1 = 124;
char c_1 = ‘c’;
int i_1 = 88;
long l_1 = 213;
float f_1 = 1.5F;
double d_1 = 1.4D;
// byte -> short 可以
short s_2 = b_1;// char -> short 不行 // short s_3 = c_1; // short -> char 不行 // char c_2 = s_1; // byte -> char 不行 // char c_3 = b_1; // char -> int 可以 int i_2 = c_1; // int -> char 不可以 // char c_4 = i_1; // short -> int 可以 int i_3 = s_1; // int -> long 可以 long l_2 = i_1; // float -> long 不可以 // long l_3 = f_1; // long -> float 可以 float f_2 = l_1; // float -> double 可以 double d_2 = f_1; // 强制转换,精度一定会丢失,数据可能出错,删除高位 // (数据类型) int i_10 = 127; byte b_10 = (byte) i_10; System.out.println(b_10); // 0000 100000001 }}
1.7 混合运算
/**
-
1 boolean不参与转换
-
2 低精度到高精度是自动转换,高精度到低精度是强制转换
-
自动类型转换
-
byte -> short -> int -> long -> float -> double
-
char -> -
@Date 2021年3月23日
*/
public class DT_05_DataChange {public static void main(String[] args) {
// 混合运算,结果的类型为 运算中 最大的数据类型
int result = 10 / 3 +1+‘c’;
System.out.println(result);// 混合运算中, byte,short,int,char 四种中,任意一种或多种进行运算 // 结果都是int byte b1 = 1; byte b2 = 2; short s1 = 1; char c1 = 'a'; int result1 = b1+b2+s1+c1; // 小数问题,不要使用小数做判断 double d1 = 0.1+0.2; // 0.30000000000000004 System.out.println(d1);}
}
- 变量和常量
2.1 常量/字面量/直接量
/**
-
常量 : 在整个程序的生命周期中,值不可更改(从运行到结束)
-
1 final修饰的变量 final int i = 2; -
2 字面量 也是常量,又叫直接量 , 比如直接打印 System.out.println(123) -
常量一般是 final 修饰的静态变量居多 , public static final int a = 2;
-
@Date 2021年3月23日
*/
public class Var_01 {public static void main(String[] args) {
final int i = 2;
// final 修饰 不可更改
// i = 3;
System.out.println(i);
// 直接量 不可更改(运行时)
System.out.println(12345);
}
}
2.2 变量
package _02_Var;
/**
*
-
变量 : 有名字的内存空间,可以通过名字找到它,更改它,访问它
-
变量目的 : 通过名字即可找到,操作方便,可以重复使用
-
变量声明 : 两步 数据类型 变量名;
-
变量定义 : 三步 数据类型 变量名 = 值;
-
数据类型划分内存空间,命名,赋值 -
变量分类 :
-
局部变量 : 方法中声明的变量 -
静态成员变量 : 类体中使用static声明的变量 -
成员变量 : 类体中没有static声明的变量 -
@Date 2021年3月23日
*/
public class Var_02 {
// 静态
static int a = 2;
// 成员
int b = 3;public static void main(String[] args) {
// 局部
int i = 2;
System.out.println(i);// 必须先声明 后使用 // System.out.println(i1); int i1 = 2; int a; // 局部变量 没有默认值,不赋值 不能使用 // System.out.println(a); // 同时声明多个变量 int c=1,d=2,e=3;}
}
2.3 命名规则
强制 : 大小写字母,数字,下划线,美元符号,数字不能开头,不能使用关键字和保留字
非强制 : 驼峰命名法,望文知义
文件名,变量名,方法名,类名,包名(文件夹名) 一切需要我们命名的地方,都要符合这个规则
2.4 作用域
/**
-
一个 {} 就可以理解为一个独立的作用域
-
变量向上找 第一个包含它的大括号 就是它的作用域
-
@Date 2021年3月23日
*/
public class Var_03 {
public static void main(String[] args) {
int a = 1;
if (true) {
int i = 2;
// 因为外面已经有了a了,并且a的作用域 在这里可以访问到
// int a = 1;
System.out.println(i);
System.out.println(a);
}
// if 中的i 作用域 就在if中,这里访问不到
// System.out.println(i);// 因为if中的i的作用域在if中,对于这里 等于是没有i的,所以可以再声明一个i int i = 22; System.out.println(i); System.out.println(a);}
}
2.5 静态变量
/**
-
静态变量 : 类体中,方法外 用static 修饰的变量 是静态变量
-
有默认值,可以和局部变量同名
-
整型 : 0 , 浮点 : 0.0 , 布尔型 : false , 字符型 : \u0000 -
调用静态变量 : 变量所在的类名.静态变量名 , 如果调用当前类中的静态变量,类名可以省略
-
如果和局部变量同名,则在该方法中,局部变量优先级高于静态/成员变量
-
@Date 2021年3月23日
*/
public class Var_04 {
static int age = 18;int xxxx = 2;
public static void main(String[] args) {
System.out.println(Var_04.age);
System.out.println(age);
int age = 20;
// 同名 局部变量优先级高
System.out.println(age);
// 可以使用类名来区分同名的局部变量和静态变量
System.out.println(Var_04.age);
}
}
- 操作符
3.1 算符运算符
-
, - , * , / , %
++ , – 优先级 大于加减乘除
单目 > 双目 > 三目
public class Operator_01 {public static void main(String[] args) {
// 局部变量
int a = 10, b = 3;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
System.out.println(a % b);// ++ : 把空间中的值取出, +1 后,再放回去 int k = 100; // k = k + 1; k++; // k++ 和 ++k 如果都是单独出现的(不参与混合运算),没有任何区别 ++k; System.out.println(k); // 初始化为100 k = 100; //++在变量前面时，先做运算后赋值 // ++在变量后面时，先做赋值后运算 // k = k++ + 1; k = k++ + k; System.out.println(k); int w = 10; w = w++ * w; System.out.println(w); int x = 10; int y = ++x + 1; // 12 System.out.println(y); // 11 System.out.println(x); int p = 2; p = 2 + p++ + ++p + p++ + ++p; // p = 2 + 2 + 4 + 4 + 6; p = 6 System.out.println(p); int z = 10; z = 10 + z++ + ++z + (10 * z++) + ++z; // z = 10 + 10 + 12 +(10*12) + 14; z = 14 // 166 System.out.println(z); byte b1 = 1; b1++; b1 = (byte) (b1+1); System.out.println(b1);}
}
3.2 位运算符
/**
-
位运算符 :
-
& 位与 , 两把都为true,结果才是true -
| 位或 ,一边为true,结果就是true -
! 位非,取反,真就是假,假就是真 -
^ 位异或,两边不一样 就是true -
&& 短路与,且 -
|| 短路或 -
~ 按位非 , 比如 0 ,二进制是 0000 0000 ~0 之后 就是 1111 1111(补码 ) 1111 1110 (-1 反码) 1000 0001 (取反 源码) -
>> 右移运算(考虑符号位,符号位不变) 8 >> 3,最右边删除以为,最左边补 符号位(正数补0,负数补1) -
8/2^3 -
<< 左移运算(考虑符号位,符号位不变) , 同上, 8 << 3 = 8 * 2^3 -
>>> : 右移运算(不考虑符号位),正数 和 >> 一样, 负数也是最左边补0(不考虑符号位) -
@Date 2021年3月23日
*/
public class Operator_02 {public static void main(String[] args) {
// 如果 & 两边是数字,转换为二进制,然后每位进行比较,都是1,取1,都是0,取0,不一样取0
// 与运输 结果不会超过两个数中的最小的一个
// 1000 1010 , 1,0,0,0
System.out.println(8 & 10);
// false
System.out.println( 1<2 & 2>3);
// true
System.out.println( 1<2 | 2>3);
// false
System.out.println(!true);
// true
System.out.println(true ^ false);
// false
System.out.println( 1<2 && 2>3);
// true
System.out.println( 1<2 || 2>3);
// 测试 && 和 &
int a = 10, b = 10;
boolean flag = a > b && a>b++;
System.out.println(b);System.out.println(~1); System.out.println(-1 >>> 1);}
}
3.3 关系运算符
/**
-
关系运算符,返回都是boolean(true/false)
-
, < , >= , <= , == , !=
-
== : 基本类型 比较值,引用类型 比较地址
-
@Date 2021年3月23日
*/
public class Operator_03 {public static void main(String[] args) {
int a = 10 , b = 11;
System.out.println(a == b);
System.out.println(a >= b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a < b);
System.out.println( a != b);
}
}
3.4 赋值运算符
/**
-
赋值运算符
-
= : 右边的赋值给左边
-
+= : 左边和右边相加,再赋值给左边
-
/= : 左边除以右边,结果赋值给左边
-
-=
-
*=
-
%=
-
i++ ; 等价于 i = i +1;
-
i+=2 ; 等价于 i = i + 2;
-
虽然是等价关系,但是 ++ 和 += 这些 会进行自动强制类型转换,比如 i 是byte类型,则 i+1 结果为int类型, i = i+1需要强制类型转换
-
而 ++ 和 += 就不需要强制类型转换,数据该出错还是出错,就等于帮我们自动强制转换了而已
-
@Date 2021年3月23日
*/
public class Operator_04 {public static void main(String[] args) {
int a = 10;
a += 10;
// 20
System.out.println(a);
a -= 5;
// 15
System.out.println(a);
a *= 5;
// 75
System.out.println(a);
a /= 15;
// 5
System.out.println(a);
a %= 2;
// 1
System.out.println(a);byte b1 = 127; // 报错 需要强制转换 , 因为 byte,short,char,int 任意一种或多种进行运算,结果都是int值 // b1 = (byte)(b1 +1) ; // 虽然数据还是会出错,但是不用强制转换了 b1++; b1+=2; System.out.println(b1);}
}
3.5 字符串拼接符
/**
-
字符串拼接符 : + ,用于把多个字符串拼接成一个字符串
-
只要左右有一个字符串,则 + 就是字符串连接符
-
若两边都是数字,则+为 加和运算
-
@Date 2021年3月23日
*/
public class Operator_05 {public static void main(String[] args) {
// 字符串类型
String name = “张三”;
System.out.println(name);
int a = 10;
int b = 11;
System.out.println(“a+b=”+a+b);
System.out.println(“a+b=”+(a+b));
System.out.println(a+"+"+b+"="+(a+b));
}
}
3.6 三目运算符/三元运算符
/**
-
三目运算符又叫三元运算符
-
语法 : boolean表达式 ? 真语句 : 假语句;
-
boolean表达式 : 运算结果为boolean类型即可
-
@Date 2021年3月23日
*/
public class Operator_06 {public static void main(String[] args) {
int a = 5; int b = 4; int c = a++ - --b * ++a / b-- >> 2 % a--; // int c = -2 >> 2; a=6 b=2 System.out.println(c); int i = 1 < 2 ? 1 : 2; System.out.println(i); if (1 < 2) { i = 1; // 可以写任何代码 } else { i = 2; }}
}
3.7 优先级
- 流程控制
4.1 顺序结构
正常编码,从上往下,从左到右执行即可
4.2 分支结构
根据业务逻辑,某些代码在某种情况下执行
或者是根据不同的情况执行不同的代码
技术栈 : if…else … switch
4.2.1 If
4.2.1.1 单分支
/**
-
单分支 :
-
有不执行情况,比如boolean表达式为false -
if( boolean表达式 ){ -
java代码; -
} -
@Date 2021年3月23日
*/
public class IF_01 {public static void main(String[] args) {
// 又不执行情况
if(1>2){
System.out.println(“原来1小于2”);
}
}
}
4.2.1.2 双分支
/** -
双分支,有且只有一个分支执行
-
if( boolean表达式 ){ -
为真的代码; -
}else{ -
为假的代码; -
} -
@Date 2021年3月23日
*/
public class IF_02 {public static void main(String[] args) {
if (1<2) {
System.out.println(“原来1小于2”);
}else{
System.out.println(“原来1大于2”);
}
}
}
4.2.1.3 多分支
/**
-
多分支 : 只会有一条分支执行,有一条执行之后,整个分支结束
-
1 有不执行情况
-
if( boolean表达式 ){ -
真语句; -
}else if( boolean表达式 ){ -
真语句; -
}else if(......){ -
} -
2 没有不执行情况
-
if( boolean表达式 ){ -
真语句; -
}else if( boolean表达式 ){ -
真语句; -
}else if(......){ -
}else{ -
} -
@Date 2021年3月23日
*/
public class IF_03 {public static void main(String[] args) {
int a = 2 ;
int b = 3;
// 多条分支符合条件,也只有一条执行(最先符合条件的执行)
// 都不符合条件,则都不执行,所以有不执行情况
if (b < a) {
System.out.println("===");
}else if (b <= a) {
System.out.println("—");
}// 如果以else结尾 能够保证必须有一条分支执行 if (b < a) { System.out.println("==="); }else if (b <= a) { System.out.println("---"); }else{ System.out.println(".............."); }}
}
4.2.1.4 特殊情况
public class IF_04 {
public static void main(String[] args) {
// 若 分支只有一条语句,则{} 可以省略
if (true)
System.out.println("1111");
if(true)
System.out.println(222);
else
System.out.println("111111");
if(true)
System.out.println(222);
else if(false)
System.out.println("111111");
else if(false)
System.out.println("=========");
}
}
4.2.2 Switch
4.3 循环结构
重复执行某些代码
1292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
