Java语言基础组成.doc

Java语言基础组成
Java基础组成分为8个部分
1，关健字 2，标识符
3，注释 4，常量与变量
5，运算符 6，语句
7，函数 8，数组

一,关键字

关键字就是被Java赋予特殊含义的单词。

要注意的关健点为：
public class 与class声名的区别：1，即如果class前用了public
则保存的文件名称必须与类名称一致。
2，一个*.java的文件中只允许出现一个public class声名，但允许有多个class声名。

2，标识符

标识符需要注意的规范，这个得记住。

3，注释

注释需要注意的关键点，这个习惯要养成。

4，常量与变量

注意的关键点：
1，常量表示不能改变的数值。一开始是什么就是什么，不能再赋予了。
2，变量之间可以进行强制转换。格式：（变量类型）（变量）
字符与字符串别搞错了，一个单引号，一个双引号。

变量的作用范围要记住，一对{}之间。要有初始化值。

变量的数据类型及要注意的关键点：
1一个字节由8位二进制组成。
2整数型：byte为一个字节，short为两个字节，int为四个字节（默认）
3，浮点类型（小数）：float为两个字节，,double为四个字节（默认）。
4，Char字符型是两个字节，汉字是两个字节。
5，如果我们定义一个类型，不是默认类型，那么我们要在后面标明：比如：float x = 5f，不然会提示损失精度。

5，运算符

运算符的种类

注意的关键点：
1，++，--放前放后的两种用法。当其单独使用时无所谓，如++x，x++没有区别。
2，注意一种运算，int x = 4200; x=x/1000*1000=4000,因为两个intt类整数相除，只能为intl类整数
3，取模时%左边数小于后数结果为左，有负数，只看左边.
4，+字符串后面的用+相连，结果都为字符串

转义字符的用法\ 是转后面的字母或含义。
System.out.print(y+"*"+x+"="+x*y+"\t ");//\t:表示制表符。出来的结果会自动对齐。要用+连接制表符。

赋值运算，+=之类的用法不要忘记，注意：左边加右边的值再赋给左边。累加运算时常用到。

注意关键点：
区别是short是占两个字节，整数是4个字节，相加必提升为4个字节相加，所以不强制定义就会提示损失精度但s+=2则会自我转换为short能识别的两个字节类型，只要没有超出short范围。不需要强制转换。

结果只能为boolean型

&与，是有假为假. |或：是有真为真 ^异或 ： 是两边一样为假。&&：只要左边出现假则不再往生运算，||：只要左边出现真，不再往后运算。这个在条件语句常会用到。

位运算是高效的，要注意的关键点：
1，这里也有&，|，^，就是这三个可以当逻辑运算也可当位运算，但全部会转化为二进制进行运算
但是这里没有&&和||,这就是区别！
2，左移时右边空位补零
3，右移时，看左边最高位是零还是一，是零左边空位零，是一补一，无符号移则不管左边最高位是什么都补零。

位运算全部转为二进制真假运算，0为假，1为真
负数的表现型式为正数取反加1 ，如：-x=~x+1
一个数异或任一个数两次，还是那个数（可以用于加密），另一个例子是：n=n^m;m=n^m,n=n^m,这样便实现n 和m值的互换。
所以：位运算的应用举例：两个变量的互换才能实现。
int a = 4,b = 6;
a=a ^ b;
b=a ^ b;
a=a ^ b;
三元运算

三元运算关键点及应用举例：
用来算进制转换，将60转成十六进制是多少？如下：

6，语句

/*
int a = 1;
if(a>2)//如果不打括号那么默认只识别离他最近的一行。
{
System.out.println("if");
}
else
{
System.out.println("else");
}
System.out.println("Hello World!");
*/
/*
if格式可以简写为三元运算：变量 = （条件表达式）？表达示1：表达示2;
if语句其写三元运算区别在于，其可以不用出结果，但是三元运算符，必须出结果。
三元运算符的优点是：代码简单，缺点是：必须要出结果.
*/
//多重判断语句
/*
if()
else if ()
else if ()//可以有很多else if ，但是任意一行满足，则运行中止。整个为一个语，尽快其很长。
......
else
//注意一种形式，如下：
if ()//这行是独立的
{

}
if ()//这个if才是和下面else为一个语句。
{

}
else
*/
/*
需求：根据所属月份，打印对应的季节。
3，4，5春季 6，7，8夏季 9，10，11秋季 12.1.2冬季
步骤：这个程序有三种写法，第二种更简单，但要理解其中的逻辑。第三种则是另一种语句。
*/
//int x = 1;
/*
if (x==3 || x==4|| x==5)
System.out.println(x+"月是"+"春季");
else if (x==6 || x==7|| x==8)
System.out.println("夏季");
else if (x==9 || x==10|| x==11)
System.out.println("秋季");
else if (x==12 || x==1|| x==2)
System.out.println"冬季");
else
System.out.println("季节不存在");
*/
/*
if (x>12 || x<1)
System.out.println("季节不存在");
else if (x>=3 && x<=5)
System.out.println(x+"月是"+"春季");
else if (x>=6 && x<=8)
System.out.println("夏季");
else if (x>=9 && x<=11)
System.out.println("秋季");
else
System.outprintln("冬季");
*/
/*switch (x)
{
case 3:
case 4:
case 5:
System.out.println(x+"春季");
break;
case 6:
case 7:
case 8:
System.out.println(x+"春季");
break;
case 9:
case 10:
case 11:
System.out.println(x+"春季");
break;
case 12:
case 1:
case 2:
System.outprintln(x+"春季");
break;
default:
System.out.println("季节不存在");
break;//switch只能遇break或}才会停止，不然会一直执行下去，直到碰到break或}。
*/
/*
switch和if语句用法很像，但用法和区别：
如果判断的具体数值不多，并且符合byte,short,int,char,字符串（jsd7.0后开始支持）用switch，但优点是运行快一些，
因为是一次性全部调入内存运算。
其它情况，比如区间判断，布尔型boolean判断，使用if,if范围更广。
语句好学，灵活运用各种语句需要花时间。

/*
循环语句 有三个：while ,do while ,for ;
也就是除了条件表达示必须要结果其它都可以为空，而for语句和while是两个都是循环语句，区别是两个
1，最简单语句时，for(;;){}也就是其条件语句也可以为空，为空时，默认就是ture.最简单的while语句是：while (true)
2，二者格式不一样，for(初始表达示;循环条件语句表达示;循环后的操作表达示)，注意：条件语句表达示一定得有结果，其它的
表达式没有限制，多个表达示相连用，逗号

//例求"1+....+100"的和的两种算法。
int x=0 ,y=1;
while (y<=100)
{
x+=y;
++y;

}
System.out.println("1+..100="+x);

//第二种
int x=0;
for (int y=1; y<=100; y++)
{
x+=y;
}
System.out.println("1+....+100="+x);
*/
/*
//例二：100以内7倍数的个数
int b =0 ;
for (int x=7;x<100 ; x++ )
{
if (x%7==0)
b++;
}
System.out.println("100以内7倍数的个数="+b+"个");
*/
/*以上就是累加思想。
通过变量记录住循环操作后的结果，
通过循环的形式进去累加操作。
记数器思想
通过一个变量记住数据的状态变化。
*/
//语句的嵌套
/*
例1：需求：做一个九九乘法口决表
思路: 因为在口决表中，每一行为一个固定的值乘从1依次递增至该值的数，
所以，用for循环语句下定义一个变量后，再在这个变量的基础上进行再循环。
步骤：1，首先用for语句，定义一个变量由1~9的变量。
2，再在每个变量值基础上进行由1到该变量本身的再进行for循环。
3,做一个制表符，让表做的更美观。
/*九九乘法口诀表
System.out.println("九九乘法口诀表");
for (int x=1;x<10;x++ )
{
for (int y =1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+x*y+"\t ");//\t:表示制表符。出来的结果会自动对齐。
}
System.out.println();

}
*/
/*
例2： 1
23
456
78910 图形的做法。

int z=1;
for (int x =1 ; x<=4; x++)
{
for (int y =1; y<=x;y++ )
{
System.out.print(z+" ");
z++;
}
System.out.println();
}
*/
/*
例3：//菱形星的做法1
*
***
*****
*******
*****
***
*

int a=3,b=3 ,c=0,d=6;
for (int x = 0;x<8 ;x++ )
{
for (int y =0; y<7;y++ )
{
if (x<4)
{
if (y>=a&&y<=b)
System.out.print("*");
else
System.out.print(" ");
}
else
{

if (y>c&&y ;x++ )
{
for (int y =0; y<7;y++ )
{
if (x<4)
{

if (y>=a&&y<=b)
System.out.print("*");
else
System.out.print(" ");
}
else
{
if (y>c&&y

}
}
System.out.println();
a--;
b++;
if (x<4)
continue;//只能用于循环语句中，跳到语句开始执行，
c++;
d--;
}
*/

/*需求：菱形星的做法3
思路：可以把其分解分两个部分，第一部分先空格组成的尖朝下三然角形，定义变量为初始表达示，
然后再定义变量为条件表达示，走一个尖朝上的星三角。第二部分刚好相反。
注意，第二部分可以少一个排，还有第一部分那空格倒三角，最下面一排可以不要，这样就不会出现空格。

for (int x =1;x<8 ;x++)
{
if ( x<5)
{
for (int y =x;y<4 ;y++ )
{
System.out.print(" ");
}
for (int z =0; z
}
for (int z =x-4; z<4;z++ )
{
System.out.print("* ");
}
}
System.out.println();
}
*/
正三角星形的两种做法

7，函数

8，数组

new是一个关健字，用来产生一个新的容器实体用来存放数组。
arr数组名是数组类型，为三个引用类型之一。

而数组所暂的内存结构如下：

总的来说：
数组是堆内存中的一个实体，实体都有一个初始化地址值，实体里的数据变量都有一个默认初始化值
比如：int类型的0，boolean型是false,double是0.0 ，float是0.0f.
如果 arr不想再指向那个数组，则使用arr=null,那么arr与数组的关联不再，（注：null只能用于引用数据类型,即类class,数组[],接口interface)一旦失去关联，堆内存里的无关联实体便成了垃圾，Java会启动垃圾回收机制自动清除这具实体。
数组的两种形式：
int[] arr=new int [3],这样数组里面的变量都是默认初始化值，如果你要让其默认自已定义的值则表示为：int[] arr=new int[] {1,2,3},或int[] arr={1.2.3};其实其为 int[] arr=new int[3]; arr[0]=1;arr[1]=2,arr[2]=3;的简写.

数组常见的两个要注意的问题：
我们定义一个数组后，堆内存内容器内的数据初始值标记（角标）是从0开始，就是0位1位....，不是从一位开始，所以，例如int [] arr=new int[2],那么arr[2]的值是不存在的，因为第二位是正确的值写法是：int[1]

数组常用操作：

一般而言，有数组通常会用到遍历（即循环）
获取数组中元素的个数，用一个属性length，格式为：数组名.length，这个在数组变量直接赋值而不用初始值的时候用的到。这样就不用一个一个数。

例：/*需求：得到一个数组内数值的累加值。
思路：用for进行小于length进行遍历，再进行一个累加运算。
步骤：1，先定义一个数组，定义一个变量记住每次累加的值。
2，再进行一个for循环进行累加。
3，打印累加变量的的值。
*/
int[] arr = {2,5,4,8,7,9,56};
int x=0;
for (int y=0; yn(x);
例2：需求：打印数组中的元素，元素用逗号隔开。
思路：定义一个函数来实现。定义函数的两个前提是看返回的结果是什么？看是不是有变量参与运算。

数组的选择排序
注意最值位置

冒泡排序：

平时用来Java编程的排序是：import java.stil.*;这个写在class上面，作初始定义。
Arrays.sort(arr);
//最快的排序是希尔排序。

还是那句话，写函数先看两点，一，有没有返回值，二，有多个变量参与运算。上面置换函数有三个不确定值，所以要定义三个变量参数。
引用举例，上面选择排序的是swap（arr,x,y）;而冒泡排序的是swap(arr,y,y+1)

数组的查找

拆半查找
效率比上面的普通查找高
注意的地方，当最小值移动超过最大值，则需要停止。

折半的一个应用，我们想插入一个数到数组，让其依然有序。
注意：最后返回值

练习
进制转换函数的写法
转二进制的关健点有两个，%的充分理解，其只取余数，而不改变数本身，
第二点，int是整数型，所以其运算结果也是整数型，有小数直接舍弃，这样就可以每次除2都能为整数，直到最后为零，不在满足条件，不再执行。
下面有一个语句：
StringBuffer 名称 = new StringuBffer()
意思为创建一个字符串缓存类，即创建一个容器
再把得出的值放进去
用：名称.append(变量值)，其中最后sb后加.reverse()表示反显。如下：

下面是使用StringBuffer 语句的用法。

用查表法（应用数组的查找原理）
以下有几种演变，要注意清楚

定义一个临时容器，数组，再打印数组内的值就可以
下面的关健语句在于：arr[x]=chs[temp];注意：num代表移后的值，temp代表移出的四位2进制的值。

这下表的演变关健点在于：1，while(num!=0),这就代表当移动到左边全是0时，不再移动运算。、
2，另外要重新定义一个变量pos
3arr[pos++]代表每次表pos表值赋完后，自已加1.

再演变
前面有空格，因为，char类型有初始值，
要实现前面的空格都没有，则只需要前的不打印就可以
所以最后一句打印条件改变很重要：
for (int x=pos-1;x>=0;x--),因为之前pos自我加1了一次，但之后num=0了，没有再执行，所以实际有值存在的最高位就是pos-1

终极演变
无论正负十六进制都没问题
关健点：1，从最高位开始存放数据，
2，int pos =arr.length ; arr[--pos]=chs[temp],pos 先自减1再赋值，最终打印的时候就是for (int xpos;x随进制的不同而变化，即每次&的值和右移的位数。还有每次需要转的值也不一样.所以，总其变量就有三个.
这样一来就好定义这个函数了。如下所示：
还有一个问题是如果需要转的值为0时，就不用循环了，那么在函数里我们就要作出条件定义。
最终再分别定义各进制转换函数，就能实现任意整数的转换
最终要求哪个数的的值只要jinzhi(任意整数);搞定
以下是我方便看才放一起，实际各进制转化函数必须独立，不然无法引用。

public static void jinzhi(int = num )
{
trans(num,7,3);//8进制
trans(nun,1,1);//2进制
trans(nun,15,4);//16进制

}

二维数组：

当二维数组里的一维数组没有定义的话，我们再赋值，其结果如下，
只是把地址放入，并没有把数组也放进去。

二维数组的应用
关健点在于：
1，我们定义一个大范围时，里面有很多小区间，当我们只要知道里面的一个小区间内的值，或只要对里面进行运算的话，那么就要用到二维数组。
比如，计算一个公司的里三个团队，每个团队四个季度的总销售量

数组的格式，关健点：注意[]的位置。

语句主要分为：判断结构语句，选择结构，循环结构语句。语句间可以进行嵌套。
一，判断结构语句几以下几种格式：

例如：
class PanDuan
{
public static void main(String[] args)
{
/*
int a = 1;
if(a>2)//如果不打括号那么默认只识别离他最近的一行。
{
System.out.println("if");
}
else
{
System.out.println("else");
}
System.out.println("Hello World!");
*/
/*
if格式可以简写为三元运算：变量 = （条件表达式）？表达示1：表达示2
if语句其写三元运算区别在于，其可以不用出结果，但是三元运算符，必须出结果。
三元运算符的优点是：代码简单，缺点是：必须要出结果.
*/
//多重判断语句
/*
if()
else if ()
else if ()//可以有很多else if ，但是任意一行满足，则运行中止。整个为一个语句，不管其有多长。
......
else
//注意一种形式，如下：
if ()//这行是独立的
{
}
if ()//这个if才是和下面else为一个语句。
{
}
else
*/
实例：
需求：根据所属月份，打印对应的季节。
3，4，5春季 6，7，8夏季 9，10，11秋季 12.1.2冬季
这个程序有三种写法，第二种更简单，但要理解其中的逻辑。
/*
第一种写法：
思路： 这里面有一个是不确定的，那就是每次输入的月份，所以要用一个变量去定义。然后使用if else语句定义特定月份值所属的季节。
int x = 1;
if (x==3 || x==4|| x==5);//这里也可以用（x>=3 && x<=5）。
System.out.println(x+"月是"+"春季");
else if (x==6 x==7|| x==8)
System.out.println(x+"月是"+""夏季");
else if (x==9 || x==10|| x==11)
System.out.println(x+"月是"+""秋季");
else if (x==12 || x==1|| x==2)//但这里就不好使用比较区间了。
System.out.println(x+"月是"+""冬季");
else
System.out.println("季节不存在");//当月份变量的值不属于月份时，需要有显示错误，这样才比较直观。
*/
第二种写法：
思路：月份的范围是可控的，所了我们可以对变量定义一个区间。然后再通过if else语句实现对月份季节的判断。
/*
int x = 1;
if (x>12 || x<1)
System.out.println("季节不存在");
else if (x>=3 && x<=5)
System.out.println(x+"月是"+"春季");
else if (x>=6 && x<=8)
System.out.println(x+"月是"+""夏季");
else if (x>=9 && x<=11)
System.out.println(x+"月是"+""秋季");
else
System.out.println(x+"月是"+""冬季");//因为月份已被定义区间，而前面判断语句把其它范围定好了，所以才可以直接else而不用定义区间。
*/
二，选择结构语句：
格式写法如下：

选择结构语句要注意的关键点：

char类型swicth应用例子：

同样上面if语句那个需求：根据所属月份，打印对应的季节。也可以用switch做出来。
/*
int x =1;
switch (x)
{
case 3:
case 4:
case 5:
System.out.println(x+"春季");
break;
case 6:
case 7:
case 8:
System.out.println(x+"春季");
break;
case 9:
case 10:
case 11:
System.out.println(x+"春季");
break;
case 12:
case 1:
case 2:
System.out.println(x+"春季");
break;
default://这个放在哪位置没有影响。
System.out.println("季节不存在");
break;//switch执行到满足条件的case或没找到执行了default，那么只能遇break或}才会停止，不然会一直执行下去，直到碰到break或}。
*/
注意：
switch和if语句用法很像，但用法有区别：
如果判断的具体数值不多，并且符合byte,short,int,char,字符串（jsd7.0后开始支持）用switch，但优点是运行快一些，因为是一次性全部调入内存运算。
switch（x）,里面的只能是变量，不能是区间，if(y),变量区间都可以。
其它情况，比如区间判断，布尔型boolean判断，使用if,if范围更广。

三，循环结构语句有以下面几种格式：

循环语句要注意的关键点:
有三个种类：while , do while , for ;
也就是除了条件表达示必须要结果其它都可以为空，而for语句和while是两个都是循环语句，区别是两个
1，最简单语句时，for(;;){}也就是其条件语句也可以为空，为空时，默认就是ture.最简单的while语句是：while (true)
2，二者格式不一样，for(初始表达示;循环条件语句表达示;循环后的操作表达示)，注意：条件语句表达示一定得有结果，其它的
表达式没有限制，多个表达示相连用，逗号
//循环结构应用举例：
1，需求：求"1+....+100"的和的两种算法。
思路：用一个变量来记住每次累加的和，再用一个变量进行累加，并用定义好循环的区间。
int x=0 ,y=1;
while (y<=100)
{
x+=y;
++y;

}
System.out.println("1+..100="+x);
//第二种（用for语句进行）
int x=0;
for (int y=1; y<=100; y++)
{
x+=y;
}
System.out.println("1+....+100="+x);
*/
for循环与while循环要注意的关键点：
最简单的while语句是：while (true) {} 也就是除了条件表达示必须要结果其它都可以为空。
for语句和while是两个都是循环语句，区别是两个
1，最简单语句时，for(;;){}也就是其条件语句也可以为空，为空时，默认就是ture.
2，for(初始表达示;循环条件语句表达示;循环后的操作表达示)，注意：条件语句表达示一定得有结果，其它的
表达式没有限制，多个表达示相连用，逗号
//例二：100以内7倍数的个数
思路：100以内的7的倍数，只要除以7能整除可以，整个除也就是没有余数，取余结果为零。
在定义一个变量b用来记住整除的个数。每余数为零，即整除，那么b加1。

int b =0 ;
for (int x=7;x<100 ; x++ )
{
if (x%7==0)
b++;
}
System.out.println("100以内7倍数的个数="+b+"个");
关键点：
1，以上就是累加思想：通过变量记录住循环操作后的结果，通过循环的形式进去累加操作。
2，记数器思想：通过一个变量记住数据的状态变化。
四：语句的嵌套
很多时候我们用一个语句无法实现我们想要的功能，所以就需要各语句结合起来，这就要用到语句的嵌套。
嵌套要注意{}区间，这个最容易搞混，书写格式要规范，才不容易出错。
语句的嵌套应用举例：
例1：需求：做一个九九乘法口决表
思路: 因为在口决表中，每一行为一个固定的值乘从1依次递增至该值的数，
所以，用for循环语句下定义一个变量后，再在这个变量的基础上进行再循环。
步骤：1，首先用for语句，定义一个变量由1~9的变量。
2，再在每个变量值基础上进行由1到该变量本身的再进行for循环。
3,做一个制表符，让表做的更美观。
System.out.println("九九乘法口诀表");
for (int x=1;x<10;x++ )
{
for (int y =1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+x*y+"\t ");//\t:表示制表符。出来的结果会自动对齐。
}
System.out.println();

}
/*
例2： 1
2 3
4 5 6
7 8 9 10 图形的做法。
思路：总共有四行，用一个for循环定义好行数，每行的累加，因为每次累加的次数恰好为当时所处的行数，所以每行的累加数不超过当
时的行数。另外每行累加是从上一行末尾数累加而开始，所以，每行起头数为上一行尾数加1.
int z=1;
for (int x =1 ; x<=4; x++)
{
for (int y =1; y<=x;y++ )
{
System.out.print(z+" ");
z++;
}
System.out.println();
}
例3：//菱形星的做法
思路：可以把其分解分两个部分，第一部分先空格组成的尖朝下三然角形，定义变量为初始表达示，
然后再定义变量为条件表达示，走一个尖朝上的星三角。第二部分刚好相反。
注意，第二部分可以少一个排，还有第一部分那空格倒三角，最下面一排可以不要，这样就不会出现空格。

*
* *
* * *
* * * *
* * *
* *
*
for (int x =1;x<8 ;x++)
{
if ( x<5)
{
for (int y =x;y<4 ;y++ )
{
System.out.print(" ");
}
for (int z =0; z {
System.out.print("* ");
}
}
else
{
for (int y =0;y