关于菱形，当三角尖朝上，可以改变条件。让条件随着外循环变化。
当尖朝下，可以改变初始化值，让初始化值随着外循环变化。
练习：菱形
class LingXing
{
publicstatic void main(String[] args)
{
for(inta=5;a>0;a--){
for(intb=1;b
System.out.print("");
}
for(intc=6;c>a;c--){
System.out.print("*");
}
for(intd=5;d>a;d--){
System.out.print("*");
}
System.out.println();
}
for(inta=5;a>0;a--){
for(intb=6;b>a;b--){
System.out.print("");
}
for(intc=1;c
System.out.print("*");
}
for(intd=2;d
System.out.print("*");
}
System.out.println();
}
}
}
练习：给出一个十进制数得出它的各十六进制位
class Demo
{
publicstatic void main(String[] args)
{
inttest=60;
intnum;
System.out.println(test+"的各十六进制位是：");
while(test>0)
{
num=test& 15;
test=test>>4;
if(num>9)
{
charch=(char)(num-10+'A');
System.out.println(ch);
}
else
{
System.out.println(num);
}
}
}
}
函数：定义在类中具有特定功能的一段独立小程序。也称为方法。
函数的格式：
修饰符返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2）{
执行语句；
return 返回值；}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
return：用于结束函数。
返回值：该值会返回给调用者。
如何定义一个函数：
1、既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。因为这是在明确函数的返回值类型。
2、在明确定义该功能的过程中是否需要未知的内容参与运算。因为是在明确函数的参数列表（参数的类型和参数的个数）。
函数的重载（overload）：在一个类中，允许存在一个以上的同名函数，只要它们的参数个数或参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表。
重载的好处：方便于阅读，优化了程序设计。
什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同时。那么这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。
数组：同一种类型数据的集合。数组就是一个容器。
int[] x=new int[3]; 所有局部变量都在栈里，使用完自动释放，例如x，而new出来的对象都在堆里。数组被定义后会有初始化值。在堆中的垃圾会不定时的启动垃圾回收机制来进行清理。栈中的X指向的是数组在堆中的首地址。
int[] x=new int[3];
int[]y=x;//把数组x的地址给y，数组y和x指向同一数组空间
y[1]=89;//此时x[1]=89
x[1]=77;//此时x[1]=77,y[1]=77
ArrayIndexOutOfBoundsException: 数组角标越界异常
NullPointerException 空指针异常
数组的遍历、取最大（最小）值、排序
选择排序和冒泡排序掌握：
class ArrayTest
{
public static voidmain(String[] args)
{
int[]arr={1,3,2,9,6,7,5,8};
printArray(arr);
//selectSort(arr);
bubbleSort(arr);
printArray(arr);
}
//数组遍历
public static voidprintArray(int[] arr){
for(intx=0;x
if(x!=arr.length-1){
System.out.print(arr[x]+",");
}
else
System.out.println(arr[x]);
}
}
//数组置换函数
public static voidswap(int[] arr,int a,int b){
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
//选择排序，就是每一个数组与其他数组比较一遍，把最小的先找出来
public static voidselectSort(int[] arr){
for (intx=0;x
for(inty=x+1;y
if(arr[x]>arr[y]){
/*inttemp=arr[x];
arr[x]=arr[y];
arr[y]=temp;*/
swap(arr,x,y);
}
}
}
}
//冒泡排序，就是相邻数组间比较，最大的往后移
public static voidbubbleSort(int[] arr){
for (intx=0;x
for(inty=0;y
if(arr[y]>arr[y+1]){
/*inttemp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;*/
swap(arr,y,y+1);
}
}
}
}
}
折半查找的两种方法：
class ArrayTest1
{
public static voidmain(String[] args)
{
int[]arr={1,3,4,5,7,9};
int key=8;//将一个数找出它插入的位置和查找这个数原理是一样的，只是返回值的改变。不再是返回-1，而是返回min。
intindex=getIndex_2(arr,key);
System.out.println(index);
}
//第一种折半查找，用需要查找的数与mid比较
public static intgetIndex_1(int[] arr,int key){
intmin=0,max=arr.length-1,mid;
mid=(min+max)/2;
while(arr[mid]!=key){
if(key
max=mid-1;
}
else
min=mid+1;
if(min>max)
return-1;
mid=(min+max)/2;
}
return mid;
}
//第二种折半查找，用min与max比较
public static intgetIndex_2(int[] arr,int key){
intmin=0,max=arr.length-1,mid;
mid=(min+max)/2;
while(min
if(arr[mid]
min=mid+1;
}
else
if(arr[mid]>key)
max=mid-1;
else
returnmid;
mid=(min+max)/2;
}
return -1;
}
}
优化后的十进制转其他进制方法。
class ArrayTest7
{
public static voidmain(String[] args)
{
toHex(60);
System.out.println();
toBin(6);
System.out.println();
toBin(0);
}
public static voidtoHex(int num){
trans(num,15,4);
}
public static voidtoBin(int num){
trans(num,1,1);
}
public static voidtrans(int num,int base,int offset){
char[]ch={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] arr=newchar[32];
intpos=arr.length;
if(num==0){
System.out.print(0);
return;
}
while(num!=0){
inttemp=num&base;
arr[--pos]=ch[temp];
num=num>>>offset;
}
for(intx=pos;x
System.out.print(arr[x]);
}
}
}
数组中的数组：二维数组 int[][] arr=new int[3][4];
Int[][] arr=new int[3][];在这里只创建一个含三个一维数组的二维数组，没有创建每个一维数组中的元素，此时 arr[0]=null;没有初始化值，指向数据的地址为空。
小问题：
int[] x,y[];//x是一维数组，y是二维数组
相当于int[] x; int[] y[];
所以以下赋值语句：
X[0] = y;//是错的
y[0] = x;//是对的
y[0][0]=x;//是错的
x[0][0]=y;//是错的
y[0][0]=x[0];//是对的
x=y;//是错的
我的总结：这一部分的内容还是主要围java语言的基础，熟练掌握各种基础语句，if、for、while等的综合运用，能够编写小的程序。明确函数是什么，函数的格式，以及如何定义一个函数，这是学习java语言的基础。着重明确什么是重载，知道重载如何使用，什么时候使用。明确数组在内存中是如何存储的，千万区分出栈内存和堆内存，知道分别存储的是什么。会用数组编写一些简单的程序，掌握数组如何遍历、排序、查找等问题。
