1 Java的数据类型
l 基本类型（8种）
l 引用类型
2 八种基本类型
| byte |
1 |
-128到127，-27到27-1 |
|
| short |
2 |
-215到215-1 |
|
| int |
4 |
-231到231-1 |
|
| long |
8 |
-263到263-1 |
|
| float |
4 |
单精度 |
IEEE 754规范 美国电子电气工程师协会浮点数表示规范 |
| double |
8 |
双精度 |
|
| char |
2 |
0到65535 0到216-1 |
|
| boolean |
1 |
真 true 00000001 假 false 00000000 |
|
2.1 计算机的存储单位
l bit - 比特，电位
l byte - 字节，8bit
l Kb - 1024 byte
l Mb - 1024 Kb
l Gb - 1024 Mb
l Tb - 1024 Gb
l Pb - 1024 Tb
2.2 二进制
l byte
10000000 -128
...
11111100 -4
11111101 -3
11111110 -2
11111111 -1
00000000 0
00000001 1
00000010 2
00000011 3
00000100 4
00000101 5
00000110 6
00000111 7
00001000 8
...
01111111 127
| 84608 8*104 4*103 6*102 8*100 |
11011 24 23 21 20 |
| 853 8530 85300 |
110 1100 11000 |
|
|
674 除2取余法
674 /2 337 余0 337 /2 168 余1 168 /2 84 余0 84 /2 42 余0 42 /2 21 余0 21 /2 10 余1 10 /2 5 余0 5 /2 2 余1 2 /2 1 余0 1 /2 0 余1 |
|
|
1 1 10 2 100 4 1000 8 10000 16 100000 32 1000000 64 10000000 128 100000000 256 1000000000 512 10000000000 1024
|
|
|
1000个苹果，分装机箱， 不管客户要多少苹果，都可以整箱交付
|
变量交换
//项目：变量交换
package ;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//提示输入
System.out.print("输入整数a：");
//获得输入的值，保存到变量a
int a = new Scanner(System.in).nextInt();
System.out.print("输入整数b：");
int b = new Scanner(System.in).nextInt();
//变量交换，三步转圈赋值
int c = a;
a = b;
b = c;
System.out.println("a = "+a);
System.out.println("b = "+b);
}
}
自由落体距离
//项目：自由落体距离
package ;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("输入降落时间（秒）：");
//获得输入的值，保存到变量t
double t =
new Scanner(System.in).nextDouble();
//调用f()方法
//把时间t的值，传递到f()方法计算
//得到f()方法的计算结果，保存到变量d
double d = f(t);
System.out.println(t+" 秒降落了 "+d+" 米");
}
static double f(double t) {
double d = 0.5*9.8*t*t;
return d;//把计算结果返回到上面调用位置
}
}
2.3 char类型（2字节）
l 字符、字符的整数编码
Unicode编码表
| 0 |
nil |
| 1 |
? |
| 2 |
? |
| 3 |
? |
| ... |
|
| 97 |
a |
| 98 |
b |
| ... |
|
| 20013 |
中 |
| ... |
|
| 65535 |
|
l char c1 = 97
char c2 = 'a'
2.4 基本类型的字面值（5条规则）
1. 整数字面值是int类型
int a = 56456;
//右侧字面值是int类型，但超出int范围
long a = 9999999999;
2. byte,short,char三种比int小的整数，可以用范围内的值，直接赋值
//右侧是byte，不是int
byte a = 127;
//右侧是int
byte a = 128;
3. 浮点数字面值是double类型
double a = 3.14;
//右侧是double，不是float
float a = 3.14;
4. 字面值后缀
L - long
long a = 9999999999L;
F - float
float a = 3.14f;
D - double
double a = 3.0;
double a = 3d;
5. 进制前缀
16进制：
两个16进制字符，可以表示一个字节
8进制：
1个8进制字符，可以表示3位
0x - 16进制
0xff 255
0 - 8进制
0377 255
\u - char类型16进制
必须表示char类型完整的两个字节值
'a' '\u0061'
'中' '\u4e2d'
2.5 基本类型的运算规则（5条规则）
1. 计算结果的数据类型，与最大的类型一致
3/2 得1
3d/2 得1.5
2. byte,short,char比int小的整数，运算时，会自动转成int
byte a = 3;
byte b = 4;
//错，右侧是int+int，结果是int
byte c = a+b;
3. 整数运算溢出
Integer.MAX_VALUE+1
得负数最小值
300000000*60*60*24*365
300000000L*60*60*24*365
01111111111111111111111111111111 +1
10000000000000000000000000000000
4. 浮点数运算不精确
2-1.9
得 0.10000000000000009
4.35*100
得 434.9999999999999999994
Java中有精确运算方法，后面会讲
5. 浮点数的特殊值
n Infinity（无穷大）
3.14/0
Double.MAX_VALUE*2
n NaN（Not a Number）
Math.sqrt(-3)
2.6 基本类型的类型转换
l 小的类型转成大的类型
byte a = 127;
int b = a;
01111111
00000000 00000000 00000000 01111111
byte a = -1;
int b = a;
11111111
11111111 11111111 11111111 11111111
l 大的类型转成小的类型
n 必须强制转型
int a = 356;
byte b = (byte) a;
00000000 00000000 00000001 01100100
01100100
牛郎织女
两颗星相距16.4光年
光速 299792458 米/秒
喜鹊身长 0.46 米
牛郎织女相会，需要多少只喜鹊
//项目：牛郎织女
package ;
public class Test1 {
public static void main(String[] args) {
System.out.println("两颗星相距16.4光年");
System.out.println("光速 299792458 米/秒");
System.out.println("喜鹊身长 0.46 米");
System.out.println("牛郎织女相会，需要多少只喜鹊");
//1光年是多少米
long ly = 299792458L*60*60*24*365;
//16.4光年是多少米
double d = ly*16.4;
//求喜鹊数量
double r = d/0.46;
//向上取整
//Math.ceil(r)
//取整结果是 double 类型 6436345.0
long n = (long) Math.ceil(r);
System.out.println(n);
}
}
3 运算符
| +-*/ |
|
| + |
数学运算 字符串的连接运算 |
| % |
取余、求模 判断变量a能否被4整除， a%4余数是0 |
| == != |
相等 不相等 |
| > >= < <= |
大小比较 |
| && |
逻辑与 左边是真，并且右边是真，结果是真 短路与，左边是假，右边忽略不执行 |
| || |
逻辑或 左边是真，或者右边是真，结果都是真 短路或，左边是真，右边忽略不执行 |
| ! |
非 非真是假，非假是真 对布尔值做相反判断 判断“非a”是真，即a是假 if(!a) {
} |
| & |
位与 两位都是1结果是1 |
| | |
位或 有一位是1，结果就是1 |
| ^ |
异或 不同是1 对同一个值异或两次，得到原值 |
| ~ |
求反 1变0,0变1 |
| >> |
带符号向右移位 符号位是0，左边补0 符号位是1，左边补1 |
| >>> |
不带符号向右移位 不管符号位是0还是1，左边都补0 |
| << |
向左移位 |
| ++ -- |
自增1、自减1
int a=5 print(a++)先取值后自增
1) 先取出a的原值等待打印 2) a自增变成6 3) 打印原值5
int a=5 print(++a)先自增后取值
1) a自增变成6 2) 取出a的新值等待打印 3) 打印a的新值6 |
| ? : |
三项运算 1 ? 2 : 3
1是真，取2的值 1是假，取3的值 |
| = |
赋值 |
| += ^= >>= ... |
复合的赋值运算 a += 2; //a = a+2;
自动转型 byte a = 2; a = (byte) (a+2); a += 2; a += 3.94; |
| () |
转型运算 |
l 向右移1位相当于除2
l 向左移1位相当于乘2
3.1 运算符优先级
l 不用记优先级表，多加小括号
(1+(2-3))*4/5
平年闰年
输入年号，显示是平年还是闰年
闰年条件：
*) 能被4整除，并且不能被100整除
*) 能被400整除
2000
1000
2016
2018
//平年闰年
package ;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.print("输入年号：");
int y = new Scanner(System.in).nextInt();
//调用runNian()方法
//对年号 y 的值判断是否闰年
//该方法返回 boolean 值
if(runNian(y)) {
System.out.println("闰年");
} else {
System.out.println("平年");
}
}
static boolean runNian(int y) {
boolean run = false;//假设不是闰年
/*if(y%4 == 0) {//能被4整除
//能被4整除的情况下
if(y%100 != 0) {//再判断不能被100整除
run = true;
}
}
if(y%400 == 0) {//能被400整除
run = true;
}*/
if((y%4==0 && y%100 != 0) || y%400==0) {
run = true;
}
return run;
}
}
3.2 位运算
00000000000000000000000001110011
00000000000000000000000001010101 &
----------------------------------
00000000000000000000000001010001
00000000000000000000000001110011
00000000000000000000000001010101 |
----------------------------------
00000000000000000000000001110111
00000000000000000000000001110011
00000000000000000000000001010101 ^
----------------------------------
00000000000000000000000000100110
00000000000000000000000001110011 ~
----------------------------------
11111111111111111111111110001100
00000000000000000000000001110011 >>2
00000000000000000000000000011100
10000000000000000000000001110011 >>2
11100000000000000000000000011100
10000000000000000000000001110011 >>>2
00100000000000000000000000011100
10000000000000000000000001110011 <<2
00000000000000000000000111001100
位运算
10011001 10000100 10111000 11110011
10011001
10000100
10111000
11110011
r
10011001 10000100 10111000 00000000
11111111 11111111 11111111 11110011
//项目：int拆分4字节
package *;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.print("输入整数：");
//获得输入的值，保存到变量n
int n = new Scanner(System.in).nextInt();
/*
* n向右移动24,16,8,0位
* 再强转成 byte类型
* 分别保存到b1,b2,b3,b4变量
* 再打印显示
*/
byte b1 = (byte) (n>>24);
byte b2 = (byte) (n>>16);
byte b3 = (byte) (n>>8);
byte b4 = (byte) (n>>0);
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
//
int r = 0;
/*
* b1,b2,b3,b4
* 左移24位,
* 再不带符号右移0,8,16,24位
* 结果再与r求或，保存到r
*/
//r = r | (b1<<24>>>0);
//r = r | (b2<<24>>>8);
//r = r | (b3<<24>>>16);
//r = r | (b4<<24>>>24);
/*
* b1,b2,b3,b4
* 对0x000000ff求与
* 再左移 24,16,8,0位
* 结果再与r求或，保存到r
*/
r = r | ((b1 & 0x000000ff) << 24);
r = r | ((b2 & 0x000000ff) << 16);
r = r | ((b3 & 0x000000ff) << 8);
r = r | ((b4 & 0x000000ff) << 0);
System.out.println(r);
}
}
三个整数的最大值
项目： day0108_三个数最大值
类： day0108.Test1
package day0108;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("输入三个整数");
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
int c = new Scanner(System.in).nextInt();
//a,b的最大值保存到max
//max,c的最大值保存到max
//int max = a>b ? a : b;
//max = max>c ? max : c;
int max = a>b ? (a>c?a:c) : (b>c?b:c);
System.out.println("最大值："+max);
}
}
