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+"
");
}*/
/*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]);
}
}
};