java第二节 基本数据类型

class Lesson2
{
	public static void main(String[] args)
	{
		 //-----------------------------------
		 //@Date: 2013-06-30

		 //System.out.println("hello world");
		 //System.out.println("你好java"); 

		 //java中的常量
		 //整型常量

		 //常量的数据类型

		 //常量的概念与作用
         //int x=0, y;
		 //int x, y; //必须先初始化变量才能对变量进行操作
		 //y = x+3;
		 //System.out.println("合值为:"+y);

		 /*
		 数据类型
		        ---基本数据类型
				          ----数值型
						       -----整型类型(byte,short,int,long)
							   -----浮点类型(float,double)
                          -----字符型(char)
						  -----布尔型(boolean)

                ----引用数据类型
				          -----类(class)
						  -----接口(interface)
						  -----数组
         */

		 //char ch = 'x'; //字符
		 //System.out.println(ch);

		 //类型转化
		 //自动类型转换
		 //

		 //byte b = 129; //byte类型的最大值是127

		 //float f=3.5;报错
		 //原因为我们直接在程序中使用了3.5,因为3.5是一个double类型的浮点数
		 //double在内存中是站8个字节，但float 只站四个字节
		 //float f = 3.5f;
		 //System.out.println(f);

		 //byte b = 122;
		 //int x = b;
		 //System.out.println(x); //自动类型转换(也叫陷式类型转换)

		 //byte b = 122;
		 //int x = 266;
		 //b = x;  失败
		 //b = (byte)x; //强制类型转换(也叫显示类型转换)
		 //System.out.println("x:"+b); //数据位数的丢失 打印为10
		 //类型转换的原理，及什么时候要用强制类型转换

		 //被赋值的类型的字节大于当前赋值的字节的变量，可以用隐示转换
		 //被赋值的类型的字节小于当前赋值的字节的变量，可用显示转换

		 //表达式的数据类型自动提升
		 //所有的byte型，short型和char的值将被提升为int类型
		 //如果一个操作类型是long型，计算结果就是Long型
		 //如果一个操作类型是float型，计算结果就是float型
		 //如果一个操作类型是double型，计算结果就是double型

         //System.out.println('a'+1);    //这个是一个字符加1
		 //这里直接把字符转换为十进制的整数，然后加1
		 //System.out.println(""+'a'+1); //这里是一个空字符串加一个字符a然后加1
		 //这里是将a与空字符串进行相加，然后得出字符串，字符串加1，进行字符相加操作
		 //区别暂时不知道

		 //byte b = 3;
		 //b = b - 1; //这里的1为int类型，所以byte减去int类型提示错误
		 //上面这种自我想法是错误

		 //b转换为一个int类型，然后去减1， 为一个int类型的2.
		 //所以不能将一个int类型的值赋值给byte值
		 //int bb = b -1;
		 //System.out.println(bb);

		 //System.out.println('a'+1); //a会被提升为整数类型，然后进行相加

		 //System.out.println(""+'a'+1);//表达式中如果有字符串与其它数值相加，
		 //其实就是与其它变量进行相连

		//复合语句，也就是变量的生存周期
		/*{
		 int x = 3;
		 System.out.println(x);
		}
		System.out.println(x);*/

		//这是在C语言中可以这样使用
		//但在java中不允许这样使用
		/*int x = 9;
		{
			 int x = 3;
			 System.out.println(x);
		}
		System.out.println(x);*/
		//变量的生存周期与作用域
		//变量要先定义，后使用，但也不是在变量定义后的语句一直都能使用
		//前面定义的变量，我们可以用大括号将多个语句包起来形成一个复合语句，变量只能在定义它的复合语句中使用
        /*int x = 9;
		{
			 System.out.println(x);
		}*/
		//函数
		//函数(子程序)的概念与作用
		//定义一个函数的格式
		//编写打印三个矩形的程序
		//如果理解函数返回类型为void的情况
		//void表示无返回值

		/*for(int i=0; i<10; i++)
		{
		    System.out.println(i+"\r\n");
		}*/
		/*for(int i=0; i<3; i++)
		{
		     for(int j=0; j<5; j++)
			 {
			     System.out.print('*');
			 }
			 System.out.println();
		}

		for(int i=0; i<2; i++)
		{
		     for(int j=0; j<3; j++)
			 {
			     System.out.print('*');
			 }
			 System.out.println();
		}

		for(int i=0; i<6; i++)
		{
		     for(int j=0; j<10; j++)
			 {
			     System.out.print('*');
			 }
			 System.out.println();
		}*/

		//MyPrint(3,5);
		//MyPrint(4,3);
		//MyPrint(10,10);
		//System.out.println("3*5="+getArea(3,5));

		//调数的调用
		//函数调用的格式
		//在函数中使用return提前返回
		//函数调用的过程分析

		//函数重载
		//函数的重载就是在同一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或类型不同即可

		/*int isum =0;
		double fsum;

		isum = add(5,5);
		System.out.println("isum:"+isum);

		isum = add(5,5,5);
        System.out.println("isum:"+isum);

		fsum = add(3.2, 5.2);
        System.out.println("fsum:"+fsum);*/

		/*System.out.println(Float.intBitsToFloat(0x7f800000));//正则无穷大

		System.out.println(Float.intBitsToFloat(0x7f800001));//比正则无穷大还要大的值，就不是数字了

        //浮点数表示的最大值
		System.out.println(Float.intBitsToFloat(0x7f7fffff));

		//浮点数表示的最小值
        System.out.println(Float.intBitsToFloat(0x00000001));*/

		//数组
		//1 为什么时会有数组?
		//2 堆内存和栈内存
		//3 int[] x; x= new int[100]的内存状态变化情况

	}

	public static int add(int x, int y)
	{
	      return x+y;
	}

	public static int add(int x, int y, int z)
	{
	      return x+y+z;
	}

	public static double add(double x, double y)
	{
	      return x + y;
	}

    public static int getArea(int x, int y)
	{
	     return x * y;
	}

	public static void MyPrint(int h, int w)
	{
	     for(int i=0; i<h; i++)
		 {
		      for(int j=0; j<w; j++)
			  {
			      System.out.print('*');
			  }
			  System.out.println();
			  //return;
		 }
	}
}

　　

class Lesson21
{

	public static void main(String[] args)
	{
	     //int x = 5, y;
		 //y = x/ 2;
		 //System.out.println(y);

		 //float f = z / 2;
		 //System.out.println(f); //2.0

		 //float f = (float)x / 2;
		 //System.out.println(f); //2.5

		 //int x = 5, y;
		 //y = -x % 2;
		 //System.out.println(y); //-1

		 //y = x % 2;
		 //System.out.println(y);//取幕运算时，当取幕为负数时，负号可以不计

		 //int x = 10;
		 //int y = (x+5)/6; //这里加五也是正确的，因为只要有一个就是一页，
		 //int y = (x+5)/6;//还真得用这个办法，不然想不到办法
         //System.out.println(y);

		 /*int x = 30;
		 int y = (x%6) >=1 ? 1 : 0;
		 int n = (x/6) + y;
		 System.out.println(n);*/

		 /*for(int x=0; x<=9; x++)
		 {
		      System.out.println(x);
		 }*/

		 //int i = 3 % 1;//0
		 //int j = 9 % 4;//1
		 //System.out.println("i:"+i);
		 //System.out.println("j:"+j);

         /*int x = 0;
		 while(true)
		 {
		      x = (x+1) % 10;
			  System.out.println("x:"+x);
		 }*/

		 //赋值运算符
		 // =
		 // +=
		 // -=
		 // *=
		 // /=
		 // %=

		 //int x = 6;
		 //x += 5;
		 //System.out.println("x:"+x);

		 //比较运算符
		 /*
		 运算符
		 ==
		 !=
		 <
		 <=
		 >
		 >=
		 instanceof 检查是否是类的对象

		 逻辑运算符

		 &   AND (与)
		 !   OR  (或)
		 ^   XOR (异或)  如果两个表达式的如果都为false 或者都为true,那么结果为false ,如果一个为false一个为true,那么为true
		 !   NOT (非)
		 &&  AND (短路)
		 ||  OR  (短路)

		 //注1: 逻辑运算符用于对boolean 型结果的表达式进行运算,运算的结果都是boolean型
		 //注2: "&"与"&&"的区别在于，如果使用前者连接，那么无论任何情况，"&"两边的表达式都会参与计算
		 //如果使用后者连接，当"&&"的左边为false,则将不会计算其右边的表达式，"|"与"||"的区别与"&"和"&&"的区别一样
		 */

		 /*int x=1, y=10;
		 if(x <=1 & y>=10)
		 {
		     System.out.println("x <=1 & y>=10");
		 }
		 if(x <=1 && y>=10)
		 {
		     System.out.println("x <=1 && y>=10");
		 }
		 if( x<=1 ^ y>=15)
		 {
		     System.out.println("x<=1 ^ y>=15");
		 }*/

		 /*
		 位运算符
		 任何信息在计算机中都是以二进制的形式保存的，& ｜ 除了可以作为逻辑运算符，也可以做为位算符
		 它们对两个操作数中的每一个二进制位都进行位运算
		  1 只有参加运算的两位都为1,&运算的结果才为1,否则就为0
		  2 只有参加运算的两位都为0,|运算的结果才为0,否则就为1
		  3 只有参加运算的两位不同，^运算的结果为1，否则就为0

		  我们可以对数据按二进制位进行移动操作，java的移位运算符有三种
		  1 << 左移
		  2 >> 右移
		  3 >>> 无符号右移
		 */
		 //int x = 0x80000000;
		 //int y = x >>1;
		 //System.out.println("0x80000000="+Integer.toHexString(y));
		 //y = x >>>1;
		 //System.out.println("0x80000000="+Integer.toHexString(y));

		 /*
		 移位运算的注意事项及小技巧
		 1 移位运算符适用数据类型为byte, short, char, int, long.
         2 对低对int型的操作数将先自动转换为int型再移位
		 3 对于int型整数移位a>>b, 系统先将b对32取模，取到的结果才是真正移位的位数，例如
		   a>>33和a>>1结果是一样的，a>>32的结果还是a原来的数字
         4 对于long型整数移位时a>>b,则是先将移位位数b对64取模
		 5 移位不会改变变量本身的值，如a>>1, 在一行语句中单独存在，毫无意义
		 6 x>>1 的结果和x/2的结果是一样的，x<<2和x*4的结果也是一样的，总之，一个数左移n位，就是等于这个数乖以2的n次方
		   一个数右移n位，就是等于这个数除以2的n次方，
		   请思考:如何用程序实现求2的X次方，答案: y = 1 << x;

		 */
		 /*int x = 10;
		 int y = x >> 2; //10 / 4
		 System.out.println("y:"+y); //2

		 int yy = x << 2;//10 * 4
		 System.out.println("yy:"+yy); //40
		 //00000010
		 //00001000*/

		 //运算符的优先级

		 //程序的流程控制
		 //顺序结构
		 //选择结构
		 //if 语句的选择结构

		 //循环结构
		 //顾名思义，顺序结构就是程序从上到下一行一行执行的结构，中间没有判断和跳转，直到程序结束
	}
};

　　

class Lesson22
{
     public static void main(String [] args)
	 {
	     /*int x = 2;
		 if(x < 3)
		 {
		     System.out.println("x小于3");
		 }else{
		     System.out.println("x大于3");
		 }*/

		 /*
		 switch语句的选择结构
		 Switch(表达式)
		 {
		     case 常量表达式1:语句1;
			 case 常量表达式2:语句2;
			 default: 语句n;
		 }
		 1 default语句是可选的，它接受除上面接受值的其他值，通俗的讲，就是准也不要都给他
         2 case后面可以跟多个语句，这些语句可以不用大括号括起来
		 3 switch语句判断条件可以接受int,byte,char,short型，不可以接受其他类型
		 4 一旦碰到第一次case，就会开始顺序执行以后所有的程序代码，而不穦后面的case条件是否，
		   后面的case条件下的代码都会被执行，直到碰到break语句为止，我们可以利用这个特点来用同一段语句处理多个case条件
		 */

		 //while循环语句
		 //do-while循环语句
		 /*int x = 1;
		 do
		 {
			 System.out.println("x:"+x);
			 x++;
		 }
		 while (x <=10);*/

		 //int x=0;

		 /*try{
		    x = System.in.read();
		 }catch(Exception e){}

		 while(x!='q')
		 {
             System.out.println((char)x);
			 try{
				x = System.in.read();
			 }catch(Exception e){}
		 }*/

		 /*do
		 {
			 System.out.println("请输入值:");
			 try{
			     x = System.in.read();
			 }catch(Exception e){}
			 System.out.println("输入的值为:"+(char)x);
		 }
		 while ((char)x !='q');*/

		 //for循环语句
		 //break与continue语句

		 //变量的字节大小及有效取值范围

	 }
};

　　

class Lesson23
{
		//数组
		//1 为什么时会有数组?
		//2 堆内存和栈内存
		//3 int[] x; x= new int[100]的内存状态变化情况
		public static void main(String[] args)
		{
		    /*int x[] = new int[100];
			int sum=0;
			for(int i=1; i<=100; i++)
			{
			     x[i-1] = i;
				 sum += x[i-1];
			}
			System.out.println("sum:"+sum);*/

			//栈内存，只有在此函数运行时存在此函数中定义的变量，某个函数在栈空间

			//堆内存 

			//数组
			//静态数组
			//int ia[] = {1,2,3,4};

			//int [] ib = new int[]{3,4,5};

			//int a[5] //声明数组时，不能指定其长度，编译时将出错

			//使用数组时要注意的问题
			//空指针导常
			//如何得到数组长度
			//数组越界异常

			//多维数组
			  //如何理解多维数组，类似我们的棋盘
			  //java中并没有真正的多维数组，只有数组的数组，java中多维数组不一定是规则的矩阵形式
			  //定义一个数组

			  /*int[][] xx;
			  xx = new int[3][];
			  x[0] = new int[3];
			  x[1] = new int[2];
			  x[2] = new int[1];*/

			  //多维数组中元素的引用方式，如x[1][2]
			  //规则矩阵数组可以在一条语句中产生，如: int xx[][] = new int[2][3];
			  //多维数组的静态初始化，如 int xx[][]={{3,3,4},{1,2},{1}};

			  /*int xx[][] = {{1,2,3},{1,2},{2}};
			  for(int i=0; i<xx.length; i++)
			  {
			      for(int j=0; j<xx[i].length; j++)
				  {
				     System.out.println("xx["+i+"]["+j+"]:"+xx[i][j]);
				  }
			  }*/

			  //与数组操作相关的函数
			  //使用System.arraycopy()函数拷贝数组
			  //用Arrays.sort来排序数组

			  //int [] ia = {3,2,5,6};

			  int[] x;
			  x = new int[]{3,2,5,6};

			  /*java.util.Arrays.sort(ia);
			  for(int i=0; i<ia.length; i++)
			  {
			      System.out.println("ia["+i+"]:"+ia[i]);
			  }*/

			  int [] tia = new int[10];
			  System.arraycopy(x,0,tia,0,2);
			  for(int i=0; i<tia.length; i++)
			  {
			      System.out.println("tia["+i+"]:"+tia[i]);
			  }
		}
};