黑马程序员--Java基础

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

Java

概述

Java是Sun(Stanford University Network)公司开发出来的一套编程语言，主设计者是詹姆斯·高斯林James Gosling，最大的特点就是跨平台运行。

分类

• J2SE(Java 2 Platform Standard Edition)标准版
• J2ME(Java 2 Platform Micro Edition)小型版
• J2EE(Java 2 Platform Enterprise Edition)企业版

Java的开发环境主要使用JDK(Java Development ToolKit-Java开发程序包)，JDK是Java的核心，包含JRE(Java Runtime Envirnment-Java运行环境)，而JVM(Java Virtual Mechinal-Java虚拟机)又是JRE中的一部分，实现可移植性靠的是JVM。

三者间的关系
JDK：JRE+工具
JRE：JVM+类库

JDK的下载和安装

下载网址：www.oracle.com
安装方式：傻瓜式安装，下一步即可。

配置环境变量

• 作用

通过配置path环境变量，将javac指令所在目录也就是JDK安装目录下的bin目录配置到path变量下，即可使javac指令在任意目录下运行

• 步骤

1.进入“我的电脑”中“属性”里面的“高级系统设置”选择“环境变量”，在系统变量中新建变量名称为JAVA_HOME，变量值为jdk的安装目录。

2.配置path，一定要保留原先的path变量，在原先的基础上用”;”分隔开来，在最前面添加%JAVA_HOME%\bin，代表bin目录的路径。

3.保存好以后运行命令提示符，输入命令“javac”出现帮助说明就证明配置正确。

classpath默认当前运行路径，在系统变量中配置classpath，配置的路径为*.class放置的文件夹的路径，配置完成以后，无论java命令在任何位置执行，都会从classpath路径中查找文件。

临时设置classpath路径方法：set classpath=“路径”，只作用于当前运行的这个命令提示符窗口，窗口关掉以后失效。

Java的基础知识

• Java语言基础组成

1.关键字
被java赋予了特殊含义的单词

2.标识符
在程序中自定义的一些名称
由26个大小写，数字 _ $组成
数字不能开头 关键字不能开头 严格区分大小写
规范：
包名：所有字母都小写 xxxyyyzzz
类名接口名：所有首字母大写 XxxYyyZzz
常量名：所有字母大写，多个单词的话用下划线连接 XXX_YYY_ZZZ
变量名和函数名： 第一个单词全小写，后面的所有单词首字母大写 xxxYyyZzz

3.注释
顾名思义，就是对Java语句做说明的语句
// 单行注释
/* */ 多行注释
/* / 文档注释

4.常量
表示程序运行时，数值不能改变的量

字面值常量：整数、小数、字符、字符串、布尔、null
自定义常量：类、接口、数组

5.变量
变量是内存中的一个存储空间，在程序运行过程中，其值在指定范围内可以改变的量。

变量的定义格式：
数据类型 变量名 = 初始化值;
例如：int i = 123;

6.进制
表现形式

• 二进制
  由0和1组成，8个单位是1个字节 1个字节最大值是255，计算机采用此进制
• 八进制
  0-7，满8进1，用0开头
• 十进制
  0-9，满10进1
• 十六进制
  0-9，A-F，满16进1，用0x开头

负数的二进制表现形式
-6：6的二进制取反+1 取反：将二进制的1变成0.0变成1

进制间的转换
十转二：对十进制数进行除2运算。没有余数为0 有余数为1。计算结果从右往左写。
例如，6的二进制表现形式为110。6除以2等于3，无余数得0。3除以2等于1，余数为1 得1。从右往左写就是110

二转十：二进制乘以2的过程。 从右往左运算
例如，110 0*2的0次方+1*2的1次方+1*2的2次方=0+2+4=6

其他进制转16进制：先转化为2进制，再转化为16进制

其他进制转8进制。三位代表一位进行转换

基本数据类型

• byte：字节 8个二进制位 -128~127（-2的7次方~2的7次方减1）
• short：短整型 16个二进制位 -21768~32767（-2的15次方~2的15次方减1）
• int：整型 32个二进制位
• long：长整型 64个二进制位
• float：单精度 32个二进制位
• double：双精度 64个二进制位

• char：字符变量 16个二进制位

  整数默认int
  浮点默认double
  长整数要加L或者l，单精度的浮点数要加F或者f。

  数据间的转换
  自动类型转换
  byte b = 3
  b= b + 2 不能运行
  b占1个字节，2默认int类型占4个字节，不同的数据类型之间不能直接做运算，需要提升b的数值类型（小的向大的提升），运算结果也是4个字节，不能直接赋给b。3本身是整数，但在b的范围内，是个常量，所以可以赋给b。

  强制类型转换
  b = （byte）（b + 2）；
  byte强制转换的是小括号里的内容，不加小括号的话，byte只会转换b，不会转换2，所以还是会报错。

运算符

• 算术运算符

+， - ， *， /
加减乘除就不用说了，大家都懂的~
说点特别的

%（取模即取余数 左边小于右边结果是左边。左边等于右边结果是0。右边是1结果是0。如果出现负数，结果只看被模数即左边）

++：a++ 表示给a进行+1运算，并将运算后的值重新赋给a，不等于a=a+1，因为a+1只进行+1运算，并没有把运算后的值重新赋给a。 b=a++：先将a的值赋给b，再进行自身+1运算。b=++a，先自身+1运算，再将运算后的值赋给b。

+：如果两个字符串之间用加号连接，那现在的加号就是字符串连接符。“He”+“llo”=“Hello” 字符串数据和任何数据使用+相连接，最终都会变成字符串。

\n：换行 \b：退格 \r：按下回车键（Windows系统中，回车符是由两个字符来表示\r \n） \t：制表符，相当于Tab键
给字符加双引号：(“\”Heloo\”“)

• 赋值运算符

  =、+=、-=、*=、/=、%=
  x+=4：把左右两边的和赋给左边 相当于x = x + 4 区别x = x + 4编译失败，因为数据类型不同，不能赋值，x=+4编译成功，因为+=运算符在给x赋值时，会自动完成强行转换动作

• 比较运算符
  ==：相等于
  ！=：不等于
  运算完的结果不是true就是false

• 逻辑运算符
  &：and与
  |：or或
  ^：XOR异或
  !：not非

class OperatorDemo {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        //&逻辑与
        System.out.println((a > b) & (a > c)); //false & false = false
        System.out.println((a > b) & (a < c)); //false & true = false
        System.out.println((a < b) & (a > c)); //true & false = false
        System.out.println((a < b) & (a < c)); //true & true = true
        System.out.println("---------------");

        //|逻辑或
        System.out.println((a > b) | (a > c)); //false | false = false
        System.out.println((a > b) | (a < c)); //false | true = true
        System.out.println((a < b) | (a > c)); //true | false = true
        System.out.println((a < b) | (a < c)); //true | true = true
        System.out.println("---------------");

        //^逻辑异或
        System.out.println((a > b) ^ (a > c)); //false ^ false = false
        System.out.println((a > b) ^ (a < c)); //false ^ true = true
        System.out.println((a < b) ^ (a > c)); //true ^ false = true
        System.out.println((a < b) ^ (a < c)); //true ^ true = false
        System.out.println("---------------");

        //!逻辑非
        System.out.println(!(a > b)); //!false = true
        System.out.println(!(a < b)); //!true = false
        System.out.println(!!(a > b)); //!!false = false
        System.out.println(!!!(a > b)); //!!false = true
    }
}

• 位运算符

<<  左移位
>>  右移位
>>> 无符号右移位
public class OperatorDemo
{
    public static void main (String args [])
    {
        int a = 3 >> 2;
        int b = 3 >> 2;
        int x = -3 >> 2;
        int y = -3 >>> 2;
        System.out.println(a);
        System.out.println(b);
        System.out.println(x);
        System.out.println(y);
    }
}
运行结果为：0 0 -1 1073741823
对于正数来说没有任何区别。
-3的补码进行右移两位运算
11111111-11111111-11111111-11111101
11111111-11111111-11111111-1111111101
右移两位之后加上两位符号位11
-3的补码进行无符号右移两位运算
11111111-11111111-11111111-11111101
00111111-11111111-11111111-1111111101
右移两位之后用00补位

& 按位与
| 按位或
^ 异或（相同为0，相反为1）

• 三元运算符
  格式：（条件表达式）？表达式1：表达式2；
  特点：三个元素参与的运算
  如果条件为true，输出表达式1，条件为false，输出表达式2

class OperatorDemo {
    public static void main(String[] args) {
        int x = 100;
        int y = 200;        
        int z = ((x > y)? x: y);
        System.out.println("z:"+z);
    }
}

流程控制语句句

顺序结构：从上往下，依次执行

class ShunXuJieGouDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        System.out.println("我爱Java");

        System.out.println("程序结束了");
    }
}

选择结构：按照不同的选择，执行不同的代码

• if语句

三种格式

• if（条件表达式）｛执行语句：｝if后面如果没有｛｝，则只执行离他最近的单条语句

• if（条件表达式）｛执行语句：｝else｛执行语句：｝
  if else 结构 简写格式： 变量 = （条件表达式）？表达式1：表达式2
  三元运算符 好处：可以简化if else 代码。 弊端：因为是一个运算符，所以运算完必须要有一个结果

• if（条件表达式）｛执行语句：｝else if（条件表达式）｛执行语句：｝….else｛执行语句：｝ 循环结构：做一些重复的代码

• if语句的注意事项：

A:比较表达式无论简单还是复杂，结果必须是boolean类型
B:if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略。
C:一般来说：有左大括号就没有分号，有分号就没有左大括号

• Switch语句

格式：
switch（表达式）

switch（表达式）
        ｛
            case 取值1：
                    执行语句；
                    break；        
            case 取值2：
                    执行语句；
                    break；
                。。。。
             default：
                执行语句；
                break；
        ｝

格式的解释：
switch:表示这是switch选择结构
表达式:这个地方的取值是有限定的
byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case:后面跟的是要和表达式进行比较的值
语句体:要执行的代码
break:表示中断，结束的意思，可以控制switch语句的结束。
default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。

• switch语句的注意事项：

  A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

  B:default可以省略吗?
  可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
  特殊情况：
  case就可以把值固定。
  A,B,C,D

  C:break可以省略吗?
  可以省略，但是结果可能不是我们想要的。
  会出现一个现象：case穿透。
  最终我们建议不要省略

  D:default一定要在最后吗?
  不是，可以在任意位置。但是建议在最后。

  E:switch语句的结束条件
  a:遇到break就结束了
  b:执行到末尾就结束了

• 循环语句
  for

/*
    for循环格式：
        for(初始化语句;判断条件语句;控制条件语句) {
            循环体语句;
        }
        执行流程：
            A:执行初始化语句
            B:执行判断条件语句,看其返回值是true还是false
                如果是true，就继续执行
                如果是false，就结束循环
            C:执行循环体语句;
            D:执行控制条件语句
            E:回到B继续。

    注意事项：
        A:判断条件语句无论简单还是复杂结果是boolean类型。
        B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
        C:一般来说：有左大括号就没有分号，有分号就没有左大括号

    需求：请在控制台输出10次"HelloWorld"
*/
class ForDemo {
    public static void main(String[] args) {

        for(int x=1;x<=10;x++) {
            System.out.println("HelloWorld");
        }
    }
}

While

/*
    while循环的基本格式：
        while(判断条件语句) {
            循环体语句;
        }

        扩展格式：

        初始化语句;
        while(判断条件语句) {
             循环体语句;
             控制条件语句;
        }

        通过这个格式，我们就可以看到其实和for循环是差不多的。

        for(初始化语句;判断条件语句;控制条件语句) {
            循环体语句;
        }
*/
class WhileDemo {
    public static void main(String[] args) {
        //输出10次"HelloWorld"
        int x=0;
        while(x<10) {
            System.out.println("HelloWorld");
            x++;
        }

    }
}

do…while

/*
    do...while循环的基本格式：
        do {
            循环体语句;
        }while(判断条件语句);

        扩展格式；
        初始化语句;
        do {
            循环体语句;
            控制条件语句;
        }while(判断条件语句);
*/
class DoWhileDemo {
    public static void main(String[] args) {
        //输出10次HelloWorld。
        int x = 0;
        do {
            System.out.println("HelloWorld");
            x++;
        }while(x<10);

        System.out.println("--------------");

        //求和1-100
        int sum = 0;
        int a = 1;
        do {
            sum += a;
            a++;
        }while(a<=100);

        System.out.println(sum);
    }
}

• 控制跳转语句

break：中断的意思，跳出单层循环，用在循环和switch语句中，离开此应用场景无意义。

continue：继续，跳出单层循环的一次，可以继续下一次，用在循环中，离开此应用场景无意义。

return:返回， 用于结束方法的，一旦遇到return,程序就不会在继续往后执行。

方法（函数）

定义：函数就是定义在类中的具有特定功能的一段独立小程序，也称之为方法

格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2….）
{
执行语句；
return 返回值；
}

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

定义方法需要两个明确：
返回值类型：结果的数据类型
参数列表：参数的个数及对应的数据类型

方法重载：
在同一个类中，方法名相同，参数列表不同。与返回值无关。
参数列表不同：参数的个数不同，参数的对应的数据类型不同。

数组

• 一维数组

定义：同一种类型数据的集合。其实数组就是一个容器。

好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式
1.元素类型[] 数组名 = new 元素类型[元素个数或数组长度]；
2.元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
数组中有一个属性可以直接获取到数组元素个数：length

数组的遍历

class ArrayTest {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11,22,33,44,55};

        //获取每一个元素
        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.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
}

• 二维数组

元素是一维数组的数组。

格式1：
数据类型[][] 数组名 = new 数据类型[m][n];

m:表示这个二维数组有多少个一维数组。
n:表示每一个一维数组的元素有多少个。

格式2：
数据类型[][] 数组名 = new 数据类型[m][];

m:表示这个二维数组有多少个一维数组。
列数没有给出，可以动态的给。这一次是一个变化的列数。

格式3：
数据类型[][] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}};
举例：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};

二维数组的遍历

class Array2Test 
{
    public static void main(String[] args) 
    {
        //定义二维数组
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

        //遍历数组
        printArry(arr);
    }


    public static void printArry(int[][] arr)
        {
        for (int x=0;x<arr.length ;x++ )
            {
                for (int y=0;y<arr[x].length ;y++ )
                    {
                        System.out.print(arr[x][y]+" ");
                    }
                System.out.println();
            }   
        }
}

总结

这篇博客主要讲述了Java的基础知识，这都是以后写程序的基石，以后不管学的知识再高深，也都离不开这些。所以，学Java，这些基础必须得深深地印在脑中。

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