基础系列【三】-- Java基础

关键字

Java语言中的保留字,共有53个,在程序中具有特殊的意义。constant,goto没有

标识符

程序中自定义的字符序列。标识符的组成:字母（字母不止是26个英文字母，所以也可以以中文名命名）,数字,下划线(_),$。

命名规则

以字线，下划线，或 $开头（不能以数字开头），后面可以跟字母，数字，下划线，或$。不允许使用关键字。

命名规范—驼峰命名法

类/接口/枚举:大驼峰
变量/方法:小驼峰
包名:全小写
常量:全大写
名字尽量要具有描述性意义。

Java中的注释:

单行注释://
多行注释:/**/

文档注释:

/**

字面常量

定义：一眼直接就能知道的值的标识符叫做字面常量
整型常量:程序中所使用的所有的整数1024,25
小数常量:程序中所使用的所有的小数 3.14,25.68
字符常量:字符常量是用’’引起来的单个字母，数字，特殊符号 ‘a’,’$’,’+’
字符串常量:字符串常量是使用””引起来的多个字符的序列 “Hello World”,”你好!”
布尔常量: true/false
空常量:nul

进制

二进制:0~1 封二进一 0b10 0B11
十进制:0~9 封十进一 15
十进制转换成二进制过程，使用十进制数不断的对2取余，直到商为0或1时停止除法运算，然后将商和余倒置，得到二进制。
二进制转换成十进制:

从低位开始，每一位乘以2的位次幂，然后求和。

八进制: 0~7 这个8八数字构成 ，封8进一. 010
二进制转换成八进制是三变一的过程
八进制转二进制是一个一变三的过程
十六进制:0~9 A~F十六个数字，封十六进一.0x9+0x1=a 0xF+0x1=0x10
十六进制和二进制之间：二进制转成十六进制是四变一的过程,十六进制是一个一变四的过程。

数据类型

基本类型

bit(位) 是计算机存储数据的时候，所能够存储和处理的最小的单位
8bit=1Byte 1024B=1KB 1024KB=1MB 1024MB=1GB, 1024GB=1TB
100mb=12.5mB

数据类型的转换

隐式转换/自动类型转换
byte b=10;
int i=b;
float f=3.14f;
double d=f;

显式的转转换:当把一个大的类型直接赋给一个小的类型时，或者把一个小数赋值给一个整数的时候需要做显式的转转换。
int i=10;
byte b=(byte)i;
double d=3.14;
float f=(float)d;
float f1=30;
float f2=(float)30.0;
int i=(int)3.99;
注意:在进行强制类型转换时，如果把一个小数赋值给一个整数话，无论小数后的值是多大，只取整数部分，小数部分会直接舍弃。

规律一:当把一个小的类型赋值给一个大的类型的时候会发生类型的自动提升。
int j=10;
float num=j;
long l=1324578L;
double d=l;
规律二:一个整型可以直接赋值给一个非整型，但是如果这个整型值比较大，赋值给非整型后有可能不能保证整数的精度。
char c=’a’;
int m=c;
规律三:char可以直接赋给一个int变量，会发生自动类型转换。

char c=98;
short s=’g’;
s=c;
jvm在进行编译的时候，会检查赋值的类型和声明类型的变量是否一致或或者兼容,否则在处理的时候会发生类型不兼容的错误。

1. 注意点
   byte b = 1;
   b++;
   b+=1;
   b = b>>1;//Type mismatch: cannot convert from int to byte
   b =b+1;//Type mismatch: cannot convert from int to byte
   short s = 1;
   s++;
   s+=1;
   s = s+1;//Type mismatch: cannot convert from int to byte
   char c = 1;
   c++;
   c+=1;
   c = c+1;//Type mismatch: cannot convert from int to byte
2. 类型转换问题：小到大自动转换。大到小强制转换
   1. 规律一:当把一个小的类型赋值给一个大的类型的时候会发生类型的自动提升。
   2. 规律二:一个整型可以直接赋值给一个非整型，但是如果这个整型值比较大，赋值给非整型后有可能不能保证整数的精度。
   3. 规律三:char可以直接赋给一个int变量，会发生自动类型转换。
   char c = ‘啊’;
   c++;
   c+=1;
   c–;
   c-=1;
   short s = ‘爱’;//可以直接用short接收char型数据
   byte b = ‘a’;//只要不超过byte的范围，可以用byte接收char型数据
   b = ‘b’;
   b = ‘爱’;//Type mismatch: cannot convert from char to byte
   s++;
   s+=1;
   //s=s+1;
   int i = ‘爱’;
   //s = (short) (s+c);
   char c=’a’;

引用类型

类、接口/数组

运算符

算数运算符:+ - * / % ++ –

byte b1=10;
byte b2=10;
byte b3=(byte)b1+(byte)b2;
byte b4=(byte)(b1+b2);
byte b5=5+5;
int i=4200;
int k=i/10001000;—4000
double d=i/1000.01000----4200.0
double d1=11.3;
int n=5;
double r=d1/5;
int m=5/0;
注意:
1当byte或short在进行简术运算时会自动转换成int 类型。
2.当算术运算符的两端数据类型一样的时候，其运算结果的类型和参与运算的数据的类型是一致的。
3.在一个算术表达式当中有一个大的类型，则整个表达式的运算结果会发生自动类型的一个提升。将提升为最该表达式当中最高一级的数据类型。
4.小数在转换成二进制数字的时候变成无限循环的小数，即使double类型也无法保证精度，
所以运算结果也无法保证其准确性。
5.整数/0会发生/byezero 的ArithmethicException的运算错误。
小数据/0或非零的数/0.0— 无限大
0/0.0—NaN

%:取模运算(求余数)
int i=5%2;—1
int j=1%3;—1
负数的取模
int k=-8%5;—(-3)
int k1=8%/-5—(3)
int k2=-8%-5—(-3)
在取模运算中如果有负号的话结果看的是被除数。
小数的取模:
3.2%21.2—5.4%1.70.3

++/–
自增/自减运算
int i=5;
//i++;i=i+1;6
++ii=i+16
当++运算符和一具操作数单独使用的时候前置和后置的都是在都是在该操作数据的基础上加1之后再赋给该变量。
Int i=5;
int j=i++j=5i=i+1
j5,i6;
int i=5;
int j=++i
i6 j6。
Int i=3;
int j=i++ + ++i;
i5 j8
int i=3;
int j=++i+i++;
i5 j8
当把自增运算符和一个操作数据放在一个赋值表达式当中时,如果自增运算符后置，则会先使用i的值，再对其进行自增运算。如果自增运算符前置，那么会先自增，再使用。
byte/short类型能够进行自增或自减运算，运算后又转换回本类型。

赋值运行符:= += -= = /= %= ^= &= |= <<= >>= >>>=
int i=10;
复合赋值运算符。
int i=5;
i+=5;i=i+5;
i10;
所有的复合赋值运算符要求变量都要有一个初值。
int i=5;
i+=i-=i=i++;
(5+(5-(5*5)))==-15

关系运算符:>,< ,>=, <=, , !=
int i=5;
int j=6;
i>jfalse
i<jtrue
ijfalse
i!=jtrue

逻辑运算符:&, |, !, ^ ,&&, ||
&(and)当&运算符两端都为真表达式的结果才为真—true&truetrue/true&falsefalse/false&truefalse/false&falsefalse
|(or)当|运算符两端只要有一个为真结果就为真—true|falsetrue/false|truetrue
false|falsefalse
!(非)对操作数进行取反的操作,如果操作数为真，取反后变假，操作数为假，取反后变真。
!truefalse/!falsetrue.
^{(异或)相同为假，不同为真。true}truefalse,false^{false==fasle,true}falsetrue
false^truetrue
&&(短路与)和&(逻辑与)区别是短路与的运算效率相对要高。
短路与是当运算符的左边为假，将不再计算右边的表达式。而逻辑与的无论左边是真还是假都会继续做右边表达式的计算。
||(短路或)和|(逻辑或)区别是短路或比逻辑或的运算效率相对要高。
短路或是当运算符的左边为真，将不再计算右边的的表达式。而逻辑或无论左边是直还是假都会继续做右边表达的计算。

位运算符:&,|,^,<<,>>,>>>,~
位运算符所操作的所有的数都是整数，而且操作的是数据的补码。
数据在内存中如何表式正负形式？是通过符号位来代表正负数，最高位为符号位，如果符号位为0则表示是正数，如果符号位为1则表示是负数。
数据在内存中是以补码的形式存储的。所有的正数的原码，反码和补码是一样的。
6:
原:00000000 00000000 00000000 00000110
反:00000000 00000000 00000000 00000110
补:00000000 00000000 00000000 00000110
-6:
原:10000000 00000000 00000000 00000110
反:11111111 11111111 11111111 11111001
补:11111111 11111111 11111111 11111010
负数的原码是实将该数据转换成二进制数后最高位为1，
反码是除了符号位以外所有的位数据按位取反，1变0,0变1
补码是在反码的基础上最低位加1。
一个数的补码如下，求该数
11111111 11111111 11111111 11111101补码
11111111 11111111 11111111 11111100反码
10000000 00000000 00000000 00000011原码
-3

& 按位与
| 按位或
^ 按位异或

~按位取反：把操作数据转换成二进制数。按位取反，对应位0蛮1，1变0.
~3
00000000 00000000 00000000 00000011
11111111 11111111 11111111 11111100 补码
-4
~i=-i-1

下一篇：
基础系列【四】-- 面向对象