第1章 初识JAVA
*Java开发的三个方向：

1、Java SE:主要用于桌面程序的开发；

2、Java EE：主要用于网页程序的开发；

3、Java ME：主要用于嵌入式系统程序的开发。



*Java语言的主要特性：

1、面向对象；



2、分布性：可以在多个不同的主机上布置相关操作，同时数据也可以存放在多个不同的主机上，Java可以凭借URL对象访问网络对象，访问的方式和访问本地系统相同；



3、可移植性：Java程序与平台系统无关，通过JVM处理字节码文件以适应不同平台；



4、安全性：删除了类C语言中的指针、内存管理等语法，避免了非法的内存操作。同时Java程序要经过代码校验、指针校验等多种测试才可以运行；



5、多线程：Java允许应用程序同时并行执行多项任务，而且相应的同步机制可以保证不同线程能正确地共享数据；



6、高性能：Java编译后的字节码是在解释器中运行的，其运行速度比多数交互式的应用程序提高很多；



7、解释性、健壮性、动态等…。



*JDK安装后的环境变量配置：



1、JAVA_HOME:指向jdk的安装目录，Eclipse等软件就是通过搜索该变量值对应路径找到jdk；



2、PATH：在起始位置添加“%JAVA_HOME%\bin;”。其作用是指定命令搜索路径，在shell下面执行命令时，系统会到PATH变量所指定的路径中查找相应的命令程序（bin目录中包含经常要用到的可执行文件如javac/java/javadoc等）。设置好 PATH变量后，就可以在任何目录下执行javac/java等工具了；



3、CLASSPATH：作用是指定应用程序中使用的类的搜索路径JVM就是通过CLASSPTH来寻找类的。



*第一个Java程序


public class MyApp{
    public static void main(String[] args){
        System.out.println(
        System.out.println("My Java Application!");
    }
}
//存储在D盘根目录下，D:\MyApp.java
//进入Shell中D盘符，输入javac MyApp.java
//通过dir可以发现D盘根目录下多出了一个MyApp.class文件
//这就是javac命令的作用：生成源程序的字节码文件
//在D盘目录下，输入java MyApp
//可在shell窗口看到输出:My Java Application!
//这里java命令即是运行之前生成的字节码文件，即MyApp.class
//但需要注意，这里不能用java MyApp.class

第2章 熟悉Eclipse开发工具

*Eclipse是IBM公司用Java语言开发的开源IDE集成开发工具。



*使用Eclipse编写Java程序：



1、首先通过“新建”创建一个Java项目，并输入项目名，假设为MyApp；



2、继续通过“新建”创建一个Java类，输入类名称时要注意类名必须和项目名一致，这里即是MyApp；



3、创建完成类之后Eclipse会自动打开代码编辑区，输入代码完成编程；



4、代码编写完成后可通过“运行”执行程序，或Ctrl+F11快捷键。



5、断点的设置：可以在需要设置断点的代码行对应的行号位置双击或者选择“切换断点”设置或删除；



6、以调试方式运行程序：右键点击程序代码选择“调试方式”/“Java应用程序”（或者通过菜单），调试器将执行到断点处挂起当前线程使程序暂停；



7、程序调试：程序被暂停后，可通过调试工具栏上的单步跳入（对应快捷键F5）使得执行跳入调用方法或者对象的内部单步执行程序；或通过单步跳过（对应快捷键F6）即运行单独的一行程序代码，跳到下一个可执行点。


第3章 Java语言基础


一、标识符和关键字

1、Java中的标识符用于标识类名、变量名、方法名、数组名、文件名。



2、标识符的命名规则：由字母、数字、下划线和美元符号组成，但第一个字符不能是数字。同时标识符不能选用Java的关键字和保留字。



3、一般的约定命名规则：

（1）类和接口名：每个词首字母大写，如MyClass,HelloWorld；



（2）方法名：第一个词的首字母小写，其余词首字母大写，尽量少用下划线，如myMethod,myGetData；



（3）常量名：基本数据类型的常量名全部用大写字母，各词之间用下划线分隔，如SIZE_NAME；



（4）变量名：首词首字母小写，其余词首字母大写，不用下划线，尽量少用美元符号。



二、基本数据类型

1、整数类型：有byte\short\int\long四种，存储空间分别为1、2、4、8个字节，其中给long类型变量赋值时必须在结尾加L或l，如：long BigNumber=1234567L。



2、浮点类型：有float单精度和double双精度两种，分别占4、8个字节。其中float类型变量赋值时结尾必须加F或f。



3、字符类型：使用char进行声明，占用两个字节。



4、布尔类型：使用boolean进行声明，只能由true和false两个值。



三、变量和常量

1、变量的有效范围（作用域）

（1）在类体中定义的变量被称为成员变量，成员变量在整个类中都有效。类的成员变量分为静态变量和实例变量，静态变量通过修饰符static确定，并且可以通过“类名.静态变量名称”的方式在其他类中使用。



class var{
    int x=3;         //这里定义了var类的一个实例变量x
    static int y=30; //这里定义了var类的一个静态变量y
}
class bar{
    int a=var.y;
/*
定义bar类的实例变量a，
并把var类中静态变量y的值赋值给a
*/
}

（2）在类的方法体中定义的变量为局部变量，只在当前代码块中有效，其生命周期只在该方法被调用时，虚拟机为其分配内存空间，方法调用结束后，则该内存也被释放。

（3）在类中某一方法体内，可直接使用类体创建的静态变量，当该静态变量与该方法体中创建的局部变量重名时，静态变量将被隐藏，如果须调用该类体静态变量时，需使用“类名.静态变量名称”的方式。
注：经测试，类体中的实例变量无法在方法中使用。

public class Number {
    static int mydata=414;
     static int yourdata=1973;   
         public static void main(String[] args) {
         int mydata=1314;
         System.out.println("类体静态变量mydata的值是"+Number.mydata);
         System.out.println("类体静态变量yourdata的值是"+yourdata);
         System.out.println("方法内部的局部变量mydata的值是"+mydata);
     }
}
/*
输出----------
类体静态变量mydata的值是414
类体静态变量yourdata的值是1973
方法内部的局部变量mydata的值是1314
----------------
*/

四、运算符
异或的应用范例：不使用辅助变量实现两变量的值互换

import java.util.Scanner;
public class Nexchange {
     public static void main(String[] args){
         Scanner scan=new Scanner(System.in);
         System.out.println("请输入变量A的值");
         long A=scan.nextLong();
         System.out.println("请输入变量B的值");
         long B=scan.nextLong();
         System.out.println("A="+A+"\tB="+B);
         System.out.println("执行变量互换...");
         A=A^B;
         B=B^A;
         A=A^B;
         System.out.println("A="+A+"\tB="+B);      
     }
}
/*
这里运用了位操作异或，对于整数X有:X^X=0;X^0=X;同时异或操作满足结合律和交换律
将A=A^B带入后面两式，分别如下：
B=B^A=B^A^B=A^(B^B)=A^0=A;
A=A^B=(A^B)^A=...=B;
----------
引申：除异或方法外，不通过辅助变量的方法还有：
（1）a=a+b;b=a-b;a=a-b;
（2）a=a*b;b=a/b;a=a/b;
*/

五、实例
1、判断某一年是否为闰年

import java.util.Scanner;
public class LeapYear{
     public static void main(String[] args){
         Scanner scan=new Scanner(System.in);
         System.out.println("请输入年份（0~99999）：");
         long year=scan.nextLong();
         while (year<0||year>99999){
             System.out.println("请重新输入年份（0~99999）：");
             year=scan.nextLong();
        }
        scan.close();
         if((year/400==0)||((year/4==0)&&(year/100!=0))){
             System.out.println("输入年份为"+year+"是闰年");
        }
         else {
             System.out.println("输入年份为"+year+"不是闰年");
        }
    }
}

2、不使用乘号运算符，用移位运算符计算21*16。

public class MoveBit {
     public static void main(String[] args){
         long a=21L;
         int x=1;
         for(int i=1;i<5;i++){
             x*=2;
             a=a<<1;
             System.out.println("21左移动"+i+"位就是乘以"+x+"结果为"+a);
        }
    }
}

第4章 流程控制

一、条件语句

1、if语句



if(布尔表达式){
    语句序列
}
/*
布尔表达式如果为true则执行if代码块中的语句序列；
反之则不执行。
*/

2、if…else语句

if(布尔表达式){
    语句序列
}
else{
    语句序列
}
/*
布尔表达式如果为true则执行if代码块中的语句序列；
反之则执行else代码块中的语句序列。
如果一段代码中有多处if..else，则每一个else总是与它上面最近的一个if相匹配。
*/

/*
创建GetTerm类，在主方法中定义变量x，从控制台输入接受赋值，并通过if...else if多分支语句判断x的值决定输出结果。
*/
import java.util.Scanner;
public class GetTerm {
     public static void main(String[] args){
         Scanner scan=new Scanner(System.in);
         System.out.println("请输入一个整数：");
         int x=scan.nextInt();
         if(x>1000){
             System.out.println("x的值大于1000");
         }else if(x>500){
             System.out.println("x的值大于500，但小于1000");
         }else if(x>100){
             System.out.println("x的值大于100，但小于500");
         }else {
             System.out.println("x的值小于100");
        }
        scan.close();
    }
}

3、switch多分支语句

switch(表达式）｛   //表达式的值必须是整型或者字符型
case 常量值1：      //这里常量值必须与表达式的值对应，下同
    语句序列1
     break;   //跳出switch语句块，如没有则会继续执行下一句
case 常量值2：
    语句序列2
     break;
...
default:   //当上述各case的常量值没有匹配时候则从此处执行
     语句序列；
      break;
}  

import java.util.Scanner;
public class Switch_Example {
     public static void main(String[] args){
         Scanner scan=new Scanner(System.in);
         System.out.println("请输入你的姓名：");
         String name=scan.nextLine();
         System.out.println("请输入你的专业编号（0~9）：");
         int majorLanguage=scan.nextInt();

         switch(majorLanguage){
         case 0:
         case 1:
         case 2:
             System.out.println("恭喜你，"+name+"你被分配到办公室");
             break;
         case 3:
         case 4:
         case 5:
         case 6:
             System.out.println("恭喜你，"+name+"你被分配到总工办");
             break;
         case 7:
         case 8:
         case 9:
             System.out.println("恭喜你，"+name+"你被分配到财务处");
             break;
         default:
             System.out.println("抱歉，你未被录用");     
         }
         scan.close();
     }
}

二、循环语句
1、while语句

while(条件表达式）{   //条件表达式必须为布尔类型
  语句序列；          //条件表达式为true则执行该语句序列
}                 //否则退出循环

2、do…while语句

do {
    语句序列；
}while(条件表达式）  /*与while语句的区别可以从顺序上理解出，即便条件表达式为false，也会执行一次do代码块里的指令*/

3、for语句

for(表达式1；表达式2；表达式3）{
    语句序列；
}
/*
表达式1：初始化工作
表达式2：为布尔类型，用于判断循环条件
表达式3：改变循环条件判断参数
表达式2：为布尔类型，用于判断循环条件
表达式3：改变循环条件判断参数
执行流程：先通过表达式1进行初始化设置工作，再判断表达式2，如果为true则执行语句序列，再通过表达式3改变循环条件判断参数；进入第二次循环时候先判断表达式2，如果为true则执行语句序列，再通过表达式3改变循环条件判断参数；直至某次判断表达式2为false则跳出循环。
*/

//用for循环输出九九乘法表
public class MultiTable {
     public static void main(String[] args){
         for(int i=1;i<10;i++){
             for(int j=1;j<i+1;j++){
                 System.out.println(j+"*"+i+"="+j*i+" ");
            }
             System.out.println();  //换行
        }
    }
}

4、foreach语句

for(元素变量x:遍历对象obj){
     语句序列（一般会对x有操作）
}
/*foreach是for语句的特殊简化格式，从上述示例代码可以看出foreach并不是所用的关键字，而是习惯上对这种循环的称谓。*/

//使用foreach语句读取一位整型数组各元素
public class Repetition {
     public static void main(String[] args){
         int arr[]={1,3,4,7,8,10};
         System.out.println("一维数组中各元素分别为：");
         for(int x:arr){
             System.out.println(x+"\t");
        }
    }
}

三、跳转语句
1、break语句
break只可以用在switch\for\while\do..while循环语句中，用于强行退出整个循环体。

2、continue语句
continue只能用在for\while\do…while循环语句中，用于直接跳出当前循环进入下一次循环。

//计算1~100各偶数之和 2 public class ContinueDemo {
     public static void main(String[] args){
         for(int sum=0,i=0;i<101;i++){
             if(i%2==0){
                 sum+=i;
             }else {
                 continue;
            }
             if(i==100){
                 System.out.println("0~100内偶数之和是"+sum);
            }
        }
    }
}

public class CatchBird {
     public static void main(String[] args){
         String[] birdArray=new String[]{"麻雀","鸽子","百灵","布谷","老鹰","鹦鹉","老鹰","翠鸟","斑鸠","老鹰","黄鹂"};
         int laoYingNumber=0;
         for(String birdString:birdArray){
             if(birdString.equals("老鹰")){
                 System.out.println("一只老鹰已经被我抓起来了");
                 laoYingNumber++;
                 continue;
            }
             System.out.println("发现了一只"+birdString);     //这里当然也可以用if-else
        }
         System.out.println("总共抓住了"+laoYingNumber+"只老鹰");
    }
}


//计算1+1/2!+1/3!+...+1/20!的值
public class x1 {
     public static void main(String[] args){
         double sum=0;
         long a=1L;
         for(long i=1L;i<21;i++){
             for(long j=1L;j<=i;j++){
                 a=a*j;              
             }
             sum+=1/(double)a;          //强制浮点运算
             a=(long)1;                 //重置为长整型数值12             System.out.println(sum);
         }
     }
}

第5章 数组

一、一维数组

1、创建

一维数组实质上是一组相同类型数据的集合，在Java中数组不属于数据类型，而是一种对象。 数组的两种声明方式：

int[] arr1;
int arr2[];

数组声明之后，在使用之前还需要先分配内存空间：

arr1=new int[3];  //数组元素个数为3，即长度为3；arr2=new int[2];

声明和分配空间也可以一并操作：

int arr1[]=new int[3];
int arr2[]=new int[2];

元素赋值的两种方法：

arr1[]=new int[]{1,2,3};
arr2[]={4,5};


//找出一维数组中的最小值元素
public class ArrayMinNum {
   public static void main(String[] args){   
     int arr[]=new int[]{12,398,25,1024,414,1973,2,520,1013};
     int tempMin=arr[0];       //最小值暂存器,初始值为第一个元素值
     int markNumber=1;    //位置标识符
     for(int j=1;j<arr.length;j++){
         if(tempMin>arr[j]){
             tempMin=arr[j];
             markNumber=j+1;
         }
     }
     System.out.println("数组arr中最小值是"+tempMin+";是数组中第"+markNumber+"个元素");
   }
}

二、二维数组
二维数组中各元素实际上是一维数组，创建、分配空间及赋值类似：

int arr[][];                    //声明创建
arr=new int[2][3]               //分配2*3个元素空间
arr={{1,2,3},{4,5,6}};              //赋值
int arrx[][]=new int[][]{{1,2},{3,4},{5,6}};  //创建+分配+赋值

//对一个二维数组进行转置操作
public class ArraySwap {
     public static void main(String[] args) {
         int arr1[][]=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
         int arr2[][]=new int[3][3];
         for(int i=0;i<arr1.length;i++){
             for(int j=0;j<arr1[i].length;j++){
                 arr2[j][i]=arr1[i][j];
            }
        }
         for(int i=0;i<arr1.length;i++){
             for(int j=0;j<arr1[i].length;j++){
                 System.out.print(arr1[i][j]+"  ");
            }
             System.out.println("");
        }
         for(int i=0;i<arr2.length;i++){
             for(int j=0;j<arr2[i].length;j++){
                 System.out.print(arr2[i][j]+"  ");
            }
             System.out.println("");
        }
    }
}

三、数组的基本操作
1、通过for方法的遍历元素

//1、二维数组的元素遍历输出
public class ArrayTrap {
    public static void main(String[] args){
        int arr[][]=new int[][]{{1,3,5,7},{2,4,6},{0,10}};
        System.out.println(
        System.out.println("for循环常规方法：");
        for(int i=0;i<arr.length;i++){
           for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]
                System.out.print(arr[i][j]+"  ");
            }
            System.out.println("");
        }
        System.out.println("foreach方法：");
        for(int arrx[]:arr){
            for(int a:arrx){
                System.out.print(a
                System.out.print(a+"  ");
            }
            System.out.println("");
        }
    }
}

2、填充替换数组元素
（1）fill(int[] a,int value)方法：将value的值赋给数组a中每一个元素，该方法的返回值为更改后的数组a。

（2）fill(int[] a,int fromIndex,int toIndex,int value):将value的值赋给数组a中的元素，范围从索引为fromIndex的元素开始，到索引为toIndex的元素结束不包括该元素,该方法的返回值为更改后的数组a。

//将数组中部分元素更改值
import java.util.Arrays;
public class ArrayDisplace {
     public static void main(String[] args){
         int arr[]=new int[]{13,8,9,520,14,4,24,27};
         System.out.println("填充前数组为：");
         for(int x:arr){
             System.out.print(x+" ");
        }
         Arrays.fill(arr,1,4,520);
         System.out.println("填充后数组为：");
         for(int x:arr){
             System.out.print(x+" ");
        }
    }
}


3、复制数组

（1）copyOf(arr,int newlength):arr是要进行复制的数组。newlength用于指定赋值后新数组的长度，如该长度大于arr长度，则其余用0填充（整型数组）或null（char型数组）。如果newlength小于arr长度，则按newlength截取。返回值为复制后的新数组。


（2）copyOfRange(arr,int fromIndex,int toIndex)：复制范围从索引为fromIndex的元素开始，到索引为toIndex的元素结束不包括该元素,该方法的返回值为复制后的新数组。



四、实例



//用冒泡法从小到大排序数组元素
public class BubbleSortArray {
     public static void main(String[] args){
         int ourArray[]=new int[]{1973,10,1013,24,414,4,1980,520,13,19999};
         int temp;
         System.out.println("排序前：");
         for(int x:ourArray){
             System.out.print(x+" ");
        }
         for(int i=1;i<ourArray.length;i++){
             for(int j=0;j<ourArray.length-i;j++){
                 if(ourArray[j]>ourArray[j+1]){
                     temp=ourArray[j+1];
                     ourArray[j+1]=ourArray[j];
                     ourArray[j]=temp;
                }
            }
        }
         System.out.println("排序后：");
         for(int x:ourArray){
             System.out.print(x+" ");
        }
    }
}

//创建一个int型二维数组，求各元素之和并打印
public class ArraySum {
     public static void main(String[] args){
         int arr[][]=new int[][]{{13,414,73},{10,24,80},{2012,10,13},{520,13,14}};
         int sum=0;
         for(int a[]:arr){
             for(int x:a){
                 sum+=x;
            }
        }
         System.out.println("二维数组arr各元素总和为"+sum);
    }
13 }
以上

哇，这么多，我就问，上面的你都会了嘛？