Java 入门知识学习笔记 (上)

第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 }