javase-javabase-210126-01
- Java关键字 基本类型 引用类型
- 进制 浮点数拓展 编码 转义字符
- 类型转换 JDK7新特性
- 变量 运算符 包机制
Java关键字
01 | 02 | 03 | 04 | 05 |
---|---|---|---|---|
abstract | assert | boolean | break | byte |
case | catch | char | class | const |
continue | default | do | double | else |
enum | extends | final | finally | float |
for | goto | if | implements | import |
instanceof | int | interface | long | native |
new | package | private | protected | public |
return | strictfp | short | static | super |
switch | synchronized | this | throw | throws |
transient | try | void | volatile | while |
Java中只能以大小字母,$(美元符),_(下划线)开头的任意字符组合
基本类型
整数类型:
byte 占1个字节 -128~127
short 占2个字节 -32768~32767
int 占4个字节 -2147483648~2147483647
long 占8个字节 (long num=10086L【需要加一个L】)
浮点类型:
float 占4个字节 (float num=100.86F【需要加一个F】)
fouble 占8个字节
Boolean类型:
占1位,true/false
引用类型
类,接口,数组…
进制
二进制 0b开头
十进制
八进制 0开头
十六进制 0x开头 09,AF(10~16)
浮点数拓展
float 它是有限的,离散的,舍入误差,大约的(接近但不等于)
少用浮点数比较,最好完全使用浮点数进行比较(比如银行业务【钱】)
使用数学工具类:BigDecimal
float f=0.1f;
double d=1.0/10;
System.out.prinltn(f==d);//false
float num1=555555555555555555;
float num2=num+1;
System.out.println(num1==num2);//true
编码
所有字符的本质还是数字
编码:Unicode 2个字节 0-65536
Unicode编码:U0000 UFFFF
表:a=97 A=65
char c=’\u0061’;//a 【\u是转义】
char c='\u0061';
System.out.println(c);//a
char c1='a';
char c2='A';
System.out.println((int)c1+"\n"+(int)c2);//97,65
转义字符
制表符 \t
换行 \n
类型转换
低---------------------------------------------------->高
byte,short,char—>int—>long—>float—>double
- 不能对布尔值进行转换
- 不能把对象类型转换为不相干的类型
- 在把高容量转换到低容量时,强制转换
- 转换的时候可能存在内存溢出,或者精度问题
int money=10_0000_0000;
int month=12;
int total1=money*month;
long total2=money*month;
System.out.println(total1);//-884901888,,精度溢出
System.out.println(total2);//-884901888,,转换之前已经有问题
long total3=money*((long)month);//先把一个数转换为long
System.out.println(total3);//12000000000
JDK7新特性
数字之间可以用下划线分割
int num=10_0000_0000;//1000000000
变量
- 局部变量
- 不许声明初始化
- 实例变量
- 从属于对象
- 如果不初始化,会是默认值,除了基本类型,其余的默认值都是null
- 布尔类型的默认值是false
- 类变量
- static修饰的变量
public class Variate {
//类变量 static修饰的
static double height=175;
//实例变量
String name;
int age;
public static void main(String[] args) {
//局部变量
int num=22;
//实例变量,,,必须new
Variate variate=new Variate();
System.out.println(variate.name);
//类变量 static
System.out.println(height);
}
}
运算符
- 算数运算符 +,-,*,/,%,++,–
- 赋值运算符 =
- 关系运算符 >,<,>=,<=,==,!=instanceof
- 逻辑运算符 &&,||,!
- 位运算符 &,|,^,~,>>,<<,>>>
- 条件运算符 ?:(x?Y:Z 如果x==true,结果为Y,否则为Z)
- 扩展赋值运算符 +=,-=,*=,/=
优先级:
long n1=1000;
int n2=100;
short n3=10;
byte n4=1;
System.out.println(n1+n2+n3+n4);//Long
System.out.println(n2+n3+n4);//int
System.out.println(n3+n4);//int
/*
如果有long/double类型的相加,结果会是long/double类型
如果没有,结果将会是int类型
*/
int a=3;
int b=a++; //执行完这行代码,先给b赋值,再自增
System.out.println(a);//4
System.out.println(b);//3
int c=++a; //执行完这行代码,先自增,再给c赋值
System.out.println(a);//5
System.out.println(b);//3
System.out.println(c);//5
boolean b1=true;
boolean b2=false;
System.out.println("b1 && b2:"+(b1&&b2));//false
//两个变量都为真,结果为true
// 如果前一个为假,则不判断后面(如果b1是假,则不判b2是真假,即不运算b2)
System.out.println("b1 || b2:"+(b1||b2));//
//两个变量其中一个为真,结果为true
System.out.println("!(b1 && b2):"+!(b1&&b2));//true
//如果是真,结果为false;如果是假,结果为true
int b3=5;
boolean d=(b3<3)&&(b3++<10);
System.out.println(d);//false
System.out.println(b3);//5 没有运算b3++
/*
A=0011 1100//(二进制)
B=0000 1101//(二进制)
------------------------------------------------------
A&B 0000 1100 按位计算,都是1,1才是1;否则为0
A|B 0011 1101 按位计算,至少有一个1比较,才是;否则为0
A^B 0011 0001 按位计算,位置相同为0,不同为1
~B 1111 0010 按位计算,相反
2*8=16 2*2*2*2
(效率很高,直接跟底层打交道)
<< *2
>> /2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 0101 5
0000 0110 6
0000 0111 7
0000 1000 8
0000 1001 9
0000 1010 10
0001 0000 16
*/
System.out.println(2<<3);//16
包机制
- 包语句的语法
- package pkg1[.pkg2 [. pkg3…]];
- 导包
0000 0101 5
0000 0110 6
0000 0111 7
0000 1000 8
0000 1001 9
0000 1010 10
0001 0000 16
*/
System.out.println(2<<3);//16
#### 包机制
1. 包语句的语法
- package pkg1[.pkg2 [. pkg3...]];
2. 导包
- import package1[.package [. package...]].(classname|*);