JAVA基础（一）

目录

1. 进入cmd终端

2. 编程快捷键

3. Java体系

(1) Java体系平台

(2) JDK、JRE、JVM

 (3) Java API文档 

4. 配置环境

5. 第一次尝试HelloWord

6. 注释的使用

7. 关键字、保留字、标识符

(1) 定义

(2) 命名规范

8. 变量

(1) 变量的声明

(2) 基本变量

(3) 变量运算

 (4) 字符串类型String 

9. 运算符

(1) 算术运算符

(2) 赋值运算符

(3) 比较运算符

(4) 逻辑运算符

(5) 位运算符

 (6) 三元运算符

10. Switch语句

11. 循环结构

 (1) for循环 

(2) while

12. break与continue

13. Scanner语句

14. 数组

(1) 初始化

(2) 初始化元素默认值

(3) 内存解析

15. 二维数组

(1) 初始化

(2) 对二维数组的操作

---

1. 进入cmd终端操作

Win+R，输入cmd，进入

进入D盘：d:（先这样以后，才能cd进入D盘目录下的文件夹）

cd+文件名：进入文件夹

cd java\class1\aaa：进入文件夹

cd.. ：返回上一级

md+文件名：新建文件夹（创建目录）

rd+文件名：删除文件夹（删除目录，目录需为空的）

cd\: 直接回到当前盘

dir：显示当前目录文献

del：删除文件（需加后缀名）

del+目录：删除目录下的所有文件（所以要删除一个有文件的文件夹可以del+rd）

del *.txt：删除所有txt文件（*代替了文件名）

2. 编程快捷键

Ctrl+/  ：注释一整行（再按一次，取消注释）

Ctrl+shift+/  ：多行注释

/**+enter ：注释方法

Ctrl+d ：复制当前行

先选中几行+Ctrl+shift+/  ：多行注释

Alt+insert：创建类的常用方法

Ctrl+shift+f：调格式

shift+enter：直接到下一行

alt+/：提示功能

3. Java体系介绍

(1) Java体系平台

(2) JDK、JRE、JVM

JDK：即Java开发工具包，包含JRE+开发工具（如Javac编译工具等）

JRE：即Java运行环境，包含JVM+Java SE标准库类

JVM：即Java虚拟机，不同系统都有不同的JVM，使得Java能在不同系统上都能运行的原因。

 (3) Java API文档 

API：应用程序编程接口，即Java提供的一系列类库。

API文档：API的说明。

4. 配置JAVA环境

计算机——属性——高级系统设置——环境变量

上面针对当前用户有效，下面针对所有用户有效（即此台计算机）

我们关注path这个环境变量，windows执行命令时，要搜寻的路径。

在终端执行命令时，先看当前路径有没有该文件，没有的话，会再去path里看有没有。即当希望一个东西在任何路径下都能运行时，可以把它的路径Ctrl+C到path变量值下，可以放到最前最后都行，与已有路径用分号隔开。

实际中常用的配置变量方法：

刚才的设置： D:\IDEA\JDK1.8\bin

实际操作：在path上面新建一个变量JAVA_HOME

JAVA_HOME=D:\IDEA\JDK1.8

%JAVA_HOME%\bin （两个百分号表示获取变量的值）

同时最好把这个路径放在path里面的最上头

注：

文件夹——查看（最上面）——选项——查看——隐藏文件扩展名（取消勾选），这样就能改文件后缀了。

在文件夹内，上面的路径框直接输入cmd可直接进到终端，且在该目录下。

5. 第一次尝试HelloWord

.java文件——javac.exe编译——.class文件（字节码文件）——java.exe运行

找个文件夹新建一个txt文件，然后把后缀改成.java，在里面写点程序。

文件夹——查看（最上面）——选项——查看——隐藏文件扩展名（取消勾选），这样就能改文件后缀了。

在终端进入到这个文件所在的地方，打javac HelloWorld.java（中间时空格，后面是文件名）。然后就发现文件夹里多了个.class文件，这个字节码文件名与源文件中的类名相同。

注：这里打HelloWord.java时，不区分大小写，因为windows不区分。不过在写java程序 时，程序的内容需严格区分大小写。

打java HelloXian（注意这里不要有后缀），即运行完程序。

注：

 - 这里打HelloXian时，区分大小写，因为字节码文件是类，回到了java层面。

 - 一个java源文件里可以声明多个class，但最多只能有一个类声明为public的，且只能加到和源文         件名一样的类上。 

 - 程序的入口是main()方法，格式是固定的。

- 输出语句：

        System.out.println(“Hello World!”);  //ln即line，输出后会自动换一行

        System.out.print(“Hello World!”);

- 编译完后，源文件中有多个类时，会生成多个class文件，文件名与类名相同。

6. 注释的使用

(1) 单行注释：//         ctrl + /

(2) 多行注释：/*…..*/    ctrl + shift + /

(3) 文档注释：

作用：文档注释内容可以被JDK所提供的工具javadoc解析，生成一套以网页文件形式体现的该程序的说明文档。

格式：/**

        @auther Huo

        @version v1.0

        This is my code.

        */

解析方式：javadoc –d mydoc –author –version HelloWorld.java

                                  文件夹名                            java文件

          里面会生成很多html文件，打开里面的index.html，就能看到了。

注：这个得写在最上面，写在程序中，就有错误。

7. 关键字、保留字、标识符

(1) 定义

关键字：  定义数据类型、（class、interface、enum、byte、short、int等）

                定义流程控制（if、while、else等）、

                定义访问权限修饰符（private、protected、public）

                等等等。

保留字：现版本未使用，以后可能会作为关键字使用。

标识符：对各种变量、方法、类等要素命名时使用的字符序列，如HelloWorld。凡是可以自                          己起名的地方，都能叫标识符。

(2) 命名规范

包名：多单词组成时所有字母都小写，如xxxyyyzzz；

类名、接口名：多单词组成时，所有单词首字母大写，如XxxYyyZzz；

变量名、方法名：第一个单词首字母小写，后面单词首字母都大写，如xxxYyyZzz;

常量名：所有字母都大写，多单词时用下划线连接，如XXX_YYY_ZZZ。

8. 变量

(1) 变量的声明

 - 光声明，不赋值，用的时候会编译错误（不默认为0）；

 - 变量都定义在作用域内，在作用域内有效，出了作用域无效；

 - 变量分类：

  

(2) 基本变量

①整型变量

类型	存储空间	范围
byte	1字节（8bit）	-128 ~ 127
short	2字节	-215 ~ 215-1
int	4字节	-231 ~ 231-1（约21亿）
long	8字节	-263 ~ 263-1

- 声明long型变量，结尾要以L或小写l结尾，例：long lalala=3431624186L。

②浮点型

类型	存储空间	范围
单精度float	4字节	-3.403E38 ~ 3.403E38
双精度double	8字节	-1.798E308 ~ 1.798E308

- 声明float时，结尾要以F或小写f结尾，例float m=12.3F（double不用加）。

- float比long表示的数范围还大，因为用了一种特殊的存储方式，因此精度不高（精度在 7位有效数字左右），常用double（范围更大、精度更高、还不用写F）。

③字符型

Char m = ‘k’;

 - 用单引号扩起；   

 - 里面只能写一个字符；

 - 也可直接用Unicode值来表示字符型常量，例char m=’\u0043’; 此语句等同于char m=’c’; 因为c       的编码就是这个。

 - 字符集：美国是ASCII码，Unicode、UTF-8包含全世界的语言字符

④布尔类型boolean

 - 只能取True、False。

(3) 变量运算

①自动类型提升

byte、short、int、long、float、double

 - 容量小与容量大的做各种运算时，结果自动提升为容量大的类型

 - float容量大于long（虽然float为4个字节，long为8个字节）

 - byte、short、char这三个之间做运算时，结果都为int

②强制类型转换

自动类型提升运算的逆运算，需使用强转符（）。

例：int i = 128；

byte b = (byte) i;   //会变为-128

注：

• case1:

long 1=123213;

此时定义long末尾未加L，系统不会报错。因为这个数在int的范围内，被自动转为int了。

long l=1231237343819173938;

这样定义时，编译就会报错，需在末尾加上L（所以定义long时最好老老实实加L，免得它自己变成int型到时候再出问题）。

• case2:

byte b=12;

byte b1=b + 1;

这时编译也会报错。之前说byte、short、char这三个之间做运算时，结果都为int。因为两个byte运算时，如126+64很容易超过byte。这里的运算可以看成这样，系统给自动转化成int了，所以用byte定义b1会出错。也可以这么理解：存范围较小的数是用byte，但一旦需要运算，就将结果定义成int。

 (4) 字符串类型String 

①格式：String 变量 = “  ”

②说明：

String属于引用数据类型，声明时使用一对双引号””。

可以和8种基本数据类型做运算（可以和布尔类型做运算），且运算只能是连接运算：+

例：int number = 1001;

      String numberStr = “学号：”;

      String info = numberStr + number;   //连接运算

结果： 学号：1001

练习1：辨别+是运算还是连接

char c = ‘a’;   // a:97  A:65

int num = 10;

String str = “hello”;

System.out.println(c + num + str);  //107hello

System.out.println(c + str + num);  //ahello10

System.out.println(c + (num + str));  //a10hello

System.out.println(str + num + c);  //hello10a

练习2：打印* *（中间是tab）

System.out.println(“*   *”);          //√

System.out.println(‘*’ + ‘\t’ + ‘*’);     //×  前两个加了，93

System.out.println(‘*’ + “\t” + ‘*’);     //√

System.out.println(‘*’ + ‘\t’ + “*”);     //×  前两个加了，51*

System.out.println(‘*’ + (‘\t’ + “*”));    //√

9. 运算符

(1) 算术运算符

①++a与a++

a=2;b=++a;    //先加1，后取值  a=3 b=3

a=2;b=a++;    //先取值，后加1  a=3 b=2

实际使用时，可以先写++a或a++（此时无区别），然后再赋值。

②转换错误

short a=10; a=a+1;

此时会报错，因为a是short型，一加类型就成int了，再赋回去类型就不匹配了。可以这样写：s = (short) (s+1)。

对于加1这种情况可直接用a++，自增一不会改变数据的类型。

③求模时，符号与被模数一样。

(2) 赋值运算符

int num1 = 10;  num1 += 2;   // num1=12

int num2 = 12;  num2 %= 5;   // num2=2

此方式也可避免上一个自己赋值自己改变数据类型的问题（不改变数据类型）。

(3) 比较运算符

输出的是布尔类型，即True、False。

(4) 逻辑运算符

区别：逻辑判断上没有任何区别，区别在于：

Boolean b2 = false;

int num = 10;

if(b2 && (num++ > 0)){

        System.out.println(“lalala”);

}else{

        System.out.println(“hahaha”);

}

这里b2是false，由于用的是&&（短路与），第一步判断了是false，后一步直接跳过，所以输出的num还是10。如果这里用&，则num会执行一步自加一。

开发中推荐使用带短路的，毕竟加可以自己操作。

练习题：

int x=1; int y =1;

if(x++==2 & ++y==2){

        x=7;

}

System.out.println(“x=”+x+”y=”+y);

这里x++==2，是false，先取值，后加加。++y==2是True。

(5) 位运算符

- 位运算符都操作的是整型数据；

- 左移几位，就乘以2的几次方，就能得到移位后的数；

- 左移时，低位补0；右移时，最高位原本是啥就补啥，所以负数还是负数（负数最高位为1）；

- 6取反为7；（视频81）

 (6) 三元运算符

 - 前面表达式得出一个布尔类型，是True执行第一个，False执行第二个；

 - 表达式1和表达式2类型要一致，如一个是数字，另一个是字符，则前面那个没法定义；

 - 获取两个整数中的最大值：

        int m=12;  int n=5;

        int max=(m>n)?m:n;

 - 嵌套使用：

        String max = (m>n)? “m大”：（(m==n)? “m等于n”：“n大”）；

 - 凡是三元运算符，都可以用if-else代替；不过三元运算符效率更高。

 - else可写可不写（之前学python时，知道else其实是有风险的，因为else包括了你规定的以外所     有的，有时会出现难以排查的错误）。

 - if-else只有一行执行语句时，都可以省略大括号，末尾加;

 - if(b=false)  此语句将false赋值给b，然后就是if(b)，判断为false;

10. Switch语句

switch(表达式){

Case 常量1：

        执行语句1；

        //break;

Case 常量2：

        执行语句2；

        //break;

        …

default：

        执行语句；

        //break;

}

①不写break时，判定完后下面的Case都不再判断，直接执行其语句，一直到结束。要想实现多选一的情况，都得加break；

②switch里的表达式只能是byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）；

③Case之后只能声明常量，不能声明范围；default结构可加可不加；

④Switch能用的，if-else都能用。不过Switch效率更高。

11. 循环结构

循环结构4个要素：  初始化条件、循环条件（布尔类型）、循环体、迭代条件。

 (1) for循环 

结构：

        for(;;){

        ...        ；

        }

执行过程：-… 直到条件不满足

例： for(i=0,i<5,i++){  }  

        for(i=5,i>1,i--){  }

练习：

int num=1;

for(System.out.println(‘a’);  num<=3;  System.out.println(‘c’),num++ ){

        System.out.println(‘a’);

}

输出结果：abcbcbc

• 未知循环次数时，可以这么写：for(;;)，最后用break跳出。

(2) while

结构：

        ；

        while(){

                ；

                ；

        }

(3) do-while

结构：

        ；

        do{

                ；

                ；

        }while()

执行过程：… 上来先执行一次，直到条件不满足。

12. break与continue

(1) 不同点

break: 

使用范围：switch-case、循环结构

作用：结束当前循环

continue:

使用范围：循环结构

作用：结束当次循环

(2) 带标签使用时

break label、continue label结束指定标签的循环

比如：

label:for(…){}

13. Scanner语句

调用：

import java.util.Scanner;

Scanner scan = new Scanner(System.in);

int number = scan.nextInt();

14. 数组

(1) 初始化

int[] ids;      //声明

ids = new int[]{1001,1002,1003,1004};  //静态初始化：数组的初始化+元素赋值分开进行

String[] names = new String[5];        //动态初始化：未赋元素初值

names[0] = “霍霍霍”;

names[1] = …

int len = names.length;           //获取数组长度

for(int i=0; i<names.length; i++){  //遍历数组

        System.out.println(names[i]);

}

int[] arr4 = {1,2,3,4,5};     //类型推断：这种初始化方法也可以

(2) 初始化元素默认值

元素为整型：0

元素为浮点型：0.0

元素为字符型：0 或 ‘\u0000’，而不是 ‘0’

元素为布尔型：false

元素为引用数据类型：null，不是 ‘null’  （引用数据类型：数组、String）

（二位数组只初始化第一个参数时，里面默认值为null）

(3) 内存解析

栈：arr

堆：（new出来的都在这）数组的三个元素连续的存在里面，然后将一个16进制的地址值赋给arr，栈空间通过地址值找到堆空间的数组，这样就将二者联系起来了。

15. 二维数组

一个一维数组的元素还是一维数组。

(1) 初始化

① int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};  // 静态初始化

② String[][] arr2 = new String[3][2]; 

     //动态初始化：有三个格子（外部数组），每个格子记录着包含两个元素的数组的地址值

③ String[][] arr3 = new String[3][];                    //可以先只定义前面的，但是不能只定义后面的

④ arr3[1] = new String[4];

(2) 对二维数组的操作

①获取二位数组长度

arr1.length;   // 3，外层数组的长度

arr1[0].length; // 3，内层第一个数组的长度

②遍历二维数组

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

        for(int j=0; j<arr[i].length; j++){

                System.out.print(arr1[i][j] + “  ”);

        }

        System.out.println();    //什么都不打印，相当于换行

}

• 对二维数组的理解

左边是栈，右边是堆。

在作用域内定义的arr，一旦超出作用域，arr就会出栈，失去作用。

③数组的复制

复制时，其实只是把堆空间数组的地址值赋给了array2这个新变量，array1、array2都指向了堆空间这同一个数组，此操作不为数组的复制。

④数组的反转

for(int i=0; i<arr.length/2; i++){

        String temp = arr[i];

        arr[i] = arr[arr.length-i-1];

        arr[arr.length-i-1] = temp;

}

⑤其他注意事项

String[] arr = new String[3][];   System.out.println(arr[3]);   //此时打印null（数组为引用类型）

String[] arr = new String[3][2];   System.out.println(arr[3]); //此时打印一个地址值

int arr[] = new int[5];  //定义一维数组时，[]写在后面也行，类似于C

int arr[][] = new int[4][3];  int[] arr [] = new int[4][3]

 //定义二维数组，[]也可以这样写

int[] x,y[];  //此操作实际上定义了一个一维数组x[]，和一个二维数组y[][]