计算机的介绍
分类
计算机分为硬件和软件 比如 @操作系统 - 百度百科 其实就是一个软件
Java属于软件层次
至于硬件有很多 里面又内存,硬盘,CPU等等
需要了解的可以自行百度 @计算机硬件 - 百度百科
Java基本语法
Java 语言的特点
1.类C语言
2.纯粹的面向对象 封装 继承(单继承) 多态
3.舍弃了C语言中的指针,使用引用替代
4.增加垃圾回收机制
5.易学的,安全,健壮等等
6.跨平台性 编译之后生成与平台无关的字节码文件(.class),只要平台安装了JVM就可以运行
JVM 与垃圾收集机制
Java的两种核心机制
Java虚拟机 JVM
Java GC 垃圾回收机制
JDK、JRE、JVM 的关系
1.JDK：
Java Development Kit
含义：Java开发工具包
2.JRE
全名：Java runtime environment
含义：Java运行环境
3.JVM
全名：Java Virtual Machine
含义：Java虚拟机
JDK 与 JRE 的安装 环境变量的配置
第一个 Java 程序：HelloWorld
class HelloWord
{
public static void main(String[] args){
System.out.println("hello world");
}
}
javac 是编译
java 是运行 此处注意 只需要运行类的名字就可以了
测试结果
单行注释与多行注释 注释一定要写 简单粗暴就够了
1.单行注释 //
//我是单行注释
2.多行注释 /**/
/*
我是多行注释
现在是第二行
*/
3.文档注释型注释 Java特有 但是C#也有,不管它哈
/**
* @author: icanci.cn
* @projectName:Java_basics
* @pageName:cn.icanci.java_basics.test
* @fileName:Test2.java
* @date: 2020年2月1日 上午9:34:34
* @version:1.0
* @description: 测试类
*/
注意 多行注释不可以嵌套使用
API 文档的说明
文档注释可以生成文档
当然,使用Java开发,也需要使用Java 的 API文档 可以自行百度下载,或者私信我获取
第一个 Java 程序的总结
比较简单,主要是环境的搭建 以及基本概念
1.java程序编写-编译-运行的过程
编写：我们将编写的java代码保存在以".java"结尾的源文件中
编译：使用javac.exe命令编译我们的java源文件。格式：javac 源文件名.java 运行：使用java.exe命令解释运行我们的字节码文件。 格式：java 类
2.在一个java源文件中可以声明多个class。但是，只能最多有一个类声明为public的。
而且要求声明为public的类的类名必须与源文件名相同。
3.程序的入口是main()方法。格式是固定的。
4输出语句：System.out.println():先输出数据，然后换行
System.out.print():只输出数据
5.每一行执行语句都以";"结束。
6.编译的过程：编译以后，会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。
Java 开发工具的说明
1.文本型 记事本 EditPlus 等等 大神都是记事本? 那慢了
2.Eclipse 免费的 ,可以安装很多插件等等 速度还行
2.MyEclipse 要收费 eclipse的升级版 集成了很多插件 不需要我们在自己安装
4.Idea 提示太强了,碾压Eclipse ,当然是要钱的,挺贵
关键字和保留字的说明
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使
用。自己命名标识符时要避免使用这些保留字
goto 、const
标识符及命名规则
标识符：
Java 对各种 变量、 方法和 类等要素命名时使用的字符序列称为标识符
技巧：凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则：
由 由26 个英文字母大小写，0-9 ，_或 或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java 中严格区分大小写，长度无限制。
标识符不能包含空格。
标识符的命名规范
Java中的名称命名规范：驼峰表示法
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个
单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。
变量的定义
变量的概念：
内存中的一个存储区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
变量的作用：
用于在内存中保存数据
声明变量
语法：<数据类型> <变量名称>
例如：int var;
变量的赋值
语法：<变量名称> = <值>
例如：var = 10;
声明和赋值变量
语法： <数据类型> <变量名> = <初始化值>
例如：int var = 10;
定义变量的注意点
使用变量注意：
Java中每个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的作用域：其定义所在的一对{ }内
变量只有在其作用域内才有效
同一个作用域内，不能定义重名的变量
变量的分类
对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分
配了不同大小的内存空间。
补充：变量的分类-按声明的位置的不同
在方法体外，类体内声明的变量称为 成员变量 。
在方法体内部声明的变量称为 局部变量
注意：二者在初始化值方面的异同:
同：都有生命周期 异：局部变量除形参外，需显式初始化
整型变量的使用说明
整数类型：byte 、short 、int 、long
Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保
证java程序的可移植性。
java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
public class Test1 {
public static void main(String[] args) {
int number1;
number1 = 10;
int number2;
number2 = 20;
int number3;
number3 = number1 + number2;
System.out.println("Number3 = " + number3);
int number4 = 50;
int number5 = number4 - number3;
System.out.println("Number5 = " + number5);
}
}
浮点型变量的使用说明
浮点类型：float 、double
与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作
系统的影响。
浮点型常量有两种表示形式：
十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 512E2 100E-2
float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。
Java 的浮点型常量默认为double型 型，明 声明float 型常量，须后加‘f’ 或‘F’ 。
char 型变量的使用说明
字符类型：char
char 型数据用来表示通常意义上“字符”(2字节)
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字
母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：
字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2= '中'; char c3 = '9';
Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
例如：char c3 = ‘\n’; // '\n'表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表
一个十六进制整数。如：\u000a 表示 \n。
char类型是可以进行运算的。因为它都对应有Unicode码。
乱码的情况和字符集的说明
了解：ASCII 码 码
在计算机内部，所有数据都使用 二进制表示。每一个二进制位（bit）有 0 和 1 两种状态，
因此 8 个二进制位就可以组合出 256 种状态，这被称为一个字节（byte）。一个字节一
共可以用来表示 256 种不同的状态，每一个状态对应一个符号，就是 256 个符号，从
0000000 到 11111111。
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的
关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个 个字符的编码，比如
空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这
128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前
面的1位统一规定为0。
缺点 ：
不能表示所有字符。
相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却代表
了字母Gimel ()ג
了解： Unicode 编码
乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因
此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，
就会出现乱码。
Unicode： 一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一
用 无二的编码，使用 Unicode 没有乱码的问题 。
Unicode 的缺点：Unicode 只规定了符号的二进制代码，却没有规定这个二进制代码
应该如何存储：无法区别 Unicode 和 ASCII：计算机无法区分三个字节表示一个符号
还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果
unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有
二到三个字节是0，这对于存储空间来说是极大的浪费。
2.3 变 变 量
： 了解： UTF-8
UTF-8 是在互联网上使用最广的一种 Unicode 的实现方式。
UTF-8 是一种变长的编码方式。它可以使用 1-6 个字节表示一个符号，根据
不同的符号而变化字节长度。
UTF-8的编码规则：
对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于
ASCII码）。
对于多字节的UTF-8编码，如果编码包含 n 个字节，那么第一个字节的前 n 位为1，第一
个字节的第 n+1 位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的
所有的字节，都是最高两位为"10"，其余6位用来对字符进行编码。
boolean 型变量的使用
布尔类型：boolean
boolean 类型用来判断逻辑条件，一般用于程序流程控制：
if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句；
boolean类型数据只允许取值true和false，无null。
不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的
boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false
用0表示。———《java虚拟机规范 8版》
自动类型提升运算
自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容
量大小排序为：
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的
那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其它数据类型运算。
当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类
型的值将自动转化为字符串(String)类型。
强制类型转换运算
自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使
用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可
以实现把字符串转换成基本类型。
如： String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。
变量运算规则的两个特殊情况
long L = 123455;
System.out.println(L);
上述代码有个默认的类中转换 从 int => long
float a = 12.2;
System.out.println(a);
此时就不可以,因为 浮点型默认是 double类型 所以后面必须加上 F 或者 f
String 类型变量的使用
String不是基本数据类型，属于引用数据类型
使用方式与基本数据类型一致。例如：String str = “abcd”;
一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str +"xyz";
int n = 100;
str = str + n;
两个关于 String 的练习题
String str1 = 4; //判断对错：no
String str2 = 3.5f + ""; //判断str2对错：yes
System.out.println(str2); //输出：”3.5”
System.out .println(3+4+"Hello!"); //输出：7Hello!
System.out.println("Hello!"+3+4); //输出：Hello!34
System.out.println('a'+1+"Hello!"); //输出：98Hello!
System.out.println("Hello"+'a'+1); //输出：Helloa1
不同进制的表示方式
所有数字在计算机底层都以 二进制形式存在。
对于整数，有四种表示方式：
二进制(binary) ：0,1 ，满2进1.以0b或0B开头。
十进制(decimal) ：0-9 ，满10进1。
八进制(octal) ：0-7 ，满8进1. 以数字0开头表示。
十六进制(hex) ：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
如：0x21AF +1= 0X21B0
二进制
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；
当是long类型时，二进制默认占64位，第64位是符号位
二进制的整数有如下三种形式：
原码：直接将一个数值换成二进制数。最高位是符号位
负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
负数的补码：其反码加1。
计算机以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同
负数的补码是其反码+1
为什么要使用原码、反码、补码表示形式呢？
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是
人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正
数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有
减法, 这样计算机运算的设计就更简单了。
二进制转换为十进制的说明
二进制转换为十进制的练习
十进制转二进制的操作
对于正数来讲：原码、反码、补码是相同的：三码合一。
计算机底层都是使用二进制表示的数值
计算机底层都是使用的数值的补码保存数据的。
二进制与八进制十六进制间的转换
算术运算符的使用
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符
算术运算符的注意问题
如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是
负数则不可忽略。此外，取模运算的结果不一定总是整数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只
保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的
结果是？
“+”除字符串相加功能外，还能把非字符串转换成字符串.例如：
System.out.println(“5+5=”+5+5); //打印结果是？ 5+5=55 ?
关于敲代码和练指法
赋值运算符的使用
符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
类型转换原则进行处理。
支持连续赋值。
扩展赋值运算符： +=, -=, *=, /=, %=
比较运算符的使用
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==” 不能误写成“=” 。
思考1：
short s = 3;
s = s+2; ①
s += 2; ②
① 和 ② 有什么区别？
+= 等同性质运算符不会改变数据的范围
思考2：
int i = 1;
i *= 0.1;
System.out.println(i);//
i++;
System.out.println(i);//
思考3：
int m = 2;
int n = 3;
n *= m++;
System.out.println("m=" + m);
System.out.println("n=" + n);
思考4：
int n = 10;
n += (n++) + (++n);
System.out.println(n);
逻辑运算符的使用说明
&—逻辑与 | —逻辑或 ！—逻辑非
&& —短路与 || —短路或 ^ —逻辑异或
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
理解：异或，追求的是“异”
位运算符的使用
位运算是直接对整数的二进制进行的运算
三元运算符的使用
格式:
( 条件表达式)? 表达式1 ：表达式2；
为 为true ，运算后的结果是表达式1；
为 为false ，运算后的结果是表达式2；
表达式1 和表达式2为 为 同种类型
三与 元运算符与if-else 的联系与区别：
1）三元运算符可简化if-else语句
2）三元运算符要求必须返回一个结果。
3）if后的代码块可有多个语句
三元运算符与 if else 的转换
public class Test1 {
public static void main(String[] args) {
int n = 10;
if (n == 10) {
System.out.println(n + 1);
} else {
System.out.println(n - 1);
}
System.out.println(n == 10 ? n + 1 : n - 1);
}
}
运算符的优先级
运算符有不同的优先级，所谓
优先级就是表达式运算中的运
算顺序。如右表，上一行运算
符总优先于下一行。
只有单目运算符、三元运算符、
赋值运算符是从右向左运算的。
关于流程控制的说明
流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组
合成能完成一定功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
顺序结构
分支结构
循环结构
- 顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。 - 分支结构
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。 - 循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素
顺序结构
Java中定义成员变量时采用合法的前向引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2；
int num1 = 12;
}
if else 结构的基本使用
- if( 条件表达式){
执行代码块；
} -
if( 条件表达式){
执行代码块1;
}
else{
执行代码块2;
}
if else -
if( 条件表达式1){
执行 代码块1;
}
else if ( 条件表达式2){
执行 代码块2;
}
……
else{
执行 代码块n;
}
if else if else
分支结构：if-else使用说明
条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
语句块只有一条执行语句时，一对{}可以省略，但建议保留
if-else语句结构，根据需要可以嵌套使用
当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓
当多个条件是“包含”关系时，“小上大下 / 子上父下”
public class Test1 {
public static void main(String[] args) {
int age = 75;
if (age < 0) {
System.out.println("不可能！");
} else if (age > 250) {
System.out.println("是个妖怪！");
} else {
System.out.println("人家芳龄 " + age + " ,马马乎乎啦！");
}
}
}
使用 Scanner 从键盘获取 int 型数据
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
if (age < 0) {
System.out.println("不可能！");
} else if (age > 250) {
System.out.println("是个妖怪！");
} else {
System.out.println("人家芳龄 " + age + " ,马马乎乎啦！");
}
}
}
使用 Scanner 从键盘获取多种类型数据
public class Test1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
String str = sc.next();
System.out.println(str);
double d = sc.nextDouble();
System.out.println(d);
long l = sc.nextLong();
//....
}
}
switch case 结构的基本使用
switch( 表达式){
case 常量1:
语句1;
// break;
case 常量2:
语句2;
// break;
… …
case 常量N:
语句N;
// break;
default:
语句;
// break;
}
switch case 结构的使用说明
public class Test1 {
public static void main(String[] args) {
int i = 1;
switch (i) {
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
default:
System.out.println("default");
break;
}
}
}
switch 语句有关规则
switch(表达式)中表达式的值 必须是下述几种类型之一：byte ，short， ，
char ，int， ，举 枚举 (jdk 5.0) ，String (jdk 7.0)；
case子句中的值必须是 常量，不能是变量名或不确定的表达式值；
同一个switch语句，所有case子句中的常量值互不相同；
break语句用来在执行完一个case分支后使程序跳出switch语句块；如
果没有break，程序会顺序执行到switch结尾
default子句是 可任选的 的。同时，位置也是灵活的。当没有匹配的case时，
执行default
switch case 与 if else 的转换说明
switch 和if 语句的对比
if和switch语句很像，具体什么场景下，应用哪个语句呢？
如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几
种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
也就是说，使用switch-case的，都可以改写为if-else。反之不成立。
循环结构及 for 循环的理解
循环 结构
在某些条件满足的情况下，反复执行特定代码的功能
循环 语句分类
for 循环
while 循环
do-while 循环
循环 语句的四个组成部分
初始化部分(init_statement)
循环条件部分(test_exp)
循环体部分(body_statement)
迭代部分(alter_statement)
for 循环结构的使用
语法 格式
for ( ① 初始化 部分; ② 循环条件部分; ④④ 迭代部分)｛
③ 循环体部分;
｝
执行过程：
①-②-③-④-②-③-④-②-③-④-.....-②
说明：
②循环条件部分为boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔
while 循环的基本使用
语法格式
① 初始化部分
while( ② 循环条件部分)｛ ｛
③ 循环体部分;
④迭代部分;
}
执行过程：
① ①- ②- ③- ④- ②- ③- ④- ②- ③- ④-...-②
说明：
注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
for循环和while循环可以相互转换
do while 循环的基本使用
public class Test1 {
public static void main(String args[]) {
int result = 0;
int i = 1;
while (i <= 100) {
result += i;
i++;
}
System.out.println("result=" + result);
}
}
while(true)结构的使用
语法格式
① 初始化部分;
do{
③ 循环体部分
④ 迭代部分
}while(② 循环条件部分);
执行过程：
① ①- ③- ④- ②- ③- ④- ②- ③- ④-...② ②
说明：
do-while 循环至少执行一次循环体
嵌套循环的使用
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，
for ,while ,do…while均可以作为外层循环或内层循环。
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的
循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开
始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
嵌套循环练习：九九乘法表
public class Test1 {
public static void main(String args[]) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(" " + i + " * " + j + " = " + i * j + " ");
}
System.out.println();
}
}
}
打印结果
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
break 和 continue 的基本使用
break 语句
break语句用于终止某个语句块的执行
{ ……
break;
……
}
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是
哪一层语句块
label1: { ……
label2: { ……
label3: { ……
break label2;
……
}
}
}
public class Test1 {
public static void main(String args[]) {
for (int i = 0; i < 10; i++) {
if (i == 3)
break;
System.out.println(" i =" + i);
}
System.out.println("Game Over!");
}
}
continue 语句
continue只能使用在循环结构中
continue语句用于跳过其所在循环语句块的一 一 次执行，继续下一次循环
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
public class Test1 {
public static void main(String args[]) {
for (int i = 0; i < 100; i++) {
if (i % 10 == 0)
continue;
System.out.println(i);
}
}
}
特殊句 流程控制语句3
return：并非专门用于结束循环的，它的功能是结束一个方法。
当一个方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管
这个return处于多少层循环之内
特殊流程控制语句说明
break只能用于switch 语句和 循环语句中。
continue 只能用于 循环语句中。
二者功能类似，但continue是终止 本次循环，break是终止 本层循环。
break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条
语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同
于goto的
Eclipse 首次启动的设置
1.安装Eclipse 只要去官网下载Eclipse 的zip文件解压缩就可以了 前提是安装好了JDK
2.选择工作空间 注意 :工作空间路径不要有中文,不要有空格
3.修改编码
HelloWorld 程序的编写和执行
数组的概述
数组(Array)，是多个相同类型数据按一定顺序排列
的集合，并使用一个名字命名，并通过编号的方式
对这些数据进行统一管理。
数组的常见概念
数组名
下标(或索引)
元素
数组的长度
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括
基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是
这块连续空间的首地址。
数组的长度一旦确定，就不能修改。
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
数组的分类：
按照维度：一维数组、二维数组、三维数组、…
按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对
象数组)
一维数组的初始化
一维数组的 声明方式：
type var[] 或 type[] var；
例如：
int a[];
int[] a1;
double b[];
String[] c; //引用类型变量数组
Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法
动态初始化 ：数组声明且为数组元素分配空间与赋值的操作分开进行
int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;
String names[];
names = new String[3];
names[0] = "钱学森";
names[1] = "邓稼先";
names[2] = "袁隆平";
静态初始化 ：在定义数组的同时就为数组元素分配空间并赋值
int arr[] = new int[]{ 3, 9, 8};
//或
int[] arr = {3,9,8};
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素
数组元素的调用
数组元素的引用方式：数组名[数组元素下标]
数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new
int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长
度(元素个数)
数组一旦初始化，其长度是不可变的
数组是引用类型，它的元素相当于类的成员变量，因此数组一经
分配空间，其中的每个元素也被按照成员变量同样的方式被隐式
初始化。例如：
public class Test1 {
public static void main(String args[]) {
int[] arr = new int[10];
System.out.println(arr[2]);
}
}
//默认数组元素值 是数组类型的默认值
对于基本数据类型而言，默认初始化值各有不同
对于引用数据类型而言，默认初始化值为null( 注意 与0 0 不同！)
数组的长度与遍历 内存结构的简单说明
Java中使用关键字new来创建数组
如下是创建基本数据类型元素的一维数组
public class Test1 {
public static void main(String args[]) {
int[] s;
s = new int[10];
for (int i = 0; i < 10; i++) {
s[i] = 2 * i + 1;
System.out.println(s[i]);
}
}
}
一维数组的内存解析
二维数组的理解和初始化
Java 语言里提供了支持多维数组的语法。
如果说可以把一维数组当成几何中的线性图形，
那么二维数组就相当于是一个表格，像右图Excel
中的表格一样。
对于二维数组的理解，我们可以看成是一维数组
array1又作为另一个一维数组array2的元素而存
在。其实，从数组底层的运行机制来看，其实没
有多维数组。
二维数组[][] 数组中的数组
格式1 （动态初始化）： ：int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
式 格式2 （动态初始化）： ：int[][] arr = new int[3][];
二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意：区别于格式1）
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
注：
int[][]arr = new int[][3]; //
格式3） （静态初始化）： ：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
Java中多维数组不必都是规则矩阵形式
二维数组的内存解析
算法：数组元素的赋值
public class Test1 {
public static void main(String args[]) {
int[] s;
s = new int[10];
for (int i = 0; i < 10; i++) {
s[i] = 2 * i + 1;
}
int[] s1 = new int[10];
for (int i = 0; i < s.length; i++) {
s1[i] = s[i];
}
System.out.println(Arrays.toString(s1));
}
}
算法：数组元素的反转
public class Test1 {
public static void main(String args[]) {
int[] s;
s = new int[10];
for (int i = 0; i < 10; i++) {
s[i] = 2 * i + 1;
}
System.out.println(Arrays.toString(s));
int[] s1 = new int[10];
for (int i = s.length - 1; i >= 0; i--) {
s1[s1.length - 1 - i] = s[i];
}
System.out.println(Arrays.toString(s1));
}
}
算法：线性查找
public class Test1 {
public static void main(String args[]) {
int[] s;
s = new int[10];
for (int i = 0; i < 10; i++) {
s[i] = 2 * i + 1;
}
for (int i = 0; i < 10; i++) {
if (s[i] == 11) {
System.out.println("找到了");
System.out.println(s[i]);
break;
} else {
System.out.println("下标为" + i + "的不是");
}
}
}
}
打印结果
下标为0的不是
下标为1的不是
下标为2的不是
下标为3的不是
下标为4的不是
找到了
11
算法：二分法查找
二分查找需要先排序
private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
Object key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
@SuppressWarnings("rawtypes")
Comparable midVal = (Comparable)a[mid];
@SuppressWarnings("unchecked")
int cmp = midVal.compareTo(key);
if (cmp < 0)
low = mid + 1;
else if (cmp > 0)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
算法和排序算法的概述 以下的排序算法,会在数据结构专栏讨论
排序：假设含有n个记录的序列为{R1，R2，...,Rn},其相应的关键字序列为
{K1，K2，...,Kn}。将这些记录重新排序为{Ri1,Ri2,...,Rin},使得相应的关键
字值满足条Ki1<=Ki2<=...<=Kin,这样的一种操作称为排序。
通常来说，排序的目的是快速查找。
衡量排序算法的优劣：
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保
持不变，则称这种排序算法是稳定的。
排序算法分类： 内部排序 和 外部排序 。
内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排
序操作都在内存中完成。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排
序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最
常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。
十大内部排序
选择排序
直接选择排序、堆排序
交换排序
冒泡排序、快速排序
插入排序
直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序
说明：满足确定性的算法也称为：确定性算法。现在人们也关注更广泛的概念，例如
考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终
止的计算描述，这种描述有时被称为过程（procedure）。
算法：冒泡排序的实现
介绍：
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元
素，如果他们的顺序错误就把他们交换过来。
排序思想：
- 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步
做完后，最后的元素会是最大的数。 - 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要
比较为止。
算法：快速排序的说明
介绍：
快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快
排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可
见掌握快排的重要性。
快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十
大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升
级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))。
快速排序
排序思想：
- 从数列中挑出一个元素，称为"基准"（pivot），
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准
值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，
该基准就处于数列的中间位置。这个称为分区（partition）操作。 - 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数
列排序。 - 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好
了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代
（iteration）中，它至少会把一个元素摆到它最后的位置去。
排序算法的横向对比
各种内部排序方法性能比较
- 从平均时间而言：快速排序最佳。但在最坏情况下时间性能不如堆排序和归
并排序。 - 从算法简单性看：由于直接选择排序、直接插入排序和冒泡排序的算法比较
简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序
算法，其算法比较复杂，认为是复杂排序。 - 从稳定性看：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排
序、快速排序、 Shell排序和堆排序是不稳定排序 - 从待排序的记录数n 的大小看，n较小时，宜采用简单排序；而n较大时宜采
用改进排序。
排序 算法 的 选择
(1)若n较小(如n≤50)，可采用 直接插入或 直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直
接插入，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用 直接插 入、 冒泡或随机的 快速排
序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法： 快速排序、 堆排序或
归并排序。
Arrays 工具类的使用
数组中的常见异常
数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[2]);
System.out.println(arr[-1]);
访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。
