java基础---->数据类型、运算符、程序控制

一、java基础数据类型

基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。对于数值类型的基本类型的取值范围都已经以常量的形式定义在对应的包装类中了。



byte : 1字节有符号整数的补码

short : 2字节有符号整数的补码

int : 4字节有符号整数的补码

long : 8字节有符号整数的补码

float : 4字节单精度浮点数

double: 8字节双精度浮点数

char : 2字节无符号Unicode字符

2 简单数据类型之间的转换

这些类型由低级到高级分别为 （byte，short，char)--int--long--float--double简单数据类型之间的转换又可以分为：

[align=left]低级变量可以直接转换为高级变量，[/align]

[align=left] 高级变量转换为低级变量时，使用强制类型转换。[/align]

数值型

public class PrimitiveTypeTest {
public static void main(String[] args) {
// byte
System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
System.out.println("包装类：java.lang.Byte");
System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();

// short
System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
System.out.println("包装类：java.lang.Short");
System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();

// int
System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
System.out.println("包装类：java.lang.Integer");
System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();

// long
System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
System.out.println("包装类：java.lang.Long");
System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();

// float
System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
System.out.println("包装类：java.lang.Float");
System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();

// double
System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
System.out.println("包装类：java.lang.Double");
System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();

// char
System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
System.out.println("包装类：java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值：Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值：Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);
}
}

结果如下：

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少倍。Java中的e代表10的幂次。而Math.E代表自然对数2.718281828459045

System.out.println("自然对数："+Math.E);          //自然对数：2.718281828459045
System.out.println("表达式中e代表10幂次 "+ 1.2e+2);//表达式中e代表10幂次 120.0

给单精度的变量赋以带小数的初值时必须在数值后面加F或f

给长整形变量赋以超出int类型数值范围（-2147483648~2147483647）以外的数时，必须在之后加大写或者小写的L。

boolean型（布尔型）这个类型只有两个值，true和false（真和非真）

char型（文本型）用于存放字符的数据类型，占用2个字节，采用unicode编码，它的前128字节编码与ASCII兼容，字符的存储范围在/u0000~/uFFFF，在定义字符型的数据时候要注意加单引号。

char a1='a';
char a2 = '\u0061';
System.out.println(a1);  //a
System.out.println(a2);  //a
System.out.println('a'+0);//97

基本类型存储在栈中，对应的包装类的实例对象存储于堆中，因此基本类型的存取速度要快于存储在堆中的对应包装类的实例对象。

装箱：将一个基本数据类型变为包装类称为装箱操作，装箱的方法由各个子类完成

拆箱：将一个包装类变回基本数据类型，称为拆箱操作，转换的方法由Number类提供。

public class WrapperDemo {

public static void main(String args[]){

int x1 = 10 ;        // 基本数据类型

Integer temp = new Integer(x1) ;    // 装箱

int x2 = temp.intValue() ;      // 拆箱

System.out.println(x2 * x2) ;

}

};

从Java5.0（1.5）开始，JAVA虚拟机（Java Virtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

二、标识符及关键字

标识符：由字母、数字、下划线、美元符号($)组成，区分大小写，其中不能以数字开头，不能是Java中的关键字。

关键字

访问控制	private	protected	public
类,方法和变量修饰符	abstract	class	extends	final	implements	interface	native	new	static
strictfp	synchronized	transient	volatile
程序控制	break	continue	return	do	while	if	else	for	instanceof
switch	case	default
错误处理	try	Catch	throw	throws
包相关	import	package
基本类型	boolean	byte	char	double	float	int	long	short	null
true	false
变量引用	super	this	void
保留字	goto	const

goto和constant没有任何意义

assert：断言

native：声明本地方法，native方法是由另外一种语言（如c/c++，FORTRAN，汇编）实现的本地方法

volatile ：volatile修饰变量。在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

strictfp, 即strict float point (精确浮点)。strictfp关键字可应用于类、接口或方法。使用 strictfp关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。

synchronized同步

transient：如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。 Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。

三、注释

　// 注释一行

　     /* ...... */ 注释若干行

/**……*/文档注释，

四、类型转换

提升：表达式中出现的最大的数据类型决定了表达式最终结果的数据类型。

窄化转换：将容纳更多信息的数据类型转换成无法容纳那么多信息的类型，有可能面临信息丢失的危险。

扩展转换：新类型肯定能容纳原来类型的信息，不会造成任何信息的丢失

float或者double转型为整型值时，总是对该数字进行截尾，如果想得到舍入的结果，需要用Math.round()方法。

五、运算符

Java中提供了以下的运算符：

赋值运算：=

三目运算：布尔表达式 ?条件满足:条不满足

数学运算符：+、-、*、/、%

关系运算符：>、>=、<、<=、==、!=

位运算：>>、<<、>>>、^、~

>> 右移 将二进制向右移动指定位数，右移之后的位数用符号填充。

<< 左移 将二进制向左移动指定为数，左移之后的位数用0填充。

>>> 无符号右移动,右移只有用0填充。

public class BitOperator {

public static void main(String[] args) {

int x=3;
int y=-3;
System.out.println("左移两位"+(x<<2)); //12
System.out.println("右移两位"+(x>>2)); //0
System.out.println("无符号右移两位"+(x>>>2));//0

System.out.println("左移两位"+(y<<2)); //-12
System.out.println("右移两位"+(y>>2)); //-1
System.out.println("无符号右移两位"+(y>>>2)); //1073741823,因为整型是4个字节
//x和~x的和为-1
System.out.println("取反"+(~x));//-4
System.out.println("取反"+(~y));//2
}
}

逻辑运算：&&、||、!,其中&&、||满足短路规则

自增自减运算符：++、--

按位操作符：&（按位与）,|（按位或），^(异或), ~(非 对补码按位取反，0变1,1变0. 若x=-3，则~x=2)

六、数组

声明和分配内存空间一步完成：声明数组时在栈内保存数组的名称，为数组开辟空间是使用new关键字在堆内完成的。

数据类型 数组名称[] = new 数据类型[长度] ;

数据类型 [] 数组名称 = new数据类型[长度] ;

两步完成：

数据类型 数组名称[] = null ;

数组名称 = new 数据类型[数组长度] ;

数组的冒泡排序：

public class ArraySort{
public static void main(String argbs[]){
int data[] = {1,3,4,1,3,54,5,43,3,2,1,5,7,87} ;
for(int x=0;x<data.length;x++){
for(int y=0;y<data.length-1;y++){
if(data[y] < data[y+1]){
int temp = data[y] ;
data[y] = data[y+1] ;
data[y+1] = temp ;
}
}
}
for(int x=0;x<data.length;x++){
System.out.print(data[x] + "、") ;
}
}
};

java.util.Arrays.sort(data);

System.arraycopy(src, srcPos, dest, destPos, length);

可变参数和数组

七、程序控制

if、if…else、switch（case分支条件后面只能是int，char（会自动转换成int） 或者枚举类型）语句，如果想使用string作为分支条件。switch 如果不加break；则执行第一个满足条件之后的所有操作。

public enum Animal {
dog,cat,pig;
static Animal getValue(String  animal)
{
return valueOf(animal.toLowerCase());
}
}

Client.java

public class Client {
public void caseAnimal(String animal) {
switch (Animal.getValue(animal)) {
case dog:
System.out.println("this is a dog");
break;
case pig:
System.out.println("this is a pig ");
break;
case cat:
System.out.println("this is a cat");
break;

default:
System.out.println("i don't know what is this!");
break;
}
}

public static void main(String[] args) {
new Client().caseAnimal("dog");

}
}

for、foreach、while、do…while语句

break:跳出循环，循环嵌套时跳出内层循环。

continue 作用：跳过循环体中剩余的语句而执行下一次循环

reteun：指定一个方法返回什么值，并导致当前方法退出，返回那个值。方法执行了return以后不再继续执行。返回类型为void的方法结尾处有一个隐含的return；

带标签的break和continue

public class LabeledWhile {
public static void main(String[] args) {
int i = 0;
outer:
while(true) {
System.out.println("Outer while loop");
while(true) {
i++;
System.out.println("i = " + i);
if(i == 1) {
System.out.println("continue");
continue;
}
if(i == 3) {
System.out.println("continue outer");
continue outer;
}
if(i == 5) {
System.out.println("break");
break;
}
if(i == 7) {
System.out.println("break outer");
break outer;
}
}
}
}
} /* Output:
Outer while loop
i = 1
continue
i = 2
i = 3
continue outer
Outer while loop
i = 4
i = 5
break
Outer while loop
i = 6
i = 7
break outer
*///:~

99乘法表：

public class Multiply_table {

public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
if (i >= j)
System.out.print(i + "*" + j + "=" + i * j + "\t");
}
System.out.println();
}
}

}