Java_01

PDF文件：Java_01.pdf Html文件：Java_01.html

第一章 Java概述

1.1 Java重要特点

• Java语言是面向对象的（OOP）。
• Java语言是健壮的。
• Java语言是跨平台性的。[即：一个编译好的.class文件可以在多个系统下运行]
• Java语言是解释性语言。

1.2 Java开发工具

• Sublime
• IDEA

1.3 Java运行机制

说明：因为有了JVM，同一个Java程序在三个不同的操作系统中都可以执行，这样就实现了Java程序的跨平台性。

Java虚拟机 Java核心机制-Java虚拟机[JVM: Java Virtual Machine]

1. JVM是一个虚拟的计算机，具有指令并使用不同的存储区域。扶着执行指令，管理数据、内存、寄存器，包含在JDK中。
2. 对于不同的平台，有不同的虚拟机。
3. Java虚拟机机制屏蔽了底层运行平台的差别，实现了一次编译，到处运行

JDK和JRE JDK：

• JDK全称（Java Development Kit Java开发工具）
• JDK是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。

JRE：

• JRE全称（Java Runtime Environment Java运行环境）
• 包括Java虚拟机和Java程序所需要的核心类库等。

第二章 Java入门

2.1 Java初识

2.1.1 Hello World！

xxxxxxxxxx
// 这是Java的快速入门，演示Java的开发步骤
// 对代码相关说明
// 1.public class Hello 表示Hello是一个类，是一个public共有的类
// 2.Hello{ } 表示一个类的开始和结束
// 3.public static void main(String[] args){ } 表示一个主方法
// 4.main(){ } 表示方法的开始和结束
// 5.System.out.println(“Hello World”); 表示输出Hello world！到屏幕
public class Hello{
// 编写一个mian方法
public static void main(String[] args){
System.out.println(“Hello World!”);
}
}

2.1.2 Java编译

xxxxxxxxxx
控制台
编译：javac xxxxx.java
运行：java xxxxx.java

2.1.3 Java细项

1. Java源文件以 .java 为扩展名。源文件的基本组成部分是类。
2. Java应用程序的执行入口时main()方法。

xxxxxxxxxx
public static void mian(){…}

1. Java语言严格区分大小写。
2. Java方法由一条条语句构成，以“;”结束。
3. 大括号都是成对出现的，缺一不可。
4. 一个源文件中最多只能有一个public类。
5. 如果源文件中包含一个public类，则文件名必须按类名命名！
6. 也可以将main方法写在非public类中，然后指定运行非public类。

   2.1.4 Java转义

   提示：在控制台，输入Tab键可以实现命令补全

   • \t:一个制表位，实现对齐功能
   • \n:换行符
   • \:一个 \
   • \”:一个 “
   • \’:一个 ‘
   • \r:回车

2.1.5 Java注释

用于注解说明解释文字的就是注释，注释提高了代码的阅读性，注释时一个程序员必须要具备的良好的编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

单多行注释：
xxxxxxxxxx
// 单行注释
/
多行注释
多行注释
多行注释
/
文档注释：
注释内容可以被JDK提供工具Javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档，一般写在类。
xxxxxxxxxx
/*
@author jierzhou
@version 1.0
/
public class J0002{
//编写一个main方法
public static void main(String[] args) {

}
}

2.1.6 Java规范

• 类、方法的注释要以Javadoc的方式来写。
• 非Javadoc的注释，往往是给代码的维护者看的。
• 使用Tab操作实现整体缩进，使用Shift+Tab实现整体左移。
• 运算符两边习惯性加一个空格。
• 源文件使用UYF-8编码
• 行宽不要超过80字符
• 代码编写次行风格和行尾风格

2.2 Java变量

变量是程序的基本组成单位 变量有三个基本要素（类型+名称+值）

2.2.1 变量原理

变量相当于内存中的一个数据存储空间的表示，可以把变量看作是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量。

xxxxxxxxxx
// 变量使用的基本步骤
// 1.声明变量
int a;
// 2.赋值
a = 60;
// 3.打印输出
System.out.println(a);
// 赋值也可以一步到位
int b = 60;

2.2.2 变量入门

xxxxxxxxxx
// 1.定义变量,记录人的信息
int age = 20;
double score = 98.6;
char gender = ‘男’;
String name = “Jierzhou”;

// 输出信息
System.out.println(name);
System.out.println(age);
Syetem.out.println(gender);
System.out.println(score);

注意事项：

• 变量表示的是内存中的一个存储区域。
• 不同的数据类型不同占用空间大小的不同。
• 变量必须先声明再使用。
• 该区域的数据可以再同一类型范围中不断变化。
• 变量在同一个作用域中不能重名。

2.2.3 数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的存储空间。

2.3 Java运算

2.3.1 运算符介绍

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

2.3.2 算术运算符

算术运算符是对数值类型变量进行运算的。

xxxxxxxxxx
// 补充说明
public static void main(){
// % 取模
// 在 % 的本质，公式：a % b = a - a / b b
System.out.println(10%3); // 10 % 3 => 10 - 10/3(3)3 = 1
System.out.println(-10%3); // -10 % 3 => -10 - (-10)/3 3 = -1
System.out.println(10%-3); // 10 % -3 => 10 - 10 / (-3)(-3) = 1
System.out.println(-10%-3);// -1

// ++的使用<br />    int i = 10;<br />    // 作为独立语句使用的时候 i++ 等价 ++i<br />    i++; // 自增 等价于 i = i + 1;<br />    ++i; // 自增 等价于 i = i + 1;<br />    <br />    /*<br />    作为表达式使用<br />    前++:先自增再赋值<br />    后++:先赋值再自增<br />    */<br />    int j = 8;<br />    int k = ++j; // 等价于 j = j + 1;k = j; j = 9;k = 9;<br />    int l = j++; // 等价于 k = j;j = j + 1;j = 9;k = 8;<br />}<br /> 

2.3.3 关系运算符

关系运算符的结果都是Boolean型，要么是true，要么是false。 关系表达式长用在if结构的条件中或循环结构的条件中。

2.3.4 逻辑运算符

用于连接多个关系表达式，最终的结果也是一个Boolean值。

• 短路与：&&，短路或：|| ，取反 ！
• 逻辑与：&，逻辑或：| ，逻辑异或：^ | a | b | a&b | a&&b | a|b | a||b | !a | a^b | | —- | —- | —- | —- | —- | —- | —- | —- | | true | true | true | true | true | true | false | false | | true | false | false | false | true | true | false | true | | false | true | false | false | true | true | true | true | | false | false | false | false | false | false | true | false |

&& 和 & 的区别： && 短路与：如果第一个条件false，则第二个条件不会判断，最终结果为false，效率高。 & 逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低。 || 和 | 的区别： || 短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高。 | 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低。 非（!）: 运算最终值取反。

2.3.5 赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量。 基本运算符：= 复合运算符：+=，-=，*=，/=，%=

2.3.6 三元运算符

基本语法： 条件表达式？表达式1：表达式2；

1. 如果表达式为true运行表达式1。
2. 如果表达式为false运行表达式2。

2.3.7 运算优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。 只有单目运算符、赋值运算符是从右向左运算的。

优先级：

1. (),{}
2. 单目运算符
3. 算术运算符
4. 位移运算符
5. 比较运算符
6. 逻辑运算符
7. 三元运算符
8. 赋值运算符

2.3.8 进制转换

第一组：

1. 二进制转十进制
   规则：从最低位开始，将每个位上的数提取出来，乘以2的（位数-1）次方，再求和。
   案例：请将0b1011转成十进制的数。

0b1011 = 1 2的(1-1)次方 + 1 2的(2-1)次方 + 0 (2的(3-1)次方+1 2的(4-1)次方) = 1 + 2 + 0 + 8 = 11

1. 八进制转十进制
   规则：从最低位开始，将每个位上的数提取出来，乘以8的（位数-1）次方，再求和。
   案例：请将0234转成十进制的数。

0234 = 48^0 + 38^1 + 3*8^2 = 4 + 24 + 128 =156

1. 十六进制转十进制
   规则：从最低位开始，将每个位上的数提取出来，乘以16的（位数-1）次方，再求和。
   案例：请将0x23A转成十进制的数。

0x23A = 1016^0 + 316^1 +216^2 = 10 + 48 + 512 *第二组：

1. 十进制转二进制
   规则：将该数不断除以2，直到商为0为止，得到的余数倒过来，就是对应的2进制。
   案例：请将 34 转成二进制。

34 / 2 = 17 ··· 0 末位 17 / 2 = 8 ··· 1 第五位 8 / 2 = 4 ··· 0 第四位 4 / 2 = 2 ··· 0 第三位 2 / 2 = 1 ··· 0 第二位 1 / 2 = 0 ··· 1 首位 故 34 => 0B00100010

1. 十进制转八进制
   规则：将该数不断除以8，直到商为0为止，得到的余数倒过来，就是对应的八进制。
   案例：请将 131 转成二进制。

131 / 8 = 16 ··· 3 末位 16 / 8 = 2 ··· 0 次位 2 / 8 = 0 ··· 2 首位 故 131 => 0203

1. 十进制转十六进制
   规则：将该数不断除以16，直到商为0为止，得到的余数倒过来，就是对应的十六进制。
   案例：请将 237 转成二进制。

237 / 16 = 14 ··· 13 => D 末位 14 / 16 = 0 ··· 14 => E 首位 故 237 => 0xED 第三组：

1. 二进制转八进制
   规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可。
   案例：请将0B11010101转成八进制。

0B 11 010 101 => 0B 11(0)010(2)101(5) 故 0B11010101 => 0325

1. 二进制转十六进制
   规则：从从低位开始，将二进制数每四位一组，转成对应的十六进制数即可。
   案例：请将0B11010101转成十六进制。

0B 1101 0101 => 0B 1101(D) 0101(5) 故 0B11010101 => D5 第四组：

1. 八进制转二进制
   规则：将八进制每一位，转成相对应的一个3位的二进制数即可。
   案例：请将0237转成二进制。

0 2 3 7 => 02(010)3(011)7(111) => 0B10011111 故 0237 => 0B10011111

1. 十六进制转二进制
   规则：将十六进制每一位，转成相对应的一个4位的二进制数即可。
   案例：请将0x23B转成二进制。

0x 2 3 B => 0x 2(0010)3(0011)B(1011) => 0B001000111011 故 0x23B => 0B001000111011

2.4 Java结构

2.4.1 顺序控制

程序从上到下逐行的执行，中间没有任何判断和跳转。

xxxxxxxxxx
// 例如正常输出Hello,world!
public class Hello{
public static void main(String[] args){
String h = “Hello”;
String w = “World”;
System.out.println(h+w);
}
}

2.4.2 分支控制

让程序有选择性的执行。 单分支 语法： if(条件表达式){ 执行代码块；（可以有多条） } 说明： 当条件表达式为true时，就会执行代码块。 案例：

xxxxxxxxxx
import java.util.Scanner;
public class age{
// 编写一个程序，可以输入年龄，如果大于18岁则输出”年龄已经大于18！”
// 思路分析
// 1. 接收输入的年龄，应该定义一个Scanner对象
// 2. 把年龄保存到一个变量 int age中
// 3. 使用if判断，输出对应信息
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.print(“请输入年龄:”);
int age = sc.nextInt();
if(a>18){
System.out.println(“年龄已经大于18！”);
}
}
}

双分支 语法： if(条件表达式){ 执行代码块1；（可以有多条） } else{ 执行代码块2； } 说明: 当条件表达式成立，即执行代码块1，否则执行代码块2. 案例：

xxxxxxxxxx
import java.util.Scanner;
public class age{
// 编写一个程序，可以输入年龄，如果大于18岁则输出”年龄已经大于18！”,否则输出”年龄未满18岁!”。
// 思路分析
// 1. 接收输入的年龄，应该定义一个Scanner对象
// 2. 把年龄保存到一个变量 int age中
// 3. 使用if判断，输出对应信息,否则输出else中信息
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.print(“请输入年龄:”);
int age = sc.nextInt();
if(a>18){
System.out.println(“年龄已经大于18!”);
}
else{
System.out.println(“年龄未满18岁!”);
}
}
}

多分支 语法： if(条件表达式1){ 执行代码块1； } else if(条件表达式2){ 执行代码块2； } …… else{ 执行代码块n； } 说明： 当条件表达式1成立时。执行代码块1，反之则判断表达式2，以此类推，若都不成立，则执行else代码块。 案例：

xxxxxxxxxx
/
需求：输入小明同学的分数
如果：分数为100时，输出优秀
分数在(80，99]时，输出优良
分数在[60,80]时，输出一般
其他情况，输出不及格
/
import java.uitl.Scanner;
public class Demo{
public static void main(){
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if(score==100){
System.out.println(“优秀”);
}
else if(score > 80 && score <= 99){
System.out.println(“优良”);
}
else if(score >= 60 && score <= 80){
System.out.println(“一般”);
}
else{
System.out.println(“不及格”);
}
}
}

2.4.3 循环控制

让程序循环进行。 For循环控制 语法： for(循环变量初始化；循环条件；循环变量迭代){ 循环操作(语句)； } 说明： for循环的四要素

1. 循环变量初始化
2. 循环条件
3. 循环操作
4. 循环变量迭代

案例：

xxxxxxxxxx
// 简单的循环
public static void main(String[] args){
for(int i = 0;i < 100;i++){
System.out.println(i);
}
}

While循环控制 语法： While(){ 循环体()； 循环变量迭代； } 说明： While跟for循环一样也有四要素，只是放的位置不一样。 案例：

xxxxxxxxxx
// 简单的循环
public static void main(String[] args){
int i = 0;
while(i < 100){
System.out.println(i);
i++;
}
}

2.5 Java数组

2.5.1 数组入门

数组可以存放多个同一类型数据，也是一种数据类型，为引用类型。 数组就是一组数据。

xxxxxxxxxx
// 定义一个数组
// double[] 表示是double类型的数组，数组名为dou
// {3,5,4,2,5,10,88}表示数组的值/元素
// 下标依次表示数组的第几个元素，从0开始计算
public static void main(String[] args){
double[] dou = {3,5,4,2,5,10,88};

// 遍历数组得到数组的所有元素的和
for(int i = 0; i < dou.length;i++){
Syetem.out.println(“第”+(i+1)+”个元素的值=” + dou[i]);
}
}