java基础（环境设置，基础语法，函数数组）

框架图

环境搭建

课程中常见dos命令：

dir : 列出当前目录下的文件以及文件夹

md : 创建目录

rd : 删除目录

cd : 进入指定目录

cd.. : 退回到上一级目录

cd/ : 退回到根目录

del : 删除文件

exit : 退出dos命令行

JDK,JRE的区别：

JDK是Java程序开发包，是面向开发人员使用的SDK，它同时提供了Java的开发环境和运行环境。

JRE是指Java的运行环境，是面向Java程序的使用者，而不是开发者。

简单而言：使用JDK开发完成的java程序，交给JRE去运行。

path和classpath环境变量的作用

path 环境变量的作用是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会到path变量所指定的路径中查找看是否能找到相应的命令 程序。我们需要把jdk安装目录下的bin目录增加到现有的path变量中，bin目录中包含经常要用到的可执行文件如javac/java /javadoc等，设好path变量后，就可以在任何目录下执行javac/java等工具了。

classpath环境变量的作用是指定类搜索路径，要使用已经编写好的类，JVM就是通过classpath来寻找类的。如果需要访问当前目录可以用“.”表示。

语法

关键字

Java语言中已经被赋予特定意义的一些单词，它们在程序上有着不同的用途，不可以把关键词作为类名、变量名、方法名、类型名、数组名、文件名等名字来用。

标识符

用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。

◆由大小写字母、数字、_和$符组成

◆数字不可以打头，不可以使用关键字和main

◆严格区分大小写，没有长度限制
◆为了提高阅读性，应该具有特定的意义

Java中的名称规范：
包名：多单词组成时所有字母都小写。
xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写。
XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二 个单词开始每个单词首字母大写。
xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。
XXX_YYY_ZZZ

数据类型

数据类型的转换就是把一种基本数据类型变量转变成另一种基本类型变量。
　　 ◆ 精度由低到高排列为：
　　　　　低———————————————→高
　　　　　byte   short  char  int  long  float  double
　　 ◆ 当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。
　　 ◆ 当把级别高的变量的值赋给级别低的变量时，必须使用显示类型转换运算。
　　 ◆ 高精度向低精度转换容易造成精度损失。
自动类型提升
byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。

强制类型转换
byte b = 3;
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。

算术运算符

赋值运算符

= , +=, -=, *=, /=, %=

示例：
int a,b,c; a=b=c =3;
int a = 3; a+=5;等同运算a=a+5;
-=, *=, /=, %=类推

short s = 3;

s=s+2;

s+=2;

有什么区别？

s=s+2编译失败。这是两次运算，s被提升为int型，运算结果为int型，无法赋给short类型；

s+=2编译通过，这是一次运算，+=运算符在给s赋值时，自动完成了强制转换操作。

比较运算符

逻辑运算符

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

“&”和“&&”的区别：“短路“

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

异或( ^ )与或( | )的区别：当左右都为true时， 结果为false。

位运算符

位运算符是直接对二进制位进行的运算。

x<<n 相当于x乘以2的n次幂；例如，3 << 2 = 12 ‐‐> 3*2*2=12

x>>n 相当于x除以2的n次幂；例如，3 >> 1 = 1 ‐‐> 3/2=1

<<
空位补0，被移除的高位丢弃，空缺位补0。
>>
被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。
>>>
被移位二进制最高位无论是0或者是1，空缺位都用0补。

&和丨：0视为假，1视为真。

二进制位进行&运算，只有1&1时结果是1，否则是0;

二进制位进行| 运算， 只有0 | 0时结果是0，否则是1;
x ^ n ^ n = x，一个数异或另一个数两次，结果仍是这个数。主要用于加密。

相同二进制位进行^ 运算，结果是0。1^1=0 , 0^0=0
不同二进制位进行^ 运算，结果是1。1^0=1 , 0^1=1

~：取反

练习对两个整数变量的值进行互换

 int n = 3,m = 8;
 //1,通过第三方变量。
 int temp;
 temp = n;
 n = m;
 m = temp;

 //2,不用第三方变量。
 11 = 3 +  8;
 3 = 11 - 8;
 8 = 11 - 3;

 n = n + m;
 m = n - m;
 n = n - m;//如果n和m的值非常大，容易超出int范围。

 //3,使用异或
 n = n ^ m;
 m = n ^ m;//(n^m)^m
 n = n ^ m;//n ^ (n ^ m)

练习把一个十进制数转成十六进制

  class GetNumDemo {
         public static void main(String[] args){
             int num = 77;
             //获取77的最低4位，通过&15；
             int n1 = num & 15;
             System.out.println(n1>9?(char)(n1-10+'A'):n1);//68 ，这里无法强转因为char与n1比较自动提升数据类型

             //获取下一组四位，将77右移4位。
             int temp = 77>>>4;  

             //对temp的值进行最低四位的获取，通过&15；
             int n2 = temp & 15;
             System.out.println(n2>9?(char)(n2-10+'A'):n2);//4
         }
     }  

三元运算符

格式:(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；

 //获取两个数中大数。
 int x=3,y=4,z;
 z=(x>y)?x:y;
 //z=4

判断结构语句

if语句三种格式

 1.
 if(条件表达式)
 {
 执行语句；
 }
 2.
 if(条件表达式)
 {
 执行语句；
 }
 else
 {
 执行语句；
 }
 //if-eise语句与三元运算符的区别是三元运算符简化了代码但要有运算结果
 3.
 if(条件表达式)
 {
 执行语句；
 }
 else if (条件表达式)
 {
 执行语句；
 }
 ……
 else
 {
 执行语句；
 }

选择结构语句

switch语句格式：

 switch(表达式)
 {
 case 取值1:
 执行语句；
 break；
 case 取值2:
 执行语句；
 break；
 …...
 default:
 执行语句；
 break；
 } 

switch语句特点：

a,switch语句选择的类型只有四种：byte，short，int ，char。
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

if和switch语句应用区别：

如果判断的具体数值不多，而且符合byte short int char这四种类型，虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高；

其他情况：对区间判断或者对结果为boolean类型判断，建议使用 if，if的使用范围更广。

循环结构语句

代表语句while，do while，for

while语句格式：

 while(条件表达式)
 {
 执行语句；
 }

do while语句格式：

 do
 {
 执行语句；
 }
 while(条件表达式); 

while:先判断条件，只有条件满足才执行循环体。
do while: 先执行循环体，在判断条件，条件满足，再继续执行循环体。
简单一句话，do while无论条件是否满足，循环体至少执行一次。

for语句格式：

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

注：

a.for里面的连个表达式运行的顺序，初始化表达式只读一次,判断循环条件,为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件, 重复找个过程，直到条件不满足为止。
b.while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。for的初始化动作在内部,while初始化动作在外部,变量在内存中的驻留时间不一样。while中的变量在下面的代码中仍然可以使用。如果变量只是为了循环存在，也就是需要定义增量，使用for比较合适，内存比较优化。
c.循环要注意哪些语句需要参与循环，那些语句不需要。
d.最简单无限循环格式：while(true){} , for(;;){},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
e.语句的结束，要么是“；”要么是“}”。例如，while(x<3);没有执行语句会不断的判断条件。

其他流程控制语句

break语句：应用于选择结构和循环结构。
continue语句：应用于循环结构。
注：
a,这两个语句离开应用范围，存在是没有意义的。
b,这个两个语句单独存在下面都不可以有语句，因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现，可以让这两个语句作用于指定的范围。

求1-100所有奇数和和奇数的个数（累加和计数器）

   class  GetSum
   {
       public static void main(String[] args)
       {
           //1,定义变量用于存储不断变化的和。
           int sum = 0;
           //2，定义变量，记录住不断变化的被加的数。
           int x = 1;
           //3，定义计数器
           int count=0;
           //3，定义循环，重复加法的过程。
           while(x<=100)
           {
            if (x%2==1){
            sum +=x;
            count++;}
            else{
            sum += 0;}
                  x++;
           }
           //改写三元运算符格式
           /* while(x<=100)
                {sum=(x%2==1)?sum+x:sum+0;
              if（x%2==1）
                count++
              x++；}*/

          //改写for形式
          /*int sum = 0;
          int count=0;
          for (int x=1;x<=100 ;x++)
          {
          if (x%2==1)
           {sum+=x;count++;
           }
          }*/
          System.out.println("sum="+sum);
          System.out.println("count="+count);
      }
   }

练习嵌套For循环打印矩形、平行四边形、三角形和菱形

 /*
  使用嵌套循环用“*”输出矩形、平行四边形、三角形和菱形
 */

 public class Test_LoopDemo
 {
 public static void main(String[] args)
 {
 PrintRect();
 System.out.println("----------------------");
 PrintParallelogram();
 System.out.println("----------------------");
 PrintTriangle ();
 System.out.println("-----------------------");
 PrintRhombus ();
 }

 // PrintRect输出矩ln形五行五列

 public static void PrintRect (){
 //外循环控制输出5行“*”
 for (int i = 1; i <= 5; i++ ){
 //内循环控制每行输出“*”
 for (int j = 1; j <= 5; j++){
 System.out.print ("*");
 }
 System.out.print ("\n");//换行打印
   }
 }

 //PrintParallelogram输出平行四边形

 public static void PrintParallelogram (){
 for (int i = 1; i <= 5; i++ ){
 for (int k = i; k <= 5; k++){
 System.out.print (" ");
 }
 for (int j = 1; j <= 5; j++){
 System.out.print ("*");
 }
 System.out.print ("\n");
 }
 }

 //PrintTriangle输出三角形
 public static void PrintTriangle (){
 for (int i = 1; i <= 5; i++ ){
 //控制输出空格
 for (int k = i; k <= 5; k++){
 System.out.print (" ");
 }
 //内循环控制每行输出“*”
 for (int j = 1; j <= 2 * i - 1; j++){
 System.out.print ("*");
 }
 System.out.print ("\n");//换行打印
 }
 }

 //PrintRhombus输出菱形
 public static void PrintRhombus (){
 //输出正三角
 for (int i = 1; i <= 5; i++ ){
 //控制输出空格
 for (int k = i; k <= 5; k++){
 System.out.print (" ");
 }

 //内循环控制每行输出“*”
 for (int j = 1; j <= 2 * i - 1; j++){
 System.out.print ("*");
 }
 System.out.print ("\n");//换行打印
 }
 //输出倒三角
 for (int i = 1; i <= 4; i++ ){
 //控制输出空格
 for (int k = i-1; k <= 2 * i - 1; k++){
 System.out.print (" ");
 }
 //内循环控制每行输出“*”
 for (int j = 7; j >= i *2 - 1; j--){
 System.out.print ("*");
 }
 System.out.print ("\n");//换行打印
 }
 }
 }
运行结果：

函数

函数也称为方法，是定义在类中的具有特定功能的一段独立小程序。
修饰符返回值类型函数名(参数类型形式 参数1, 参数类型形式 参数2,...)
{
执行语句;
return 返回值;
}

返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。

函数特点：
定义函数可以将功能代码进行封装
便于对该功能进行复用
同时提高了代码的复用性
函数只有被调用才会被执行
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的应用
明确要定义的功能最后的结果是什么？明确函数的返回值类型
明确在定义该功能的过程中，是否需要未知内容参与运算？明确函数的参数列表（参数的类型和参数的个数）

函数的重载(overload)
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表。参数的顺序不同，参数列表也会不同。
重载的好处：
方便于阅读，优化了程序设计。

数组

数组是同一种类型数据的集合。其实数组就是一个“容器”。数组中的数据就是“元素”、
数组可以自动给数组中的元素从0开始编号，方便操作这些元素。

 格式1：
 元素类型[] 数组名= new 元素类型[元素个数或数组长度];
 示例：int[] arr = new int[5];
 格式2：
 元素类型[] 数组名= new 元素类型[]{元素，元素，……};
 int[] arr = new int[]{3,5,1,7};
 int[] arr = {3,5,1,7};

Java程序在运行时，需要在内存中的分配空间（栈内存，堆内存，方法区，本地方法区，寄存器）。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存

• 用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存

• 数组和对象，通过new建立的实例都存放在堆内存中。
• 每一个实体都有内存地址值
• 实体中的变量都有默认初始化值
• 实体不在被使用，会在不确定的时间内被垃圾回收器回收
• 方法区，本地方法区，寄存器

二维数组[][]

格式1：int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2：int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

int[] x; int x[];
int[][] y; int y[][]; int[] y[];

int[] x,y[];//x一维，y二维。
int[] x;
int[] y[];

a.
x[0] = y;//error
b.
y[0] = x;//yes
c.
y[0][0] = x;//error
d.
x[0][0] = y;//error
e.
y[0][0] = x[0];//yes
f.
x=y;//error

数组的应用----获取数组遍历数组

 class GetArray
 {
     public static void main(String[] args)
     {
     //数组的操作：
     //获取数组中的元素。通常会用到遍历。

     int[] arr = {3,6,5,1,8,9,67};

     //获取数组元素个数：数组名称.length =
     System.out.println("length:"+arr.length);

     for(int x=0; x<arr.length; x++)
         {

     System.out.println("arr["+x+"]="+arr[x]+";");
         }

     //打印的数组地址值
     System.out.println(arr);

 }
   } 

数组的应用----获取数组最值

 class  Get1
 {
     public static void main(String[] args)
     {
         int[] arr = {3,6,5,1,8,9,67}
         for(int x=0; x<arr.length; x++)
          {
         System.out.println("arr["+x+"]="+arr[x]+";");
         }

             int max=getMax(arr);
             int min=getMin(arr);
             System.out.println("max="+max);
             System.out.println("min="+min);
 }
      public static int getMax(int[] arr)
      {
         int max = 0;

         for(int x=1; x<arr.length; x++)
         {
             if(arr[x]>arr[max])
                 max = x;
         }
         return arr[max];
     }
     public static int getMin(int[] arr)
     {
         int min = 0;
         for(int x=1; x<arr.length; x++)
         {
             if(arr[x]<arr[min])
                 min = x;
         }
         return arr[min];
     }
 }  

数组的应用----排序

 /*对给定数组进行排序。
 {5,1,6,4,2,8,9}*/
 import java.util.*;
 class ArraySort
 {
      //选择排序。内循环结束一次，最值出现头角标位置上。
     public static void selectSort(int[] arr)
     {
         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 bubbleSort(int[] arr)
     {
         for(int x=0; x<arr.length-1; x++)
         {
             for(int y=0; y<arr.length-x-1; y++){//-x:让每一次比较的元素减少，-1：避免角标越界。
                 if(arr[y]<arr[y+1])
                 {
                     int temp = arr[y];
                     arr[y] = arr[y+1];
                     arr[y+1] = temp;
                 }
             }
         }
     }
     public static void main(String[] args)
     {
         int[] arr = {5,1,6,4,2,8,9};
         //排序前；
         printArray(arr);

         //排序
         //selectSort(arr);
         bubbleSort(arr);

         //Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
         //排序后：
         printArray(arr);

     }
     //打印数组函数
     public static void printArray(int[] arr)
     {
         System.out.print("[");
         for(int x=0; x<arr.length; x++)
         {
             if(x!=arr.length-1)
                 System.out.print(arr[x]+", ");
             else
                 System.out.println(arr[x]+"]");
         }
     }
 } 

数组的应用----查找

 class GetArray
 {
     public static void main(String[] args)
     {
         int[] arr = {3,2,1,5,4,2,9};
         int index = getIndex(arr,5);
         System.out.println("index="+index);
     }
    public static int getIndex(int[] arr,int key)
     {
         for(int x=0; x<arr.length; x++)
         {
             if(arr[x]==key)
                 return x;
         }
         return -1;
     }
 }
 //输出结果：index=3 

数组的应用----折半查找（只适用于有序数组,实际使用Arrays.binarySearch）

 public static int halfSearch_1(int[] arr,int key)
     {
         int min,max,mid;
         min = 0;
         max = arr.length-1;
         mid = (max+min)/2;

         while(arr[mid]!=key)
         {
             if(key>arr[mid])
                 min = mid + 1;
             else if(key<arr[mid])
                 max = mid - 1;

             if(min>max)
                 return -1;
             mid = (max+min)/2;
         }
         return mid;
     }

 public static int halfSearch_2(int[] arr,int key)
     {
         int min = 0,max = arr.length-1,mid;

         while(min<=max)
         {
             mid = (max+min)>>1;

             if(key>arr[mid])
                 min = mid + 1;
             else if(key<arr[mid])
                 max = mid - 1;
             else
                 return mid;
         }
         return -1;
     }

十六进制转换对比当时位运算

 1 class ArrayTest {
 2       public static void main(String[] args) {
 3           toBin(6);
 4           toHex(60);
 5       }
 6 /*
 7 十进制-->十六进制。
 8 */
 9       public static void toHex(int num) {
   
           StringBuffer sb = new StringBuffer();
   
           for(int x=0; x<8; x++){
               int temp = num & 15;
               if(temp>9)
                   //System.out.println((char)(temp-10+'A'));
                   sb.append((char)(temp-10+'A'));
               else
                   //System.out.println(temp);
                   sb.append(temp);
   
              num  = num >>> 4;
           }
           System.out.println(sb.reverse());
   
      } 
 /*
 十进制-->二进制
 */
       public static void toBin(int num){
           StringBuffer sb = new StringBuffer();
   
           while(num>0){
               //System.out.println(num%2);
               sb.append(num%2);
               num = num / 2;
           }
           System.out.println(sb.reverse());
       }
   }

查表法进制转换

 1 class ArrayBase  {
 2       public static void main(String[] args) {
 3           //toBin(-6);
 4           //toHex(-60);
 5           //toBa(60);
 6   
 7   //        System.out.println(Integer.toBinaryString(6));
 8   //        System.out.println(Integer.toHexString(6));
 9      }
   
 /*
 十进制-->二进制
 */
       public static void toBin(int num){
           trans(num,1,1);
      }
  
 /*
 十进制-->八进制
 */
       public static void toBa(int num) {
           trans(num,7,3);
      }
 /*
 十进制-->十六进制
 */
       public static void toHex(int num){
           trans(num,15,4);
       }
       public static void trans(int num,int base,int offset)  {//需要转换的数字，需要与的基础数，需要右移的位数
           if(num==0){
               System.out.println(0);
               return ;
           }
           char[] chs = {'0','1','2','3'
                       ,'4','5','6','7'
                       ,'8','9','A','B'
                      ,'C','D','E','F'};
           char[] arr = new char[32];
   
           int pos = arr.length;
   
           while(num!=0){
               int temp = num & base;
               arr[--pos] = chs[temp];
               num = num >>> offset;
           }
   
           for(int x=pos; x<arr.length; x++){
              System.out.print(arr[x]);
           }
           return ;
       }
   }

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------