标签：
day02_变量_基本数据类型_数据类型的转换_Scanner_20150731
回顾：
昨天主要讲了3个方面的内容：
1.Linux
操作系统、开源的、免费
服务器端
目录、挂载点、安全级别高
/:根目录
/home/soft01:主目录/家
2.java开发环境
1).java源文件，经过编译，生成.class字节码文件
JVM加载.class并运行.class
跨平台、一次编程到处使用
2)JVM:java虚拟机
加载并运行.class
JRE:java运行环境
除了包含JVM以外还包含运行java程序所需要的必须的环境
JRE=JVM+java系统类库
JDK:java开发工具包
除了包含JRE以外还包含开发java程序所需要的命令工具
JDK=JRE+开发工具(编译、运行......)
3.eclipse
IBM、开源的、免费
-------------------------------------------------------------------------------------------------------------------------------------------------------
今天主要内容：
1.变量 2.基本数据类型 3.数据类型转换 4.Scanner用法
********** ******************** * ***************** ******************
1.变量:存数据的，代词，指代它所存的那个数
1)声明:
int a; //声明整型变量，名为a
int b,c,d; //声明三个整型变量，名为b,c,d
2)命名:
2.1)只能包含字母、数字、_、$符
并且不能以数字开头
2.2)严格区分大小写
2.3)不能使用关键字
2.4)可以中文命名，但不建议
2.5)建议:见名知意、驼峰命名法
3)初始化:第一次赋值
3.1)声明同时初始化
int a = 250;
3.2)先声明后初始化
int a;
a = 250;
4)使用:
4.1)变量的使用必须与数据类型匹配
int a = 25.678; //编译错误
4.2)变量在用之前必须声明并初始化
System.out.println(a); //编译错误，a未声明
int a;
System.out.println(a); //编译错误，a未初始化
int a = 250;
System.out.println(a); //正确
4.3)对变量的使用就是对它所存的那个数的使用
int a = 5;
a = a + 10; //取出a的值5，加10后，赋值给a
//在a本身基础之上增10
代码小demo：
package day02;
public class VarDemo {
//变量练习
public static void main(String[] args) {
//变量的声明、初始化、赋值
/*
int a; //声明整型变量a
int b,c,d; //声明3个整型变量b，c，d
int e = 250; //声明变量e并赋值250
int f; //声明变量f
f = 250; //给变量f赋值250
//System.out.println(g); //编译错误，未声明变量g
//int g;
//System.out.println(g); //编译出错，变量g未初始化
//int h = 25.67; //编译出错，类型不匹配
int m = 5;
System.out.println(m);
m = m + 10;
System.out.println(m);
*/
/*
int a,_a,$,_,_1,$1; //合法变量名
int _$1a_; //合法变量名
*/
/*
int 年龄; //正确，不建议使用
int age; //建议：见名知意
int myJavaScore; //建议：驼峰命名法
*/
}
}
2.基本数据类型
1)int: 整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认int型，不能超范围
int a = 250; //250默认int型
int b = 10000000000; //编译错误，100亿默认int型，但超范围了
1.2)两个整数相除，结果还是整数，小数位无条件舍弃
System.out.println(5/2); //2
System.out.println(2/5); //0
1.3)整数运算时超范围，会发生溢出，需要避免
2)long:长整型，8个字节，很大很大
2.1)long型直接量在数字后加L或l
long a = 250L;
long b = 10000000000; //编译错误，100亿为int型
----
整数的直接量为int型，100亿超过int型表示的范围，故编译错误
long c = 10000000000L;
2.2)较大数运算时有可能溢出，建议在第一个数后加L
2.3)获取自1970.1.1零时到此时此刻的毫秒数
long a = System.currentTimeMills();
3)double:浮点型，8个字节，很大很大
3.1)浮点型直接量默认为double型
double a = 25.6378; //25.6378默认double型
3.2)舍入误差，精确运算场合不能使用
3.3)小数的直接量为double型，如果float f = 23.4; 则编译错误
4)char:字符型，2个字节
4.1)unicode编码格式，每个字符都有一个对应的码
char是表现形式，实质上是int
4.2)有且仅有一个字符
4.3)字符型直接量需放在一对单引号中
4.4)对于不方便输出的字符，需\来转义
5)boolean:布尔型，1个字节，只能存true和false
3.数据类型的转换:
1)分两种: 从小到大依次为 byte,short,int,long,float,double
char
1.1)自动类型转换(隐式类型转):从小类型到大类型转
1.2)强制类型转换:从大类型到小类型转
(要转换为的数据类型)变量
有可能会溢出或精度的丢失
2)两点规则:
2.1)整数直接量可以直接赋给byte,short,char，但不能超范围
2.2)byte,short,char型变量参与运算时，一律转为int再运算
代码小demo：
package day02;
public class DataTypeDemo {
//练习基本数据类型
public static void main(String[] args) {
int a = 250;
long b = a; //小转大，直接转
//int c = b; //编译错误，不能直接把long类型的数赋值给int型
long d = 10000000000L; //100亿
int e = (int)d;
System.out.println(e); //结果为1410065408，100亿超过int范围，强制转换结果溢出
double f = 25.678;
int g = (int)f;
System.out.println(g); //结果为25，强制把double型转换成int型，可能会损失精度
//整型直接量可以直接赋值给char、byte、short，不能超范围
byte bt1 = 5;
byte bt2 = 6;
//char、byte、short参与运算时，先转换成整型，然后再运算，故运算结果为整型
byte bt3 = (byte)(bt1+bt2);
byte bt4 = 5+6;
System.out.println(bt3);
char c1 = 'a';
char c2 = 'b';
//char c3 = c1+c2; //编译错误，运算时，先把char型的c1和c2转换成int型，然后进行运算
char c3 = 'a'+'b';
System.out.println(c3);
/*
boolean b1 = true;
boolean b2 = false;
System.out.println(b1);
//boolean b3 = 5; //编译错误，boolean的值只能为true或false
char c1 = '男';
char c2 = 'm';
char c3 = 5;
char c4 = ' ';
//char c5 = ''; //编译错误，字符的单引号中必须有且只有一个字符，不能不写
//char c6 = '你好'; //编译错误，字符的单引号中必须有且只有一个字符
//字符的单引号中必须有且只有字符的单引号中必须有且只有一个字符一个字符
char c7 = '\\';
System.out.println(c7); //结果为：
System.out.println(2+2); //4
System.out.println('2'+2); //52
*/
/*
Integer a = 1234;
Integer b = 1234;
System.out.println(a == b);
Integer c = 123;
Integer d = 123;
System.out.println(c == d);
*/
/*
int a = 250;
//int b = 10000000000; //100亿--超过整型的范围-21亿～21亿
System.out.println(5/2); //2
System.out.println(2/5); //0
int c = 2147483647;
c = c + 1;
System.out.println(c); //溢出--结果为-2147483648
long d = 250L;
//long e = 10000000000; //100亿--编译错误，整型的直接量为int型
long f = 10000000000L;
long g = 1000000000*2*10L;
System.out.println(g); //200亿
long h = 1000000000*3*10L;
System.out.println(h); //溢出
long i = 1000000000L*3*10;
System.out.println(i); //300亿
//把L加在第一个数后面，防止溢出
//1970.1.1零时到现在的毫秒数
long j = System.currentTimeMillis();
System.out.println(j);
double k = 2.526;
double m = 3.0;
double n = 2.9;
System.out.println(m - n); //结果：0.10000000000000009
System.out.println(1.0/10); //结果：0.1
System.out.println(1.0/3); //结果：0.3333333333333333
*/
}
}
代码小demo：
package day02;
import java.util.Scanner; //1.
//Scanner演示
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in); //2.
System.out.println("请输入你的年龄:");
int age = scan.nextInt(); //3.
System.out.println("请输入商品的价格:");
double price = scan.nextDouble();
System.out.println(age);
System.out.println(price);
}
}
总结：文中红色标记部分为之前掌握的不好的地方，需要加强记忆与理解，其他内容为Java的基础知识点，仍需时而温习之！！！
版权声明：本文为博主原创文章，未经博主允许不得转载。
day02_变量_基本数据类型_数据类型的转换_Scanner_20150731
标签：
原文地址：http://blog.csdn.net/u011637069/article/details/47177105
