『黑马程序员』第一话<JAVA基础学习>

1,dos命令行，课程中常见命令：
           dir:列出目录下的文件以及文件夹;
           md:创建目录;
           rd:删除目录;
           cd:进入指定目录;
           cd..:退回上一级;
           cd/:退回根目录;
           del:删除文件(del 可以删除非空文件夹，而rd不行)
     //目的：要在任意目录下运行javac.exe:     set path=（javac所在目录路径）  -----会临时覆盖掉原来的路径
     //目的：要在设置路径同时保留原路径：   set path=（javac所在目录路径）;%path%--------会临时增加新路径

     //目的：在任意目录下运行类：                  set classpath=类文件所在目录路径        -------------会临时设置类路径
     //目的：永久添加路径：到高级系统设置->环境变量内添加。
 2，搭建环境：

           JRE:java运行环境
           JDK:java开发工具包
           JVM:虚拟机

3，注释：   //   单选注释

       /*多行注释*/

       /** java专用注释，文档注释*/

                                                       Java的基础组成

                                                  关键字             标识符

                                                  注释            常量与变量

                                                 运算符              语句

                                                   函数                数组

1   关键字：被Java语言赋予特殊含义的单词，关键字都为小写   

2   标识符：在程序中自定义的一些名称。比如class

      注意：   以0-9，a-z ,A-Z,$和_组成

                      不能用数定开头
         
                      关键字不能当标识符

                      严格区分大小写

                       main是被JVM识别的名称

     规范： 包名xxxyyyzzz                           接口XxxYyyZzz 
 
     变量与函数名 xxxYyyZzz                 常量名 XXX_YYY_ZZZ

3   常量：

    整数常量

             十进制  ，八进制‘0’，十六进制‘0x’

             进制转换： 10->2     除以2          2-->10   各位数值*2的位数减1次幂

             2--> 16    每4位组成一位            负的二进制：取反+1

    小数常量

    布尔型常量

    字符常量

    字符串常量

4  变量：将不确定的数据进行存储。需要在内存中开辟一个空间。

    数据类型     其本数剧类型     数值型：整数 byte(8个2进制) ,short（16个2进制）,int（32个2进制）,long.

                                                         浮点类型：float（32个） double（64个）
                                                         字符型：char

                                                         布尔型：boolean

    引用数据类型                   类：class

                                                 接口: interface

                                                 数组： [ ]

     整数默认int     小数默认：double                      

     类型转换：byte b=3,b=b+2 可能损失精度   强制转换b=(byte)(b+2)

                  System.out.println('a'+1)  --->98 因为字符a自动转换成整数类型      System.out.println((char)('a'+1))

5   运算符 

      算术运算符：+ - * / %  x++   ++x    x-- --x  "xx"+"xx"（字符串+任何数据变成字符串）

                                       int x=4270; x=x/1000*1000 =4000

                                       -1%5=-1, 1%-5=1,左边小于右边=1

6.转义字符 ：通过\来转变后面字母或者符号的含义

                      \n:换行

                      \b:退格

                       \r:回车，window中，回车符是\r\n.

                       \t:制表

            目的 ：  打印出带”“的"hello",不能用 System.out.println(”“hello”“)要用 System.out.println('‘\"hello\"’)

            目的 ：  打印出\hello\,，如果用 System.out.println('“\hello\”)会提示错，System.out.println  ('“\\hello\\”)

 7.赋值运算符   ：+= -= *= /= %=     （一次运算）  short x=4   x=x+4 错误，会损失精度

8 比较运算符  ：==   !=   >    <    <=   >=  结果为true或false

9 逻辑运算符   &与 |或  ^异或（相同为false,不同为true） ！非   &&  ||短路

10 位运算符   <<左移   >>右移    >>>无符号右移    &与运算   |或运算  ^异或运算  ~反码    （只用于2进制，如果不是2进制先转换成2进制）  n^m^m=n

                        目的：  最有效率算出2*8     2<<3

                        目的：  n=3与m=8互换：方法1，利用第三变量

                                                              方法2：n=m+n;m=n-m;n=n-m;(可能超出int范围)

                                                              方法3：n=n^m;m=n^m;n=n^m

                        目的：将60转换成十六进制，  int num=60;  int n1=60&15;
                                                    int temp=60>>>4;
                                                    int n2=temp&15;
                                                    System.out.println("0x"+n2+(char)(+n1-10+'A'));
                                                     //结果为0x3C,
                                                      //存在问题，怎么知道n1与n2是否大于9

      三元运算符：（条件表达式）？表达式1：表达式2;   true就执行表达式1，flase表达式2

11语句

                 判断结构        if（条件表达式）{执行语句}

                                 if（条件表达式）{执行语句};   else{执行语句} 与三元运算符的区别：三元运算符要有一个果。

                                 if   (条件表达式)   {   } else if （） {  }  else if ()   {  } else {  }

                 选择结构       int x=2   switch(x)    { case 1:执行;break;case 2：执行;break;case3:执行;break;default:执行; }     //switch只接受byte short  int char

                                 执行顺序 与各选项排列顺序无关，default最后执行。

                                把default放第一位置，且选项中无对应值，又没break,会什么都执行，直到break,或到}

                 if与switch怎么选择：

                               如果判断具体数值不多，而符合其接受类型，用switch

                               两语句都可用，用switch,效率稍高

                               对区间判断，对结果为boolean的类型判断，使用if

                 循环结构      while (  ) {执行语句}   

                                     do{   }while(条件)    至少执行一次

                                     for(初始化表达式;循环条件表达式;循环后的操作表达式){执行}    

                                     int x=1;for(System.out.println('a');x<3;System.out.print('b'),x++) {System.out.println('c')};         

                                                                                                                                  -------------->acbcb

                 语句嵌套

 12. 函数 ：定义在类中的具有特定功能的一段独立小程序。也称方法。

                     格式：

                      修饰符    返回值类型  函数名（参数类型 形式参数1，参数类型 形式参数2，……）

                       {    

                                            执行语句;

                                            return 返回值;

                           }

                   void:当函数没有具体返回值的情况

      如何定义一个函数？

                   1.既然函数是一个独立的功能，那么该功能的运算结果是什么先明确

                   2.再明确在定义该功能的过程中是否需要未知的内容参与运算

      需求：判断两个数是否相同：

                    1.明确功能结果为boolean

                     2.功能是否有示知内容,有，两个整数

                  public static boolean compare(int a,int b 

                     {

                       /*   if(a==b)       //方法一

                                         return true;

                           return false;*/

                      /*return    (a==b)？true:false; */     //方法二

                      return   a==b;           //方法三

                     }

      重载：在同一个类中，允许存在一个以上的同名函数，只要它们的参数类型和参数个数不同（参数列表）。

13.数组：同一种类型数据的集合，其实数组就是一个容器。

                好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

                格式：元素类型[ ] 数组名=new 元素类型[元素个数或数组长度]

                          数组中数默认为0，如是boolean,默认为false

               数组存于堆内存，int[] x=new[3];int[] y=x;y[1]=89,x[1]则等于89

                int[]arr=new int[3]; int arr[]=new [3],都可以
                int[] arr=new int[]{3,5,3,6,9}
                         或
                int[] arr=new int[5];
                int[] arr={3,5,6,9,8};

                 int[] arr=new int[3]; System.out.println(arr[3]).操作数组时，访问到了数组中不存在的角标
                 int[] arr=new int[3];arr=null; System.out.println(arr[1]):空指针异常;
 14，数组的操作：
         1.获取数组中的元素，通常会用到遍历;
             数组中有一个属性可以直接获取到数组元素个数，使用方法：数组名称.length.比如，arr.length
             int[] arr={1,5,8,9,6,5,4,7};
             for(int x=0;x<arr.length;x++)
             {S.o.p(arr[x])}
         2.获取最大值与最小值 
             思路：获取最值需要进行比较，每一次比较都会有一个较大的值 ，因为该值 不确定，通过一个变量进行临储
            让数组的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值就用这个变量记录较大值。当所有的元素都比较完成，那么该变量中存储的就是      数组中的最大值。
             步骤：定义变量，初始化为数组中任意一个元素即可。通过循环语句对数组进行遍历。在变量过程中定义判断条件，如果文心遍历到的元素比变量大。就赋      值给该变量;


     需要定义一个功能来完成，以便提高复用性。
     1.先明确结果，类型 int
     2.未知内容：一个数组 int[]
     public static int getMax(int[] arr)
     {
          int max=arr[0];
          for(int x=1;x<arr.length;x++）//思路就是用数组的第一个元素与第二元素比较，把较大的值赋给max ，然后由max再跟第三个比，再把较大值赋给max，以此                                                                      循环。
         {
                   if(arr[x]>max)
                   max=arr[x];
           }
           return max;
     }
     3.对给定数组进行排序：
 ----------------------------------------------------------------------------------------------------------------------------------
class  paixu
{
          public static void main(String[] args) 
          {
                    int[] arr ={2,5,6,3,8,7};
                    paiXu(arr);
                     printArr(arr);
           }
          public static void paiXu(int[] arr)//无需返回数据，返回类型用void
          {
                    for(int x=0;x<arr.length-1;x++)
                    {
                              for(int y=x+1;y<arr.length;y++)
                              {
                                        if (arr[x]>arr[y])
                                        {
                                                  int temp=arr[x];  //交换数组元素的位置
                                                  arr[x]=arr[y];
                                                  arr[y]=temp;
                                         }
                              }
 
                   }
        }
          public static void printArr(int[] arr)//打印数组的功能
          {
                    System.out.print("arr={");
                    for(int x=0;x<arr.length;x++)
                    {
                              if(x<arr.length-1)
                                        System.out.print(arr[x]+",");
                              else

                              System.out.print(arr[x]+"}");
 
                       }
              }
}
-----------------------------------------------------------------------------------------
    冒泡排序
    在java中可直接用Arrays.sort(arr);
    4.数组的查找操作
    class  jiaobiao
{
public static void main(String[] args) 
{
int[] arr=new int[] {2,5,9,8,6,7,5,5};//如有多个被查找的元素，只返回第一个
int index=jiaoBiao(arr,5);
System.out.println(index);
}


    public static int jiaoBiao(int[] arr,int shu)
{
for(int x=0;x<arr.length;x++)
{
if(arr[x]==shu)

return x;

}
return -1;
}

}
----------------------------------------------------------------
                                注意：只查找第一个符合的角标数
    
    折半查找（必须是有序的数组）
    class  zheban
{
public static void main(String[] args) 
{
int[] arr=new int[] {1,2,3,3，6,7,8,11,12,15};
int index=zheBan(arr,8);
System.out.println(index);
}


    public static int zheBan(int[] arr,int shu)
{
int min,max,mid;
min=0;
max=arr.length-1;
mid=(max+min)/2;//定义最小值最大值与中间值。


while (arr[mid]!=shu)//如果中间值不是要找的数,就不断循环以下动作
{
if(shu>arr[mid])
min=mid+1;
else if(shu<arr[mid])
max=mid-1; //如果中间值小于要找的数，那么最小值移到中间值+1，
mid=(max+min)/2;
if(min>max)
return -1;
}
return mid;


}

}
-----------------------------------------------------------
查表法把10进度转成16进制
class chabiao 
{
public static void main(String[] args) 
{
toHex(60);
}
public static void toHex(int num)
{
char[] chs= {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//定义一个临时容器，数组
char[] arr=new char[8];
int pos=arr.length;
while(num!=0)    //当数值为0时就停止循环
{
int temp=num&15;
//System.out.println(chs[temp]);
arr[--pos]=chs[temp];//从最后一位写入数据
num=num>>>4;
}
for(int x=pos;x<arr.length;x++)//控制指针从倒数第二个数开始，到最后一个元素结束
{
System.out.print(arr[x]+",");
}
}
}
----------------------------------------------------------------------------

  二维数组，
int[][] arr= new int[3][4];
int[][] arr={{1,2,5,6}{7,1,4,5}{2,5,6,8}};
arr.length==3
arr[0].length==4
int[]x,y[];==>int[]x;int[]y[]; //x是一维，y是二维