黑马上程序员----2015.6.11java笔--break,堆，重载，排序，数组

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.break 和 continue语句的作用范围

2.break 和 continue单独存在时，下面不可以有任何语句，因为无效。
3.当函数运算后，没有具体的返回类型用void表示。当返回类型为void时，函数中的return可以省略不写。
4.函数里面不能定义函数
5.如何定义一个函数
        a.既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。
             即明确返回值类型
        b.在明确在定义该功能的过程中是否需要未知的内容参与运算。
             即明确参数列表
6.返回值类型为void时，System.out.println();中不能输出
    eg： public static void get(int a,int b)    
            {
                System.out.println(a+b);
                return;
            }
            System.out.println(get(3,4));//编译不会通过
7.什么时候用重载？
        当定义的功能相同，但参与运算的未知内容不同。
        那么，这时候就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个不同函数。
8.void show(int a,char b,double c) {} 以下和其重载的有哪些？
    1.void show(int x,char y,double z) {}  //没有重载
    2.int show(int a,double b,char c) {}   //重载，参数列表不同，与返回值类型无关
    3.void show(int a,double b,char c) {}  //重载，参数列表不同，与返回值类型无关
    4.void show(double c)　{}              //重载，参数列表不同
　5.boolean show(int c,char b) {}        //重载，参数列表不同
  6.double show(int x,char b,double c) {}//没有重载，参数列表一致。
9.    a.new出来的东西都在堆里面
        b.堆内存中的数据都有默认的初始值
        c.当栈中不在有指向堆的引用时，堆中实体数据即变成垃圾。java虚拟机会使用垃圾回收机制，不定时清理内存。
    
10. 单一数组的几种创建方法
        int[] arr = new int[3];
        int arr1[] = new int[3];        //这种方法也可以但是不是太推荐！
        int[] arr2 = new int[]{1,2,3};  //切记！new int[]中不能写数组的大小
        int[] arr3 = {3,4,5};
        
11.//选择排序法（数组从小到大排序）
 

   public static void selectSort(int[] a)         {            for(int x=0;x<a.length-1;x++)            {                for(int y=x+1;y<a.length;y++)                {                    if(a[x]>a[y])                     {                        int temp =  a[x];                        a[x] = a[y];                        a[y] = temp;                    }                    }                                }                                }                        //冒泡排序        public static void bubbleSort(int[] arr)         {            for(int x = 0;x<arr.length-1;x++)                {                for(int y = 0;y<arr.length-1-x;y++) //-x是为了每一次循环减少一次比较，-1是为了防止数组越界                {                    if(arr[y]>arr[y+1])                    {                            int temp = arr[y];                            arr[y] = arr[y+1];                            arr[y+1] = temp;                    }                }                }                    }

12.折半要求数组是有序的！
        eg:  //折半查找
          

 class HalfSearch             {                public static void main(String[] args)                 {                        int[] arr = {2,4,6,8,9};                        System.out.println(getIndex(arr,6));                }                                public static int getIndex(int[] arr,int x)                 {                    int min = 0;                    int max = arr.length-1;                    int mid = (min+max)/2;                                        while(arr[mid]!=x)                     {                            if(arr[mid]>x)                            {                                max = mid - 1;                            }else{                                min = mid + 1;                            }                            if(min>max)                                return -1;                            mid = (min+max)/2;                    }                    return mid;                }            }

            
13.        //10进制----->2进制
         

  public static void toBin(int a)             {                    StringBuffer sb = new StringBuffer();                    while(a>0)                     {                        sb.append(a%2);                        a = a/2;                    }                    System.out.println(sb.reverse());            }                        //10进制----->16进制            public static void toHex(int a)            {                    StringBuffer sb = new StringBuffer();                    for(int x = 0;x<8;x++)                    {                        int temp = a & 15    ;                        if(temp>9)                        {                                sb.append((char)((temp-10)+'A'));                        }else{                                sb.append(temp);                        }                        a = a>>>4;                    }                    System.out.println(sb.reverse());