JAVA 1.0 - 基础

JAVA 1.0 - 基础

基本知识

图解

基础常识

软件：即一系列按照特定顺序组织的计算机数据和指令的集合。分为：系统软件和应用软件

• 系统软件：windows、mac os、linux、unix、android、ios...

• 应用软件：word、ppt、画图板...

人机交互方式：图形化界面 VS 命令行方式

应用程序 = 算法 + 数据结构

DOS

常用的DOS命令：

• dir：列出当前目录下的文件以及文件夹

• md：创建目录

• rd：删除目录

• cd：进入指定目录

• cd..：退回到上一级目录

• cd\：退回到根目录

• del：删除文件

• exit：退出dos命令行

  补充：echojavase>1.doc

常用快捷键：

• ←→：移动光标

• ↑ ↓：调阅历史操作命令

• Delete 和 Backspace：删除字符

API 文档

APl（Application Programming Interface，应用程序编程接口）是Java提供的基本编程接口

Java语言提供了大量的基础类，因此 Oracle 也为这些基础类提供了相应的 API 文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法

计算机语言

计算机语言的发展迭代史

第一代：机器语言

第二代：汇编语言

第三代：高级语言

• 面向过程：c、Pascal、Fortran

• 面向对象：Java、Js、Python、Scala...

开发工具

文本编辑工具：

• 记事本

• UltraEdit

• EditPlus

• TextPad

• NotePad

Java集成开发环境 (IDE)：

• JBuilder

• NetBeans

• Eclipse

• MyEclipse

• IntelliJ IDEA

注释

1.java规范的三种注释方式：

单行注释、多行注释、文档注释（java特有）

2.单行注释和多行注释的作用：

• 对所写的程序进行解释说明，增强可读性。方便自己，方便别人

• 调试所写的代码

3.特点：单行注释和多行注释，注释了的内容不参与编译。换句话说，编译以后生成的 class 结尾的字节码文件中不包含注释掉的信息

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

5.多行注释不可以嵌套使用

JDK JRE JVM

JDK：java 开发工具包

JRE：java 运行环境

JVM：java 虚拟机

三者关系：

JDK = JRE + 开发工具集（例如 Javac 编译工具等）

JRE = JVM + Java SE 标准类库

基础语法

关键字和保留字

关键字（keyword）：

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

• 特点：关键字中所有字母都为小写

保留字： goto、const

现有 Java 版本尚未使用，但以后版本可能会作为关键字使用

自己命名标识符时要避免使用这些保留字

标识符

Java对各种变量、方法和类等要素命名时使用的字符序列

技巧：凡是自己可以起名字的地方都叫标识符

定义合法标识符规则：

• 由26个英文字母大小写，0-9，_或 $ 组成

• 数字不可以开头

• 不可以使用关键字和保留字，但能包含关键字和保留字

• Java中严格区分大小写，长度无限制

• 标识符不能包含空格

命名规范：

• 包名：多单词组成时所有字母都小写：XXXyyyzzzZ

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

• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：XXxYyyZzz

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

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”

注意2：java采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用

变量

变量的概念：

• 内存中的一个存储区域

• 该区域的数据可以在同一类型范围内不断变化

• 变量是程序中最基本的存储单元，包含变量类型、变量名和存储的值

变量的作用：

• 用于在内存中保存数据

使用变量注意：

• Java中每个变量必须先声明，后使用

• 使用变量名来访问这块区域的数据

• 变量的作用域：其定义所在的一对 {} 内

• 变量只有在其作用域内才有效

• 同一个作用域内，不能定义重名的变量

声明变量

语法：<数据类型><变量名称>

例如：int var

变量的赋值

语法：<变量名称>=<值>

例如：var = 10

声明和赋值变量

语法：<数据类型><变量名>=<初始化值>

例如：int var = 10

变量的分类

整型变量：

java 各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证 java 程序的可移植性

java的整型常量默认为 int 型，声明 long 型常量须后加 'l' 或 'L'

java程序中变量通常声明为 int 型，除非不足以表示较大的数，才使用long

bit：计算机中的最小存储单位

byte：计算机中基本存储单元

浮点型变量：

与整数类型类似，java 浮点类型也有固定的表数范围和字段长度，不受其体操作系统的影响

浮点型常量有两种表示形式：

• 十进制数形式：如：5.12、512.0f、.512(必须有小数点）
• 科学计数法形式：如：5.12e2、512E2、100E-2

float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求

double：双精度，精度是float的两倍。通常采用此类型

Java的浮点型常量默认为 double 型，声明 float 型常量，须后加 ‘f’ 或 ‘F’

注意：float 表示数值的范围比 long 还大

char 类型：

char型数据用来表示通常意义上“字符”(2字节）

Java中的所有字符都使用 Unicode 编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符

字符型变量的三种表现形式：

• 字符常量是用单引号(')括起来的单个字符。例如：char c1='a';char c2= '中'; char c3 = "9';

• Java中还允许使用转义字符“V’来将其后的字符转变为特殊字符型常量
  例如：char c3='n'；//'n'表示换行符

• 直接使用 Unicode 值来表示字符型常量：‘uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n

char类型是可以进行运算的，因为它都对应有 Unicode 码

布尔型（boolean）：

只能取两个值之一：ture、false

常在条件判断、循环结构中使用

字符串类型（String）：

String不是基本数据类型，属于引用数据类型

声明 String 类型变量时，使用一对 " "

使用方式与基本数据类型一致。例如：Stringstr=“abcd”

一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据

例如：
str = str + “xyz”
int n = 100
str = str + n

变量之间的运算

前提：只讨论7种基本数据类型变量间的运算，不包含 boolean 类型

自动类型转换：

容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算

• byte，short，char之间不会相互转换，他们三者在计算时首先转换为int类型

• boolean 类型不能与其它数据类型运算

• 当把任何基本数据类型的值和字符串（String）进行连接运算时（+），基本数据类型的值将自动转化为字符串（String）类型

强制类型转换：

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型

• 如：String a =“43” ; int i= Integer.parselnt(a)

boolean类型不可以转换为其它的数据类型

运算符

算术运算符

赋值运算符

符号：=

• 当 ” = “ 两侧数据类型不一样是，可以使用自动类型转换或强制类型转换原则进行处理

• 支持连续赋值

扩展赋值运算符： += 、-= 、*= 、/= 、%=

比较运算符

• 比较运算符的结果都是 boolean 型
• 比较运算符 ”==“ 不要误写成 ”=“

逻辑运算符

&&：左边为 false 时，右边不执行

||：左边为 true 时，右边不执行

&：无论左边结果如何，都执行右边

|：无论左边结果如何，都执行右边

• 逻辑运算符的结果都是 boolean 型

• 推荐使用短路运算符（ && 和 || ），性能好，更安全

• 避免滥用 & 和 | 作为逻辑运算符

位运算符

位运算符直接对整数的二进制位进行运算

<<：低位补0，a << n 相当于 a × 2ⁿ

>>：高位补符号位，a >> n 相当于 a ÷ 2ⁿ

>>>：高位始终补0，结果必为非负数

• 只适用于整数类型
• 移位超过位数会取模：int 类型移位只取低5位（0-31），long 取低6位
• 负数的位运算：Java 使用补码表示负数
• 性能：位运算比算术运算快，但不要牺牲可读性

三元运算符

格式：(条件表达式) ? 表达式1 : 表达式2

• 条件表达式为 true ，运算结果为表达式1
• 条件表达式为 false ，运算结果为表达式2

表达式1和表达式2应为同种类型

三元运算符与 if-else 的联系与区别：

1.三元运算符可简化if-else语句

2.三元运算符要求必须返回一个结果

3.if后的代码块可有多个语句

运算符优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序；如上表，上一行运算符总优先于下一行

只有单目运算符、三元运算符、赋值运算符是 从右向左 运算的

Scanner

作用：从键盘获取不同类型的变量

实现步骤：

1.导包：代码import java.util.Scanner;

2.Scanner 的实际化：Scanner scan = new Scanner(System.in);

3.调用 Scanner 类的相关方法，来获取指定类型的变量

eg：从键盘获取 int 型数据

数组

概述

1.数组：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，通过编号的方式进行管理

2.常见概念：

• 数组名
• 下标索引
• 元素
• 数组的长度

3.数组的特点：数组是有序排列

4.数组本身属于引用数据类型的变量，但数组的元素既可以是基本数据类型，也可以是引用数据类型

5.数组的长度一旦确定，就不能修改

6.直接通过下标（索引）的方式调用指定位置的元素

7.数组的分类：

• 按维度：一维数组、二维数组、三维数组......
• 按元素的数据类型：基本数据类型元素的数组、引用数据类型元素的数组（即对象数组）

一维数组

声明和初始化

声明：int[] ids

静态初始化：数组的初始化和数组元素的赋值操作同时进行

ids = new int[]{1001,1002,1003,1004};

动态初始化：数组的初始化和数组元素的赋值操作分开进行

String[] names = new String[5];

错误写法：

int[] arr1 = new int[];  // 数组创建时需指定长度
int[5] arr2 = new int[5];  // 数组长度只能写在变量名后面
int[] arr3 = new int[3]{1,2,3};  // 数组长度和初始化列表不能同时出现

• 数组一旦初始化完成，其长度就确定了

元素调用

通过下标的方式调用

数组的下标（索引）从 0 开始，到数组的长度 -1 结束

获取长度：length属性

System.out.println(ids.length)

遍历数组

for(int i = 0;i < names.length;i++){System.out.println(names[i]);
}

二维数组

声明和初始化

声明：int[] arr = new int[]{1,2,3};

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

动态初始化1：String[][] arr2 = new String[3][2];

动态初始化2：String[][] arr3 = new String[3][];

错误写法：

String[][] arr4 =new String[][4];  // 不能只指定第二维长度
String[4][3] arr5 = new String[][];  // 数组长度只能写在变量名后面
int[][] arr6 = new int[4] [3]{{1,2,3},{4,5},{6,7,8}};  // 初始化长度不匹配

元素调用

System.out.println(arr[0][1]);

错误写法：System.out.println(arr[1][1]); // null

获取长度：length属性

int[][] arr4 = new int[][]{{1,2,3},{4,5},{6,7,8}};

System.out.println(arr4.length)  // 3
System.out.println(arr4[0].length)  // 3
System.out.println(arr4[1].length)  // 2

遍历数组

for(int i = 0;i < arr4.length;i++){for(int j = 0;j < arr4[i].length;j++){System.out.println(arr4[i][j] + " ");}
}

JVM 内存结构

堆（Heap）

作用：存储所有对象实例和数组，是垃圾回收的主要区域

特点：

• JVM 启动时创建
• 所有线程共享
• 垃圾回收的主要区域（GC 堆）
• 可以物理不连续，逻辑连续

方法区

作用：存储类信息、常量、静态变量、即时编译器编译后的代码

程序计数器

作用：记录当前线程执行的字节码行号

特点：

• 线程私有
• 唯一不会 OOM 的区域
• 生命周期与线程相同

虚拟机栈

作用：存储栈帧，每个方法执行时创建栈帧

栈帧组成：

• 局部变量表：存储方法参数和局部变量
• 操作数栈：存储计算过程中的中间结果
• 动态链接：指向运行时常量池的引用
• 方法返回地址：方法执行后继续执行的位置

常见异常：

• StackOverflowError：栈深度超过限制
• OutOfMemoryError：栈内存不足

本地方法栈

作用：为 Native 方法服务

数组算法

算法五大特征：

常见算法：

1.数组元素的赋值（杨辉三角、回形数等）

2.求数值型数组中元素的最大值、最小值、平均数、总和等

最大值：

核心：假设第一个元素为最大值，然后遍历比较

int max = arr[0];  // 假设第一个最大
for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];  // 找到更大的就替换}
}

最小值：

核心：思路与求最大值相同，只是比较符号相反

int min = arr[0];
for (int num : arr) {if (num < min) {min = num;}
}

平均数（Average）：

核心：先求总和，再除以数组长度

// 错误方式：整数除法会截断小数
int avg = sum / arr.length;// 正确方式：转为浮点数
double avg = (double) sum / arr.length;

• 注意：平均值通常是小数，需要将总和或长度转为浮点数计算，否则会丢失精度

总和（Sum）：

核心：定义一个累加变量（通常初始化为0），遍历数组并逐个累加

int[] arr = {3, 7, 2, 9, 5};
int sum = 0;
for (int num : arr) {sum += num;  // sum = 26
}

• 注意：结果类型要与数组元素类型匹配，防止溢出（特别是大量数据时考虑用 long 接收）

3.数组的复制、反转、查找（线性查找、二分法查找）

复制：

//复制 array1 数组给 array2
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){array2[i] = array1[i]
}

反转：

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 dest = "xx"
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){if(dest.equals(arr[i])){System.out.printin("找到了指定的元素，位置为：" + i);isFlag = false;break;} 
}
if(isFlag){System.out.println("很遗憾，没有找到");}

二分法查找：

前提：所要查找的数组必须有序

int[] arr2=newint[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
int head = 0;               //初始的首索引
int end = arr2.length - 1;  //初始的末索引
boolean isFlagl = true;
while(head<=end){int middle = (head + end) / 2;if(dest1 ==arr2[middle]){System.out.println("找到了指定的元素，位置为：" + middle);isFlag1 = false;break;}else if(arr2[middle] > desti){end = middle - 1;}else{head = middle + 1;if(isFlag1){System.out.println("很遗憾，没有找到")}}
}

4.数组元素的排序算法

冒泡排序：

思路：比较相邻的元素，如果第一个比第二个大（升序），就交换他们两个

public class BubbleSort{public static void main(String[] args){int[] arr = {64, 34, 25, 12, 22, 11, 90};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;}}}for (int num : arr){System.out.print(num + " "); // 11 12 22 25 34 64 90}}
}

快速排序：

思路：采用分治法

public class QuickSort {public static void main(String[] args) {int[] arr = {49, 38, 65, 97, 76, 13, 27, 49}; System.out.print("排序前：");for (int num : arr) {System.out.print(num + " ");}System.out.println();quickSort(arr, 0, arr.length - 1);        System.out.print("排序后：");for (int num : arr) {System.out.print(num + " ");}// 输出结果：13 27 38 49 49 65 76 97}    public static void quickSort(int[] arr, int left, int right) {if (left >= right) {return;}       int pivotIndex = partition(arr, left, right);quickSort(arr, left, pivotIndex - 1);quickSort(arr, pivotIndex + 1, right);}    public static int partition(int[] arr, int left, int right) {int pivot = arr[left];  // 选择最左边元素49作为基准值int i = left;int j = right;     while (i < j) {// 从右向左找第一个小于基准值的元素while (i < j && arr[j] >= pivot) {j--;}// 从左向右找第一个大于基准值的元素while (i < j && arr[i] <= pivot) {i++;}// 交换if (i < j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}arr[left] = arr[i];arr[i] = pivot;      return i;}
}

异常

数组中的常见异常：

1.数组角标越界的异常：ArrayIndexOutofBoundsExcetion

2.空指针异常：NullPointerException