1. 常量
1. 在程序运行的过程,其值不发生改变
2. 分类:
1. 字面值常量
2. 自定义常量
3. 字面值常量
1. 字符串
2. 整数
3. 小数
4. 字符
5. 布尔
6. 空
如下:
/*
常量:在程序运行时不发生改变的值
分类:字面值常量
自定义常量
字面值常量:
字符串: " "
举例: "HelloWorld" , "吃多了"
整数:
举例: 0,123,
小数:
2.5 ,4.5
字符: ''
'a','0' 字符只能表示一个
'ab' 错误的
布尔:
true 真
false 假
空:
null
*/
class ConstantDemo{
public static void main(String[] args){
//定义常量
//字符串
System.out.println("我们来认识常量");
//整数
System.out.println(100);
//小数
System.out.println(3.14159265);
//字符
System.out.println('a');
System.out.println('0');
System.out.println('ab');
//布尔
System.out.println(true);
System.out.println(false);
//空
//System.out.println(null);
}
}
4. 进制:人为规定的进位的方式
5. 二进制 八进制 十进制 十六进制
1. 二进制的由来,开关的状态
2. 二进制的简化-->8进制,16进制
3. 表示方式
1. 0b100
2. 0100
3. 100
4. 0x100
4. 进制的转换
1. x进制转到10进制-->系数*基数^权值之和
2. 10进制转到x进制-->除除除x,直到0,余数反转
3. 8421码--每一个二进制1表示一个十进制值
4. 任意进制相互转换靠8421快速转换
5. 有符号的表示方式(了解)
1. 符号位 数值位
2. 正数 0 值,原反补一样
3. 负数 1 值
4. 反码,取反(数值位取反)
5. 补码,补1
如下:
/*
进制不同的表现形式
二进制: 0b 0 1
八进制: 0 0-7
十进制: 0-9
十六进制: 0x 0-9 a,b,c,d,e,f
*/
class ConstantDemo2{
public static void main(String[] args){
//输出不同进制 100
//二进制
System.out.println(0b100); //4
//八进制
System.out.println(0100); //64
//十进制
System.out.println(100); //100
//十六进制
System.out.println(0x100); //256
}
}
/*
带符号的表示法
1 010 0101
符号位 数值位
1 0100101
原码:
符号位 0表示正 ,1表示负
数值位表示的是大小
反码: 符号不变 数值位取反 0-->1 1-->
符号位 数值位
1 1011010
补码: 就是在 数值位补1
符号位 数值位
1 1011011
符号位 数值位
原码:+7 0 0000111
反码: 同上
补码: 同上
符号位 数值位
原码:-7 1 0000111
反码: 1 1111000
补码: 1 1111001
+7 补码 0 0000111
-7 补码 1 1111001
--------------------------
10 0000000
*/
2. 变量
1. 变量:在程序运行时,其值可以发生改变
2. 数据类型 变量名 = 初始化值;
3. 数据类型
1. 限制初始化值的变化的范围
2. 四类八种
1. 整数--byte,short,int,long
2. 浮点--float(单精度) ,double(双精度)
3. 字符--char (0~65535)
4. 布尔--true false
如下 :
/*
变量的格式:
数据类型 变量名 = 初始化值;
price = 5999;
分类:
基本数据类型 : 四类八种
整数--
byte 1字节 8位 -128~ 127
short 2字节 16位 -32768 ~ 32767
int
4字节 32位 -2147483648 ~ 2147483647
long 8字节 64位
浮点数--
float 4字节 32位
double 8字节 64位
字符
char 2字节 16位 0~65535
布尔
boolean 1字节 true false
引用数据类型
类
接口
数组
1.整数赋值的过程当中,默认的类型int,那么如果数值太大,超出范围,那么报错.
long 类型,在数值后面 l 或者 L
2.浮点数赋值,默认的类型是double,那么如果赋值不精准,那么报错.
float类型,在数组后面 f 或者 F
*/
class BianLiangDemo{
public static void main(String[] args){
//定义变量
//整数类型
byte b = 10;
System.out.println(b);
short s = 5999;
System.out.println(s);
//int i= 100000;
//int i = 10000000000000; //过大的整数
long l = 10000000000000L; //错误: 过大的整数: 10000000000000
System.out.println(l);
//浮点数
float f = 3.14F;
System.out.println(f); //错误: 可能损失精度
double d = 3.1434456;
System.out.println(d); //错误: 可能损失精度
//字符
char c = 'a';
char c2 = 'a';
System.out.println("----------");
System.out.println(c2+1);
//布尔
boolean bo = false;
boolean bo2 = false;
System.out.println(bo);
System.out.println(bo2);
}
}
3. 数据类型的转换
1. 隐式转换
1. byte,short,char -->int-->long-->float-->double
2. 显示转换(强制转换)
1. 格式: 数据类型 变量名 = (目标数据类型) (数据)
2. 隐藏了损失精度的问题
3. float f = 2.1+5.5;
4. byte b = 300+4;
如下:
/*
类型的默认转换:
byte,short,char --> int --> long -->float -->double
顺序从小到大,隐式转换.向上提升
byte ,short ,char 相互不转换 ,直接转换int类型
注意: boolean类型不能转换为其他的数据类型
*/
class BianLiangDemo2{
public static void main(String[] args){
int x = 3;
byte y = 4 ;
//int z = x+y;
// byte z = x+y; 错误: 可能损失精度
System.out.println(z);
}
}
/*
强硬手段: 强制转换 --(显示转换)
格式:
数据类型 变量名 = (目标数据类型)(数据);
在使用强制转换的时候,这里面隐含了可能损失精度的问题,会产生意想不到的效果,所以强转慎用 .
*/
class BianLiangDemo3{
public static void main(String[] args){
int x = 3;
//byte y = 4 ;
byte y = 126;
//强制转换
byte z = (byte)(x+y);
System.out.println(z);
}
}
________________________________________
/*
变量注意的小问题
1.作用域,用大括号来限定变量的作用范围.
2.初始化值的问题,定义变量,不赋值可以,但是,不能使用它.
想要使用,必须在使用前赋值.
建议: 在定义变量的时候,就赋值.
3.一行一个变量,如果一行定义多个变量也行,但是,不建议.
建议:一行就一个变量,定义时就赋值.
*/
class BianLiangNotice{
public static void main(String[] args){
//定义变量
//
int x =100; 作用域问题
//
{
//
//
System.out.println(x);
//
}
//
int x ;
//
x=1000;
//
System.out.println(x); // 可能尚未初始化变量x
int x,y ;
x=10;
y=20;
System.out.println(x);
System.out.println(y);
}
}
4. 字符和字符串
1. 字符类型-->类型提升int
2. 字符串--> 连接符运算 (俄罗斯方块)
3. 运算符--有运算就有结果
1. 算术
1. + - * / %
2. ++ --
1. a++ :先赋值 再++
2. ++a :先++ 再赋值
如下 :
/*
运算符:
算术运算符:
简单 + - * / %
扩展 ++ --
*/
class YunSuanDemo{
public static void main(String[] args){
//演示 运算符
System.out.println(3+4); //7
System.out.println(3-4); //-1
System.out.println(3*4); //12
System.out.println(3/4); //0 整数运算结果只能是整数
System.out.println(3.0/4);
System.out.println(3%4); //0 余数 3
}
}
/*
++ -- 运算符
单独使用: ++ 加1的操作
-- 减1的操作
前后都一样.
运算使用:
a++ b-- ,先赋值,后去++
++a --b ,先++ , 后赋值
*/
class YunSuanDemo2{
public static void main(String[] args){
//演示 ++ --运算符
int x =3;
int y =4;
//
x++;
//
y--;
++x;
--y;
System.out.println(x); // 4
System.out.println(y); // 3
System.out.println("------------");
int a =3;
int b =4;
//
int c = a++;
//
int d = b--;
int c = ++a;
int d = --b;
System.out.println("c:"+c); // 3 4
System.out.println("d:"+d); // 4 3
}
}
2. 赋值
1. = 右边赋值给左边
2. += -= *= /= %=
1. 变量的理解
2. 左边和右边做运算,再赋值给左边
如下 :
/*
赋值运算符:
简单 = : 把右边的值 赋值给左边
int a = 7;
扩展:
+= -= *= /= %=
左边和右边做运算,再赋值给左边
*/
class YunSuanDemo3{
public static void main(String[] args){
// 扩展:
// += -= *= /= %=
int x =3;
int y =4;
//x+=y; 7
//x-=y; //-1
System.out.println(x+=y); // 7
System.out.println("x:"+x+"y:"+y); // 7
System.out.println(x-=y); // -1
System.out.println("x:"+x+"y:"+y);
System.out.println(x*=y); // 12
System.out.println("x:"+x+"y:"+y);
System.out.println(x/=y); // 0
System.out.println("x:"+x+"y:"+y);
System.out.println(x%=y); // 3
System.out.println("x:"+x+"y:"+y);
}
}
3. 关系
1. 大小关系,结果 boolean类型
2. == != < > <= >=
3. 举例: 3==4, 5>9
如下 :
/*
关系运算符:
关系就指大小关系,运算结果 真或者假
注意:结果只能是 boolean 类型 true /false
== != < > <= >=
*/
class YunSuanDemo4{
public static void main(String[] args){
//关系运算符
int a =10;
int b =10;
boolean bo = (a=b);
System.out.println(bo);
System.out.println(a!=b);
}
}