javabase简记 - 第二天

1.变量是一个代词，指代内存中的数据
  变量是可以改变的量---指代不同的数据


2.变量必须先声明，再使用
    语法: 数据类型 变量名;
          int       a;

  可以一条语句声明多个同类型变量
    eg: int a,b,c;
        int a=1,b,c=2;

3.变量的命名:
    规定:
      1)只能包含字母、数字、_、$并且不能以数字开头
      2)严格区分大小写
      3)不能使用关键字(java已经用了的字)
    建议:
      1)不建议中文命名变量
      2)最好"见名知意"
      3)驼峰命名法:第一个单词首字母小写，其余单词首字母大写

4.变量的初始化:
    java语法规定:变量在使用前必须初始化
    初始化两种方式:
      1)声明同时初始化
          int a=5;
      2)先声明再初始化
          int b; 
 b=8;

5.变量的使用:
    1)必须与数据类型匹配
      eg: int a=2.5; //错误，类型不匹配

6.int:
   1)整型，占4个字节，范围-21个多亿到21个多亿
   2)整数直接量(25,250,2500...)，默认为int类型
   3)两个整数相除，结果为整数
     (无条件舍去小数位)
  long:
   1)长整型，占8个字节，范围特别大(足够用)
   2)long型直接量，在数字后面加l或L
      eg: long a = 35L;

小结:
1.变量:
    声明
    命名
    初始化
    使用
2.数据类型:
    int:55
    long:55L
    double:55.0
    char:'a'
    boolean:true和false

    类型间转换

案例测试代码如下：

package base;

/**
 * 演示数据类型
 * 
 * @author Administrator
 * 
 */
public class DataTypeDemo {
	public static void main(String[] args) {

		/**
		 * int 类型的演示
		 */
		System.out.println("#######  int 类型的演示        ########");
		// int:整型，4个字节
		int a = 88; // 88为直接量，java默认int型
		// 100亿写出来就是错的，默认为int，但超了
		// int b = 10000000000;
		int b = 5 / 3;
		System.out.println(b);// 1，小数无条件舍去

		// 溢出是需要避免
		int m = 2147483647;// m为int的最大值
		m = m + 1; // 最大值基础之上加1----溢出
		System.out.println(m);// int的最小值

		// 不记得的时候也可以通过系统设定的常量求出最大值，最小值
		int max_int = Integer.MAX_VALUE;
		int min_int = Integer.MIN_VALUE;
		System.out.println(max_int);
		System.out.println(min_int);

		/**
		 * long 型的演示
		 */
		System.out.println("#######  long 类型的演示        ########");
		// long:长整型，占8个字节

		long long1 = 88L; // 88L为long型直接量
		// long b = 10000000000;//错误，原因同上
		long long2 = 10000000000L;

		// 运算时，以最大类型作为最终类型
		long long3 = 1000 * 1000 * 1000 * 1000 * 2L;
		System.out.println(long3);// 溢出
		long long4 = 2L * 1000 * 1000 * 1000 * 1000;
		System.out.println(long4);// 不溢出

		// 获取自1970.1.1零时到现在的毫秒数
		long time = System.currentTimeMillis();
		System.out.println(time);

		/**
		 * float double 型的演示
		 */
		System.out.println("####### float double 类型的演示        ########");
		// double:浮点型/小数型，占8个字节
		double double1 = 55.6;// 55.6小数直接量，默认double型
		// float b = 55.6;//错误，类型不匹配
		float float1 = 55.6F;

		// double和float都有舍入误差
		// 想解决可以使用BigDecimal
		double double2 = 3.0, d = 2.9;
		System.out.println(double2 - d);// 舍入误差

		// 运算时以最大类型作为最终类型
		int e = 5 / 2;
		double f = 5 / 2;
		double g = 5.0 / 2;
		System.out.println(e); // 2
		System.out.println(f); // 2.0
		System.out.println(g); // 2.5

		double h = 0; // 占8个字节

		/**
		 * char 型的演示
		 */
		System.out.println("####### char 类型的演示        ########");

		// char:字符型，占2个字节
		// 只能存储一个字符
		char c1 = 'A'; // 'A'为字符型直接量
		char c2 = 65; // 65为'A'所对应的码(整数)
		System.out.println(c1);
		System.out.println(c2);

		// char cc='AB';//错误，有且仅有一个
		// char c3='';//编译错误，必须有字符
		// char c4=''';//错误，'为特殊字符
		char c5 = '\'';// 正确，转义字符
		System.out.println(c5);

		// 字符实际上存储的就是一个整数(码)
		// '0'码48，'a'码97，'A'码65
		int int3 = 2 + 2;
		int n = '2' + '2'; // 50+50
		System.out.println(int3); // 4
		System.out.println(n); // 100

		/**
		 * boolean 型的演示
		 */
		System.out.println("####### boolean 类型的演示        ########");
		// boolean:布尔型，存储true或false
		// 占1个字节
		boolean boolean1 = true;
		boolean boolean2 = false;
		// boolean c = 2;//错误，类型不匹配
		
		
		
		/**
		 * 数据类型转换，两种方式:
		 * 1)自动类型转换:小到大
		 * 2)强制类型转换:大到小
		 */
		
		System.out.println("##########   数据类型转换        ###########");
		int xiao = 55;
		long da = xiao;//自动类型转换--小到大
		int xiao2 = (int)da; //强制类型转换--大到小
		//int c = da;//错误，大到小必须强制转
		
		
		long long_da = 10000000000L;
		int xiao3 = (int)long_da;
		System.out.println(xiao3);//强转时溢出
		
		
		double double4 = 3.88888888888888;
		float float3 = (float)double4;
		System.out.println(float3);//强转时精度丢失
		
		byte b1 = 127;
		//byte b1 = 128;//错误，超了byte的范围
		
		
		//java的两点规则:
		//1.整数直接量可以直接赋给byte,char,short
		//2.byte,char,short参与运算时，一律转为int
		short s1=5;
		short s2=6;//规则1
		short s3=(short)(s1+s2);//规则2
		//short s3=s1+s2;//错误，s1+s2为int型
		int s4=s1+s2;
		System.out.println(s4);
			
	}
}

小练习：

/*小练习1：
		 * 1.声明double型变量，存储8.88
		 *   声明float型变量，存储8.88
		 * 2.输出5/2以及5.0/2的结果，看一看
		 * 3.声明两个double型变量，
		 *   分别存储3和2.9
		 *   输出相减的结果
		 * 4.声明char型变量，使用两种方式存储小a
		 *   方式一:字符直接量
		 *   方式二:码(97)
		 * 5.计算2+2以及'2'+'2'的结果，看一看
		 * 6.声明两个boolean型变量，
		 *   分别存储true和false
		 *   
		 */

/*小练习2：
		 * 1.声明int型变量a，存储55
		 *   声明long型变量b，存储a---什么现象?
		 *   声明int型变量c，存储b----什么现象?
		 * 2.声明long型d，存储100个亿
		 *   声明int型e，存储d--------什么现象?
		 * 3.声明double型dou,存储5.55
		 *   声明int型f，存储doub-----什么现象?
		 * 4.如下代码演示:
		 *     byte b1=55,b2=66;
		 *     byte b3=b1+b2;--------?????
		 */

/*小练习3：
		 * 1.声明整型变量a，存储55
		 * 2.声明整型变量b，存储8/3的结果
		 *   输出b的值
		 * 3.声明整型变量c，存储2147483647(最大值)
		 *   重新给c赋值为其本身加1---查看溢出
		 * 4.声明long型变量d，赋值为long型直接量
		 * 5.声明long型变量e，
		 *   存储4个1000相乘的结果--要保证不溢出
		 * 6.声明long型变量f，
		 *   存储自1970.1.1零时到现在的毫秒数
		 */