黑马程序员_java编程基础

------- android培训、java培训、期待与您交流！ ----------java开发环境

        java编译运行过程：
        程序员编写的java源文件（.java)首先要经过编译，生成所谓的字节码文件（.class)。Java程序的运行需要JVM的支持，而不同的操作系统有不同的JVM，所以java源文件只要一次编译，就可以在不同的操作系统中执行。
        配置环境变量：
        在机器装好JDK之后，需要配置环境变量，才能让java文件在当前的操作系统中执行。通常情况下我们需要配置两个属性。变量名：JAVA_HOME，把它的变量值编辑为当前JKD的安装目录。变量名Path,在它的变量值的前面加上当前目录下的java可执行文件的路径或者%JAVA_HOME%\bin，以英文输入状态下的“;”结束。
        第一个程序HelloWorld:
        此程序的效果是在控制台输出一条语句：HelloWorld
        public class HelloWorld{
                public static void main(String [] args){
                        System.out.println("HelloWorld");
               }
        }
        变量：
        变量就是指代在内存中开辟的存储空间，用于存放运算过程中需要用到的数据。在java中，要使用一个变量，必须先声明并赋值，否则不能使用。
        变量的命名规范：
        1.可以由字母、数字、“_”、“$”组成；
        2.首字母不能以数字开头；
        3.Java严格区分大小写；
        4.不能使用java的保留字（一些java语言规定好的，有特殊含义的字符）；
        5.可以使用中文作为变量名，但不提倡使用；
        6.建议“见名知意”；

        7.命名采用“驼峰命名法”。当一个变量由多个单词组成时，第一个单词的首字母小写，其余单词的首字母要大写。

        JAVA基本类型:
        8种基本数据类型:
        类型名称               字节空间
        byte                         1字节（8位）
         short                        2字节（16位）
         int                            4字节 （32位）
         long                         8字节 （64位）
         float                         4字节（32位）
         double                    8字节（64位）
         char                        2字节（16位）
         boolean                   1字节（8位）


        int类型:
        int是最常用的整数类型。它的表示范围是：-2^31到2^31-1,即从-2147483648到2147483647.在java中，默认的一个整数就是int类型的。如果一个整数直接量的值超过了int的范围，则会报错 。
        int类型在运算时要注意：
        1.在java中，两个整数相除，结果还是整数。会把小数位自动舍弃；
        2.在两个整数作运算的时候，其结果可能会超出int的范围而溢出，正数有可能溢出变为负数，负数也有可以溢出变为正数。所以在java中要避免这种情况的发生。

        long类型：

        在表示整数时，如果int类型的范围不够，可以使用long类型。long类型的表示范围是从12^63到2^63-1。

        当一个数要用long类型来表示时，要以L或l结尾。

        例如：long a=1000000000000L;

                   long b=1234567891011l;

        当一些数参与运算时，如果结果超过了int的范围，那么必须把其中的一个数标记为

long类型，这样运算的结果才是long类型。

        使用double进行浮点数的运算

        浮点数，就是小数。double类型的精度值是float类型的两倍，所以double也叫双精

度小数。一个小数的直接量就是double类型。double运算时会出现舍入误差，不适

合有些要求精确运算的场合。

         char类型

        char是字符类型，其实是一个16位无符号整数 ，这个值是对应字符的编码。它的表示形式如下 ：

        char a='中';

        char b='\u4e2d';

        还可以用一个整数直接量来表示。表示范围从0到65535，其实它表示的是该

整数编码对应的字符。如：

        char c=65;

        转义字符:

        在java中，一些不方便输出的字符可以用转义字符来表示，例如 ：

        '\n'表示回车符

        '\r'表示换行符

        '\\'表示反斜杠

        '\''表示单引号

        '\"'表示双引号

        boolean类型

        boolean类型用于逻辑运算。只有两个值true和false,true表示条件成立，false

表示条件不成立。例如：

        boolean a=3>2;

        System.out.println(a);//此时打印的结果为true;

        boolean b=3<2;

        System.out.println(b);//此时打印的结果为false；

        基本类型间相互转换：

        类型按照从小到大的顺序为：

        byte--short(char)--int --long --float--double

        自动类型转换：

        当一个数从小类型转到大类型时可以自动转换。

        强制类型转换：

        当一个数从大类型向小类型转换时要做强制转换：（要转换成的类型）变量。

但是强制转换时有可能 会造成精确度损失或者溢出。

        例如： long a=1024*1024*1024*4;

        int b=(int)a;//此时会溢出 ，结果为0；

        double d=3.141592653;

        float e=(float)d;//此时会产生精度损失，结果为3.1415927

        运算符和表达式：

        +、-、*、/、%、++、--。

        %运算符：

        %运算符用于对一个数取余。例如：

        8%3=2；

        ++、--运算符：

        这两个运算符是对数进行自增或自减的运算。区别：

        1.当++、--写在变量前时表示使用这个变量之前先加1或减1；

        2.当++、--写在变量之后时表示这个变量使用之后再加1或减1；

        关系运算：

        关系运算符包括：

        大于（>)、小于(<)、大于等于(>=)、小于等于（<=)、等于（==）、不等于（！=）共六个运算符。关系运算符的结果为boolean类型，成立时为true,不成立时false。

        逻辑运算：

        逻辑运算是建立在关系运算之上的。包括：

        与（&&）、或（｜｜）和非（！）。逻辑运算的规则如下表：

变量b1变量b2b1&&b2b1||b2!b1falsefalsefalsefalse truefalsetruefalsetrue
truefalsefalsetruefalsetruetruetruetrue

        短路逻辑：

        对于"&&",当第一个操作数为false时，将不会判断第二个操作数。因为此时无

论第二个数为何，最后的运算结果一定是false.所以"&&"也叫短路与。

对于"||",当第一个操作数为true时，将不会判断第二个操作数，因为此时无论

第二个操作数为何，最后的结果都是true.所以"||"也叫做短路或。

        运算符和表达式：

        使用"="可以对一个变量进行赋值。

        扩展赋值表达式：

        +=、-=、*=、/=.定义一个int数int a=10，如下表：

运算符表达式计算结果+=a +=5a=a+515-=a -=5a=a-55*=a *=5a=a*550/=a /=5a=a/52%=a %=5a=a%50

        字符串连接运算：

        “+”可以实现字符串的连接。例如：

         int a =15;

        String s="a="+a;

        System.out.pritnln(s);//打印结果为：a=15;

        三目运算符：

        boolean表达式？表达式1：表达式2.  意思为：

        判断boolean表达式是否为true,为true,则整个语句的值为表达式1，否则为表达式2.

        分支结构：

        程序可以在运行过程中，根据不同的条件运行不同的语句。这就是分支结构。

        表达式有：

        第1种：if(表达式）｛

                               语句1

                      }

        当if的括号中的语句成立时，则会执行语句1.

        第二种：

                if(表达式1）｛

                        语句2

                ｝else{

                        语句3

                 ｝

                当表达式1成立时，执行语句2，否则执行语句3.

        第三种：

                if(表达式1）｛

                        语句1

                ｝ else if(表达式2）｛

                        语句2

                ｝else if(表达式3）｛

                        语句3

                ｝

                ......

                else{

                        语句4

                ｝

        从上到下，若表达式1成立，则执行语句1，若表达式2成立 ，则执行表

表达式2，依次判断每个表达式，当判断到有一个表达式成立时，其它的

语句就不会执行。

        分支的特点就是：当有一个表达式成立时，就不会走之后的语句。即所谓只走一条

路。

        switch-case语句 ：

                stitch(整型表达式）｛

                        case 整型常量值1：

                        语句 1；

                        break;

                         case 整型常量值2：

                        语句2；

                        break;

                        case 整型常量值3：

                        语句3；

                        break;

                        default:

                        语句4；

                ｝

       当整型表达式的值为整型常量值1时，就会执行语句1，遇到break则会跳出，不再

往下判断。当整型表达式的值为整型常量值2时，就会执行语句2.依次判断。如果

每一个整型常量值都和整型表达式不相等。那么就会执行最后的语句 4.

        switch-case的优势：

                1.switch-case常常和break语句结合使用实现分支的功能；

                2.switch-case在实现分支功能时和if-else的主要区别在于switch-case 结构的

效率要高，结构更加清晰.

        循环结构：

                循环是程序设计中反复执行某些代码的一种计算机处理过程，是一组相同或相似语句有规律的重复性执行。

        循环的三要素 ：

        1.循环初始化；

        2.循环体;

        3.循环条件。

        while语句：

                while(boolean表达式1）｛

                        语句块1

                }

        计算表达式1的结果，如果为true,则语句块1会一直执行。如果在语句块中加了

break,当执行到break时，便会跳出循环。

         do-while语句：

                do{

                        语句块1

                ｝while(boolean表达式1）；

          语句块1先执行一次，判断表达式1是否成立，为true则继续执行语句块1，一直循

环，直到表达式1为false才停止循环。

        while与do-while的区别：

                1.while是先判断再执行；

                 2.do-whiel是先执行一次再判断；

                 3.当循环的条件不成立时， while中的语句不会执行，而do-while在任何情况

下至少都会执行一次。

        while和do-while语句的不同仅仅会体现在第一次就不满足条件的循环中，如果不是

这样的情况，while和do-while可以互换。

        for循环：

                for(表达式1；表达式2；表达式3）｛

                        语句块4

        }

        计算表达式1的值，再计算表达式2的值，若为trur,则执行语句块4，最后执行表达

式3，再判断表达式2，为true则执行语句块4，再执行表达式3.如此2、4、3、2、4

、3循环，直到表达式2为false时停止循环。

        在 for循环的语句块中可以使用break跳出循环。还可以使用coutinue用于跳过之后

的语句执行下一次的循环。

        数组：

                相同的数据类型组成的集合就叫数组。如：

                        int []    arr =new int[8];

                意思为：定义一个int类型的数组arr,它包括8个int类型的元素。

        数组的初始化:

        三种方式 ：

                第一种：int []  arr= {2,3,5,8,4};

                第二种:

                        int arr;

                        arr={10,20,85,10};

                第三种：

                        int arr;

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

        获取数组的长度：

                数组变量名.length;

        可以通过下标访问元素：

                数组的下标从0开始。当访问数组的下标不在时，程序会报ArrayIndexOutOfBoundsException异常。

        遍历数组元素：

                正序输出：

                        int arr={1,3,5,7,9,25,3,6};

                        for(int a=0;a<arr.length;a++}{

                                System.out.println(arr[a]);

                        }

                倒序输出 ：

                        int arr={1,3,5,7,9,25,3,6};

                        for(int a=arr.length-1;a>=0;a--}{

                                System.out.println(arr[a]);

                        ｝

        数组的复制：

                1.System.arraycopy(源数组，源数组的起始位置，目标数组，目标数组的起始位置

        ，要复制的元素的个数）；

                2.类型 [] newArray=Arrays.copyOf(源数组，要复制的长度len);

        这种情况下，当len小于源数组的长度，由会进行截取。当len大于源数组

        的长度时，则会把多余的元素填充为默认的0）；

        数组的扩容：

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

                a=Arrays.copyOf(a,a.length+1);

        以上这句语句将数组a扩容1，新增的最后一个元素为默认值0。

        数组的排序：

                数组的排序就是将数组中的元素按照从小到大或者从大到小的顺序重新排列。

        数组冒泡排序算法：

                原则：比较两个相邻的元素，如果违反最后的顺序准则，则次的两个元素的位置。

        这样一直比下去，最后数组中的元素就会按照定好的规则来排序。

        工具类快速排序：

                Arrays.sort(数组）；

        这样就会把一个数组中的元素按照从小到大的顺序排列起来。

        方法：

                方法是用于封装一段特定的逻辑功能 。如：执行计算或操作。

                使用方法的好处：

                        1.可以在程序中反复调用 ；

                        2.方法可以减少代码重复，便于程序的维护 。

                方法的5要素：

             public static int method(int one ,int two){

                方法体

                ｝

                public static 是修饰词，int 是返回值类型，method是方法名，括号中的int

        one 和int two是参数列表，而在花括号中的为方法体。

        方法的调用 

                在主方法或其它方法中都可以调用方法：

                        1.调用没有参数列表的方法:方法名（）；

                        2.调用有参数列表的方法时，括号中要传进相关的参数。如：

                              method(1,23);

                               method(12,"abc");

        3.调用有返回值类型的方法时：

                返回值类型 变量名=方法名（参数1，参数2）；

        案例1：

       案例2：

------- android培训、java培训、期待与您交流！ ----------

更多详情请点击：http://www.itheima.com