黑马程序员——Java基础概述

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

 

一、java概述：

1991年Sun公司的James Gosling等人开始开发名称为Oak的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器，1994年将Oak语言更名为Java。

Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。是一门简单易学，完全面向对象，安全可靠，与平台无关的编程语言。

1、Java的三种技术架构:

J2EE(Java 2 Platform EnterpriseEdition)企业版

开发企业环境下的应用程序，主要针对web程序开发；

J2SE（Java 2 Platform Standard Edition）标准版

完成桌面应用程序的开发，是其它两者的基础；

J2ME(Java 2 Platform MicroEdition)小型版

开发电子消费产品和嵌入式设备，如手机中的程序；

2、JDK、JRE和JVM

JDK：是Java Development Kit的简称，java的开发和运行环境，包含了java的开发工具和jre。

JRE：是Java Runtime Environment的简称，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

JVM：是JavaVirtual Machine 的简称，也称作虚拟机。它是运行所有Java程序的抽象计算机, JVM读取并处理编译过的与平台无关的字节码(class)文件。

Java编译器针对JVM产生class文件，因此是独立于平台的。

Java解释器负责将JVM的代码在特定的平台上运行。

Java虚拟机是不跨平台的.

 

3、配置环境变量：

让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

1）环境变量的配置：

  永久配置方式：JAVA_HOME=%安装路径%\Java\jdk

                  path=%JAVA_HOME%\bin

    临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin

特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。

2）classpath的配置:

  永久配置方式：classpath=.;c:\;e:\

临时配置方式：set classpath=.;c:\;e:\

 

注意：在定义classpath环境变量时，需要注意的情况

1、如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；

2、如果指定了classpath，那么会在指定的目录下查找要运行的类文件。并且：

1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。

2）：如果classpath的值结尾处没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。

一般情况下不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。

 

二、java语法基础：

关键字：其实就是某种语言赋予了特殊含义的单词。

保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。

 

1、Java标示符：

可简单理解为在Java程序中为了增强阅读性自定义的名称。比如：类名，方法变量名等。

命名规则：

(1)由字母、数字、下划线、$组成，不能以数字开头

注意:此处的字母还可以是中文,日文等;

(2)大小写敏感

(3)不得使用java中的关键字和保留字

(4)别用Java API里面的类名作为自己的类名。

2、Java中的常量与变量

1）常量：是在程序中的不会变化的数据。

2）变量：其实就是内存中的一个存储空间，用于存储常量数据。

作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。

特点：变量空间可以重复使用。 

3、数据类型：

1）：基本数据类型：byte、short、int、long、float、double、char、boolean 

2）：引用数据类型: 数组、类、接口。

级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double

自动类型转换：从低级别到高级别，系统自动转的；

强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

 

4、运算符号：

1）算术运算符：+ - * / 

%:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。

+:连接符。

++,--自增，自减

2）赋值运算符。

=  += -= *= /= %=

3）比较运算符。

特点：该运算符的特点是：运算完的结果，要么是true，要么是false。 

4）逻辑运算符。

&  |  ^  !   &&   ||

逻辑运算符除了! 外都是用于连接两个boolean类型表达式。

&: 只有两边都为true结果是true。否则就是false。

|:只要两边都为false结果是false，否则就是true

^:异或：和或有点不一样。两边结果一样，就为false，两边结果不一样，就为true.

 

& 和 &&区别：&无论左边结果是什么，右边都参与运算。

                  &&:短路与，如果左边为false，那么右边不参数与运算。

| 和|| 区别： | 两边都运算。

||短路或，如果左边为true，那么右边不参与运算。

5）位运算符:用于操作二进制位的运算符。

&  |  ^ 

<<  >>   >>>(无符号右移)

5、程序控制语句。

1）if语句:

基本语法:if(表达式){方法体}else if(表达式){方法体}else(方法体)

几种形式:

三种格式：

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

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

if(条件表达式){执行语句；}else if (条件表达式){执行语句；}……else{执行语句；}

 

public class If3

{

    publicstatic void main(String args[])

    {

        inti = 3;

        if(i > 5)

        {

            System.out.println("变量i大于5");

        }

        elseif (i > 4)

        {

            System.out.println("变量i小于4");

        }

        else

        {

            System.out.println("其他");

        }

    }

}

 

2）switch控制语句

格式：

switch(表达式)

{

    case表达式可能的结果值1:

            执行语句；

    break；

    case表达式可能的结果值2:

            执行语句；

    break；

        ...

    default:

            执行语句；

    break；//最后这个一般不写

}

备注：

case之间与default没有顺序。先执行第一个case，都没有匹配的case值执行default。

结束switch语句的两种情况：遇到break，switch语句执行结束。

如果匹配的case或者default没有对应的break，那么程序会从第一次匹配的case语句开始继续向下执行，运行可以执行的语句，直到遇到break或者switch结束为止。

class switch2

{

    publicstatic void main(String[] args)

    {

        inta = 7,b = 5;

        switch(a-b)

        {

            case3://表达式可能的值；

            {

                System.out.println("33!");

            }

            break;

 

            case4:

            {

                System.out.println("44!");

                }

                break;

                default://都没有执行则执行该语句!

                    System.out.println("其它的");

 

        }

    }

}

6、循环结构

1）while语句

格式：

while(条件表达式值为true)

{

    执行语句；

}

 

2）do while语句

格式：

do

{

    执行语句；

}

while(条件表达式值为true);

 

3）for语句

格式：

for(初始化表达式（1）；循环条件表达式（2）；循环后的操作表达式（3）)

{

                   执行语句；（4）

}

         执行顺序：(1) →(2) → (4) → (3) → (2) → (4) → (3)

 

7、函数：

1）函数也称为方法，为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数有以下功能：

结构化代码

将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。
    减少代码重复

一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。

 

2）java中的函数的定义格式：

[修饰符] 返回值类型 方法名([参数类型 形式参数1，参数类型 形式参数2，……])

{  

    执行语句;   [return 返回值;]//需要的话

}

 

参数列表（参数的类型，参数的个数，参数的顺序）

当函数没有具体的返回值时，返回的返回值类型用void关键字表示。

如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。

return的作用：结束函数。结束功能。

 

3）函数的重载的

定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。

如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。

 

8、数组：

1）数组(Array)是Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化代码的书写。

数组的好处：数组里的每个元素都有编号，编号从0开始，并且依次递增，方便操作这些元素；

使用Java数组：必须先声明数组，再给该数组分配内存；

数组对应在内存中一段连续空间。

数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。

2）数组的声明

一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；

一维数组的声明方式：

        type varName[]; 或 type[] varName;(推荐)

3）数组初始化：

Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；

数组初始化的两种方式：

静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；

格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};

简化语法：数组名 = {元素1,元素2,元素3...元素n};

动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；

格式：数组名 = new 数组类型[数组长度];

4）二维数组

二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),

可以看做是一张表格。

二维数组的声明方式：

typevarName[][]; 或 type[][] varName;(推荐)

动态初始化

int[ ][ ]  arr = newint[3][2];

定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素

静态初始化

int[ ][ ]  arr = new int[][]{{1,2},{3,4},{5,6}};

int[ ][ ]  arr ={{1,2},{3,4},{5,6}};

9、排序算法

1）选择排序：

//选择排序

//对给定数组进行排序

//｛5，1，6，4，2，8，9｝从小到大

class  Shuzu2

{

         //定义一个函数，让一个数组的0角标位与后面的元素依次比较

         //若0角标的元素小，则两元素不变，否则两元素对换

         public static int[] paiXu(int [] Shuzu)

         {

                   //用一个外循环控制每次用哪个角标与后面的元素进行比较

                   for (intb=0;b<Shuzu.length ;b++ )

                   {

                            //用一个内循环使选定的元素与它后面的每个元素进行比较换位

                            for (inta=b+1;a<Shuzu.length ;a++ )

                            {

                                     if(Shuzu[b]>Shuzu[a])

                                     {

                                               //元素对换语句

                                               intx=Shuzu[b];

                                               Shuzu[b]=Shuzu[a];

                                               Shuzu[a]=x;

                                     }

                            }

                   }

                   return Shuzu;

         }

         public static void main(String[] args)

         {

                   int [] Shuzu=new int[]{5,1,6,4,2,8,52,51,23,7,11,26,9};

                   arrayPos(Shuzu);

                   arrayPos(paiXu(Shuzu));//打印排序后的数组数组

         }

         //定义一个打印数组的方法

         public static void arrayPos(int [] al)

         {

                   System.out.print("[");

                   for(intx=0;x<al.length;x++)

                   {

                            if (x!=al.length-1)

                                     System.out.print(al[x]+",");

            else

                                     System.out.println(al[x]+"]");

                   }

         }

}

2）冒泡排序

/*

1、从头开始每相邻两个比较一次，大的往后拿

3  5 1  4  9 8  6  2

3跟5比，5大，位置不变

5跟1比，5大，对换--- 3  1 5  4  9 8  6  2

5跟4比，5大，对换--- 3  1 4  5  9 8  6  2

5跟9比，9大，不变--- 3  1 4  5  9 8  6  2

9跟8比，9大，对换---

  .

  .

  .  3  1  4 5  8  6 2  9

一次遍历后，最大值在最右边

2、再次从头开始比较，但是最后一位不用在比较了，因为是最大值了

3、以此类推，需要比较的数一次比一次少

*/

 

class  Maopao

{

    public static void maoPao(int[]Shuzu)

    {

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

        {

            for(inty=0;y<Shuzu.length-x-1;y++)

                //-x:让每一次比较的元素减少，-1：避免角标越界

            if (Shuzu[y]>Shuzu[y+1])

            {

                int temp =Shuzu[y];

                Shuzu[y]=Shuzu[y+1];

                Shuzu[y+1]=temp;

            }

        }

    }

    public static void main(String[] args)

    {

        int [] Shuzu = new int[]{5,1,6,4,2,8,9};

 

        dayinShuzu(Shuzu);//打印排序前的数组

 

        maoPao(Shuzu);//排序操作

 

        dayinShuzu(Shuzu);//打印排序后的数组

    }

 

//定义一个打印数组的方法

    public static void dayinShuzu(int [] Shuzu)

    {

        System.out.print("[");

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

        {

            if (x!=Shuzu.length-1)

                System.out.print(Shuzu[x]+",");

            else

                System.out.println(Shuzu[x]+"]");          

        }

    return;

    }

}

3）快速排序

classQuickSort

{

    public static void main(String[] args)

    {

        int [] x = newint[]{16,54,5,61,12,31,25,11,76,22,10};

       

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

            {

            System.out.print(x[i]+"");

            }

            System.out.println();

       

        quickSort(x,0,x.length-1);

       

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

            {

                System.out.print(x[i]+"");

            }

    }

    private static void quickSort(int[] arr, intleft, int right) {

                int l,r; //左右哨兵，l为左哨兵位置，r为右哨兵位置

                int baseNum; //存储基准数

               

                if(left > right)

                        return;

                

                baseNum = arr[left]; //第一次基准数默认为数组首位

                l = left;  //左哨兵从左边出发扫描

                r = right; //右哨兵从右边出发扫描

                while(l != r) {

                        //先从右边开始往左扫描,找到第一个比基准数小的

                        while(arr[r] >= baseNum&& l < r)

                                r--;

                        //再从左边开始往右扫描,找到第一个比基准数大的

                        while(arr[l] <=baseNum && l < r)

                                l++;

                        //交换两个数位置

                        if(l < r) {

                                int temp =arr[l];

                                arr[l] =arr[r];

                                arr[r] = temp;

                        }

                }

               

                //基准数归位

                arr[left] = arr[l];

                arr[l] = baseNum;

       

                //递归处理左边

                quickSort(arr, left, l - 1);

                //递归处理右边

                quickSort(arr, l + 1, right);

        }

}