Java基础_Java语法

Java基础
一、Java语法
(一)Java环境搭建
1.基本常识
软件：软件是一系列按照特定顺序组织的计算机数据和指令的集合。
常见的软件：系统软件(Linux)和应用软件(Google Chrome)。软件的出现实现了人与计算机之间的更好的交互。交互的方式有图形化界面和命令行方式两种。
常见的DOS命令：
dir(directory)->列出当前目录下的文件以及文件夹
md(make directory)->创建目录
del(delete)->删除文件
rd(remove directory)->删除目录
cd(change directory)->进入指定目录
cd..->退回到上一级目录
cd/->退回到根目录
exit->退出dos命令行
注意：在DOS(Disk Operation System)命令行里删除文件夹必须要保证此文件夹是空的。
通过使用DOS命令行，你会发现原来操作计算机就如同和计算机说话一样，我们告诉它做什么，它就可以做什么，前提是，我们和它说的内容它必须识别才可以，这就是计算机语言。
2.Java的跨平台性
跨平台性->通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理->只要在需要运行Java应用程序的操作系统上先安装一个Java虚拟机(Java Virtual Machine)即可，由JVM来负责Java程序在该系统中的运行。
3.Java编程环境搭建
JRE(Java Runtime Environment) ----- Java运行环境，包括Java虚拟机(JVM ----- Java Virtual Machine)和Java程序所需要的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
JDK(Java Development Kit) ----- Java开发工具包
JDK是提供给Java开发人员使用的，其中包含了Java的开发工具包，也包括了JRE。所以安装了JDK，就不用再单独安装JRE了。其中的开发工具：编译工具(javac.exe)、运行工具(java.exe)、打包工具(jar.exe)等。
简单而言：使用JDK开发完成的Java程序，交给JRE去运行(有了JRE只能运行Java程序)。
注意：JDK里面包含了开发工具和JRE，JRE里面包含了虚拟机。
当执行运行命令java时会自动去找JRE里面的虚拟机去执行对应的字节码(*.class)文件。
4.环境变量
在DOS敲入命令时，操作系统会先在当前目录下去查找看是否存在用户所敲入的命令，若不存在，则操作系统又会到环境变量中去查找看所配置的变量对应的目录下是否存在用户所敲入的命令。
配置环境变量的目的是为了更方便应用Java开发工具。
在配置环境变量时需要注意所配置的文件必须是可执行文件。
JAVA_HOME -----> C:\Java\jdk1.7.0_17
PATH -----> %JAVA_HOME%\bin;
CLASSPATH -----> .;%JAVA_HOME%\lib;
<注意>
(1)我们可以将可能变化部分(C:\Java\jdk1.7.0_17)提取出来用一个新的环境变量JAVA_HOME记录下来，这样在PATH中只要获取JAVA_HOME的值就可以了，用%JAVA_HOME%就可以动态地获取某一个已存在的环境变量的值，这样当你修改了环境变量JAVA_HOME的值时并影响环境变量PATH的值。
(2)DOS命令行配置环境变量的方式只在当前窗口有效，如：set PATH=C:\Java\jdk1.7.0_17\bin;
(3)PATH环境变量的特点是先在当前目录下去找，若没有找到再到PATH环境变量下去找。CLASSPATH环境变量的特点是先到CLASSPATH环境变量下去找，若没有找到再到当前目录下去找(CLASSPATH的值结尾处加了分号)。
(4)set CLASSPATH=C:\Java\jdk1.7.0_17\bin与set CLASSPATH=C:\Java\jdk1.7.0_17\bin;的区别在于set CLASSPATH=C:\Java\jdk1.7.0_17\bin;不仅会在环境变量CLASSPATH的值下查(*.class)文件还会在当前目录下查找(*.class)文件。而set CLASSPATH=C:\Java\jdk1.7.0_17\bin只在环境变量CLASSPATH的值下查找(*.class)文件而不在当前目录下查找(*.class)文件。
5.第一个Java程序
主函数的作用是保证这个类的独立运行，原因是因为当执行运行命令java时会去调用JVM，而JVM会去调用Windows底层内容并去运行你指定的类，JVM会先去找类中是否存在public static void main(String[] args)函数。


(二)语法基础
1.基础语法
(1)关键字
关键字：其实就是某一种计算机语言对指定的单词赋予了特殊的含义。
特点：体现上都是英文小写的单词。
(2)标示符
标示符：就是在程序中起的名字。
包含：0-9/A-Z/a-z/_/$
注意：数字不可以开头并且名字不可以使用关键字。
(3)注释
单行注释->//注释的内容
多行注释->/* 注释的内容 */
文档注释->/** 注释的内容 */
作用1->注解、说明、解释源代码。
作用2->用于调试程序。
(注意：多行注释中不可以嵌套多行注释)
(4)Java关键字
用于定义数据类型的关键字：class、interface、byte、short、int、long、float、double、char、boolean、void
用于定义数据类型值的关键字：true、false、null
用于定义流程控制的关键字：if、else、switch、case、default、while、do、for、break、continue、return
用于定义访问权限修饰符的关键字：private、protected、public
用于定义类、函数、变量修饰符的关键字：abstract、final、static、synchronized
用于定义类与类之间关系的关键字：extends、implements
用于定义建立实例及引用实例、判断实例的关键字：new、this、super、instanceof
用于异常处理的关键字：try、catch、finally、throw、throws
用于包的关键字：package、import
其他修饰符关键字：native、strictfp、transient、volatile、assert
(5)Java中的名称规范
包名：多单词组成时，所有字母都小写。
类名或接口名：多单词组成时，所有单词的首字母大写。
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。
常量名：所有字母都大写，多单词组成时，每个单词用下划线连接。
2.进制
(1)进制的由来：任何数据在计算机中都是以二进制的形式存在的。二进制是由开关演变而来的。一个整数在内存中一样也是二进制的，但是使用一大串的1或0组成的数值进行使用很麻烦。所以就想把一大串由1或0组成的数据缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值是7，超过7就进位了，这就是八进制。但是对于过长的二进制变成八进制还是较长，所以出现用二进制中的四位表示一位的情况，由于四个二进制为最大为15，超过15就进位了，这就是十六进制。之所以会出现其它的进制，如八进制(3个二进制表示一位)、十六进制(4个二进制表示一位)，是为了更方便地表示数据。
(2)1和0的不同排列组合可以表示不同的数据。二进制用来表示一些数据有一个基本的规则就是它用八位二进制数来表示最小的一个单位(即字节)。
(3)由于用二进制来表示数据很麻烦，所以人们就想到如何让计算机识别我们生活中的文字(如：A、B、C.....)，于是人们用1和0的不同排列组合来表示A、B、C.....这样就可以把生活中的数据用1和0的不同排列组合表示出来了，它们之间存在着一定的对应关系。当你用键盘输入数据时，数据在内存中就是它对应的0和1不同排列组合。而随着数据越来越多，对应的映射关系也越来越多，这样就形成了一张表，即编码表，而美国人用的编码表是ASCII表。对于中文同样是由1和0的不同排列组合来表示的，但由于中文词很多，所以中文的码表也就很大。
(4)负数的二进制表现形式
十进制数 二进制数
   6       110
整数6占了四个字节，在内存中为：00000000 00000000 00000000 00000110 = 6
取反：11111111 11111111 11111111 11111001
加一：00000000 00000000 00000000 00000001 = 1
结果：11111111 11111111 11111111 11111010 = -6
结论：负数的最高位都是1。


(三)变量
1.变量的概念
(1)内存中的一个存储区域；
(2)该区域有自己的名称(变量名)和类型(数据类型)；
(3)该区域的数据可以在同一类型范围内不断变化。
2.为什么要定义变量：用来不断地存放同一类型的常量并可以重复使用。
3.使用变量时要注意的问题
(1)变量的作用范围；
(2)初始化值。
4.什么时候定义变量：当数据不确定的时候，需要对数据进行存储时，就定义一个变量来完成存储动作。
<注意>
(1)在程序中我们会使用一些内存单元来存储临时的数据。为了能够方便地访问到这些临时的数据，我们都会用一个标识符来命名内存单元，说简单一点，就是为内存单元取一个容易记住的名字。这样我们在访问那个内存单元时，可以使用它的名字而不是它的唯一地址。在为内存单元命名的同时，我们还需要指定数据的类型，这样，我们就可以在这个内存单元里存入和读取指定类型的数据。由于内存单元里的数据在程序运行时是可变的(常量例外)，因此这个内存单元被称为变量(Variable)。
(2)C语言中的类型是不占内存的，如int，但用它们定义的变量、数组都占内存。同理，定义的结构体类型也不占内存，如定义的Struct Student不占内存，只是告诉编译系统，将来定义的这种类型的对象(如变量、数组)由哪些类型的成员构成，各应占多少字节，按什么形式存储，并把它们当作一个整体处理。如定义结构体变量Struct Student s如同int i，虽然还没有为其成员赋值，但系统已经为它们分配了内存，内存是连续的。
<例>类型转换
short s = 3;
s = s + 2;//编译失败，因为(s + 2)中的s会被自动转换成int类型，运算后的结果还是int类型，无法赋值给short类型。
s += 2;//编译通过，因为+=运算符在给s赋值时自动完成了强制类型转换操作。


(四)运算符
<例>位运算符(位运算主要用于对二进制数进行运算)
60 >> 4 = 3
(00000000 00000000 00000000 00111100 >> 4 = 00000000 00000000 00000000 00000011)
<注意>左移其实就是乘以2的移动位数次幂，右移其实就是除以2的移动位数次幂。


(五)语句
1.switch语句的特点
(1)switch语句选择的类型只有四种：byte、short、int、char；
(2)case之间与default没有顺序，先执行第一个case，没有匹配的case执行default；
(3)结束switch语句的两种情况：遇到break或执行到switch结尾；
(4)如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或执行到switch结尾。
2.循环语句
(1)当要对某些语句执行多次时就使用循环结构。
(2)变量有自己的作用域。对于for循环来讲，如果将用于控制循环的增量定义在for语句中，那么该变量只在for循环语句内有效，for循环语句执行完毕后，该变量在内存中被释放。
(3)用循环结构操作了某个变量后，如果在循环外还要用到该变量的结果，那么就应使用while循环；否则，使用for循环更节省内存。
(4)for循环与while循环的区别
<例>
for(int i = 0; i < 3; i++)
{
System.out.println("i=" + i);
}
System.out.println("i=" + i);//编译出错，找不到符号i
System.out.println("-------");
int j = 0;
while(j < 3)
{
System.out.println("j=" + j);
j++;
}
System.out.println("j=" + j);//编译正确，j=3
(5)嵌套循环
<例>
for(int i = 1; i <= 5; i++)//控制行
{
for(int j = 1; j <= i; j++)//控制列，j=1控制第一列的值，j<=i控制列变化的规律，j++控制列数增大
{
System.out.print(j);
}
System.out.println();
}
运行结果：
1
12
123
1234
12345


(六)函数
1.函数就是定义在类中的具有特定功能的一段独立小程序。
2.函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1, 参数类型 形式参数2, .....)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型；
参数类型：是形式参数的数据类型；
形式参数：即函数的自变量，是在定义函数名和函数体的时候使用的参数，目的是用来存储调用函数时传递给函数的实际参数；
实际参数：传递给形式参数的具体数值；
return：用于结束函数；
返回值：该值会返回给调用者。
3.如何定义一个函数？
(1)既然函数是一个独立的功能，那么需要先明确该功能的运算结果是什么(明确函数的返回值类型)；
(2)再明确在定义该功能的过程中是否需要未知的内容参与运算(明确函数的参数列表)。
<注意>
(1)函数中只能调用函数，不可以在函数内部定义函数；
(2)定义函数时，函数的结果应该返回给调用者，交由调用者处理；
(3)主函数的功能主要是调用其它函数进行测试。
<例>定义一个函数完成求任意两个整数的和
public static void getAdd(int a, int b)
{
/*这个功能定义的思想有问题，为什么呢？因为只为完成加法运算，至于是否要对和进行打印操作，那是调用者的事，不要再该功能中完成。*/
System.out.println((a+b));
return;
}
<例>语句一般都要定义在函数内
class Demo
{
//错误，找不到程序入口
for(int i = 0; i < 5; i++)
{
System.out.println(i);
}
}
4.函数重载
(1)重载的概念
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
(2)重载的特点
与返回值类型无关，只看参数列表。
(3)重载的好处
方便于阅读，优化了程序设计。
(4)什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同，那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。


(七)数组
1.数组的概念
同一种类型数据的集合，其实数组就是一个容器。
2.数组的好处
可以自动给数组中的元素从0开始编号，方便操作这些元素。
3.C语言中数组
数组定义后，数组和它的每个元素在内存中就都有了明确的地址。数组起始地址(第一个元素地址)就是数组的指针，数组元素的地址就是数组元素的指针；为指针变量赋初值，可以用数组起始地址，也可以用数组名，数组名本身代表数组首地址(数组名永远是常量)。
<例>C语言中的数组与指针
int a[10];
(1)int *p;
   p = &a[0];
(2)int *p;
   p = a;
(3)int *p = &a[0];
(4)int *p = a;
4.内存结构
Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
(1)栈内存
用于存储局部变量，当数据使用完，所占空间会自动释放。
(2)堆内存
堆内存里存放的是实体(实体包括数组和对象)，通过new建立的实例都存放在堆内存中；
每一个实体都有内存地址值；
实体中的变量都有默认初始值；
实体不再被使用，会在不确定的时间内被垃圾回收器回收。
(3)方法区(也叫共享区或数据区)
(4)本地方法区
(5)寄存器
5.数组常见操作
(1)遍历
<例>
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println("arr[" + i + "]=" + arr[i]);
}
}
(2)最值
<例>
public static int max(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
(3)排序
<例>选择排序
public static void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
<例>冒泡排序
public static void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
(4)查找
<例>折半查找：提高效率，但是必须要保证数组是有序的
public static int search(int[] arr, int key) {
int min = 0;
int max = arr.length - 1;
int mid;
while (min <= max) {
mid = (min + max) / 2;
if (key > arr[mid]) {
min = mid + 1;
} else if (key < arr[mid]) {
max = mid - 1;
} else {
return mid;
}
}
return -1;
}
<例>向有序数组中插入指定的元素使得插入元素后的数组仍然是有序的
public static int insert(int[] arr, int key) {
int min = 0;
int max = arr.length - 1;
int mid;
while (min <= max) {
mid = (min + max) / 2;
if (key > arr[mid]) {
min = mid + 1;
} else if (key < arr[mid]) {
max = mid - 1;
} else {
return mid;
}
}
return min;
}
6.进制转换
<例>十进制--->十六进制
public static void toHex(int num) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < (32 / 4); i++) {
int temp = num & 15;
if (temp > 9) {
sb.append((char) (temp - 10 + 'A'));
} else {
sb.append(temp);
}
num = num >>> 4;
}
System.out.println(sb.reverse());
}
<例>十进制--->其它进制
public static void toBinary(int num) {
transform(num, 1, 1);
}


public static void toOctal(int num) {
transform(num, 7, 3);
}


public static void toHex(int num) {
transform(num, 15, 4);
}


public static void transform(int num, int base, int offset) {
char[] chs = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8',
'9', 'A', 'B', 'C', 'D', 'E', 'F' };
char[] arr = new char[32];
int pos = arr.length - 1;
while (num != 0) {
int temp = num & base;
arr[pos] = chs[temp];
pos--;
num = num >>> offset;
}
for (int i = pos + 1; i < arr.length; i++) {
System.out.print(arr[i]);
}
}
7.二维数组
<例>
int[][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[2];
arr[2] = new int[1];
System.out.println(arr.length);// 二维数组的长度
System.out.println(arr[0].length);// 二维数组中第一个一维数组的长度
System.out.println(arr[1].length);// 二维数组中第二个一维数组的长度
System.out.println(arr[2].length);// 二维数组中第三个一维数组的长度
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}