变量
变量和常量是程序处理的两种基本数据对象，变量是程序的基本组成单位
变量的目的就是确定目标并提供存放空间
public class Hello
{
public static void main(String args[])
{
int a=10; //定义一个变量，并赋值
int b=20;
int result=a+b; //变量之间的运算
System.out.println("结果是"+result);
}
}
运行结果：
D:myJavaDemo>javac -encoding UTF-8 Hello.java D:myJavaDemo>java Hello 结果是30
基本数据类型
补码
程序在运行的时候都是用补码运行的，同样计算出的结果也是补码，
- 0的原码和补码都是0，
- 正数的补码是其本身的二进制形式，
- 负数的补码需要先将其绝对值按位取反（取得的结果叫做反码），再 +1。
比如 - 3 ，就是先将 1000 0011 按位取反（除了符号位），得到 1111 1100 ，在 +1 得到 1111 1101
java有四大基本数据类型：整数类型，浮点类型，布尔类型，字符类型
整数类型
整数类型可以表示一个整数，常用的整数类型有：byte，short，int，long
计算机中的信息存储单位：
-
- 最小是bit，也就是位——表示0/1
- 1 字节（Byte / B） == 8 位（bit）
- 1 KB == 1024字节(B) == 2^10B
- 1 MB == 1024KB == 1024 * 1024字节 == 2^20B
- 1 GB == 1024MB == 2^30B
他们之间的区别主要是大小
-
- byte 一个字节————（-128-127）
- short 两个字节————（-32768-32767）
- int 四个字节————（........）
- long 八个字节————（........）
数字的范围是如何计算出来的呢？
计算公式：
最高位是符号位（0表示正数，1表示负数），所以一个字节中的8位只有7位可以用，最大的数为
- 0111 1111 —— 2^7 - 1 == 127
- 1111 1111 —— - (2^7 - 1) == -127
但是最小为什么是 -128 呢？这就体现出印度人的聪明来了，因为是印度人发明的
- 0000 0000 —— 表示的是 0
- 1000 0000 —— 表示的是 -0
这不就浪费了一个数了吗，所以人们就把 - 0 看成 -128，
- [-128] 原码 = 1000 0000 —— 发生了溢出（二进制形式是1000 0000，恰巧和符号位一样都是1不要误解），反码1000 0000是省略了最前面的1，因为溢出
- [-128] 反码 = 1111 1111 —— 最高位是符号位所以不会改变，其余取反
- [-128] 补码 = 1000 0000 —— 反码 + 1，符号位不会受到影响
1 + 3 的计算过程（运算结果也为补码）
- 原码为：0000 0001 + 0000 0011
- 补码为：0000 0001 + 0000 0011 = 0000 0100
- 运算结果也是补码，但是符号位是0，一个正数，原码就是它本身0000 0100 == 3
1 + -3 的计算过程
- 原码为：0000 0001 + 1000 0011
- 补码为： 0000 0001 + (1111 1100 + 1) = 0000 0001 + 1111 1101 = 1111 1110
- 符号位为1说明是一个负数，转换为原码得（1111 1110 - 1，再取反）1000 0010 == -2
1 + (-128) 计算机的计算过程为
- 原码：0000 0001 + 1000 0000
- 转换为补码： 0000 0001 + 1000 0000 == 1000 0001
- 1000 0001 的符号位为1，是负数，转换成原码为（1000 0001 - 1，再取反）1111 1111 == -127
- -127的原码为 1111 1111 ， 补码为 1000 0000 + 1 = 1000 0001
- 127的原码为 0111 1111 ，补码为 0111 1111
神奇的事情就是，把-0在取反码进行计算后，结果就是用128进行计算的值！！！
用程序验证byte型的大小
public class Hello
{
public static void main(String args[])
{
byte bytel = 127;
}
}
//程序可以正常运行
public class Hello
{
public static void main(String args[])
{
byte bytel = 128;
}
}
//报错会损失精度
D:myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:6: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte bytel = 128;
^
1 个错误
现有的数据结构不够大的时候，可以用链表，字符数组，字符串来解决这样的问题
浮点类型
浮点类型可以表示一个小数，常用的浮点类型有：float，double（单精度，双精度），他们的区别主要是数据大小范围
布尔类型
布尔类型可以表示，真或者假，类型是boolean
boolean spBool = true;
字符类型
字符类型可以表示 单个字符，字符类型是char
多个字符称之为字符串，在java中用String（还真是大写）这种数据类型表示，但是String不是基本数据类型，而是类，类是复合数据类型（之后会学习到）
java中字符的加减法
字符类型是一个特殊的整形
public class Hello
{
public static void main(String args[])
{
int test1 = 'a' + 'b'; //把a和b对应的ascii码的数相加,赋值给test1
char test2 = 'a' + 'b';
char test3 = '中'; //java中一个char占用两个字节,所以可以存放汉字
char char1 = 'q';
int char2 = '中'; //中文是用unicode号存放的
System.out.println(test1);
System.out.println(test2);
System.out.println(test3);
System.out.println(char1);
System.out.println(char2);
}
}
运行结果：
D:myJavaDemo>java Hello
195
?
中
q
20013
注:中对应的unicode码为u4e2d,为20013的16进制形式
结论：在java中，对char进行运算的时候，直接当做 ascii码对应的整数 对待
java基本语法——定义变量、初始化、赋值
什么是定义变量？
int a1;
//这就是定义了一个变量,表示定义了一个整数,名字叫做a1
初始化变量
int a = 45; //这就是初始化变量,在定义变量的时候就给值
给变量赋值
int tt; tt = 7780;
int a=25;
a = 45;
//两者都是给变量赋值
数据类型的转换
例1
public class Hello
{
public static void main(String args[])
{
int a = 1.2;
}
}
只要损失精度就会报错：
D:myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:6: 错误: 不兼容的类型: 从double转换到int可能会有损失
int a = 1.2;
^
1 个错误
精度排行：byte < short < int < long < float < double
例2
public class Hello
{
public static void main(String args[])
{
int b = 10;
System.out.println(b);
}
}
输出结果:
10
结论：数据可以从高精度转到低精度
例3
public class Hello
{
public static void main(String args[])
{
float a = 3.4;
}
}
报错：
D:myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:6: 错误: 不兼容的类型: 从double转换到float可能会有损失
float a = 3.4;
^
1 个错误
因为在java中，小数的默认类型是double
float a = 3.4;
表示我要把一个double类型交给float类型，损失精度，报错
例4
public class Hello
{
public static void main(String args[])
{
float a = 3.4f; //加上f就明确表示用float类型,就可以通过编译了
}
}
将高精度强制转换为低精度
例5
public class Hello
{
public static void main(String args[])
{
float a = 3.4f;
int b = (int)a;
int c = (int)1.9;
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
输出结果：
D:myJavaDemo>java Hello
3.4
3
1
可以看出(int)1.9的结果为1，强制转换会直接省略掉后面的
例6
public class Hello
{
public static void main(String args[])
{
float a = 3.4f;
int b = a;
System.out.println(a);
System.out.println(b);
}
}
报错：
D:myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:7: 错误: 不兼容的类型: 从float转换到int可能会有损失
int b = a;
^
1 个错误
只要造成精度损失就会报错
例7
public class Hello
{
public static void main(String args[])
{
float a = 3;
int b = a + 3.4;
System.out.println(a);
System.out.println(b);
}
}
报错：
D:myJavaDemo>javac -encoding UTF-8 Hello.java
Hello.java:7: 错误: 不兼容的类型: 从double转换到int可能会有损失
int b = a + 3.4;
^
1 个错误
a + 3.4的结果会自动往高精度转换，就造成了a+3.4的结果是个double类型的，而b是个int类型，损失精度报错
注： 1 + 3.4f + 6.2的结果是double类型的