本文详细介绍了Java开发环境的配置步骤，包括JDK的安装、环境变量设置及Java三个体系（JSE、JEE、JME）的概要。随后讲述了基础编程概念，如第一个Java程序的创建、编译与运行，以及注释、标识符、数据类型、运算符、位运算和内存模型。
Java基础之公共基础
一、配置开发环境
1.下载 jdk1.8 安装包或从已经安装过的电脑上拷贝 jdk 安装后的文件夹直接使用。下载解压版地址：下载JDK1.8 提取码:1pdg
2.安装完 JDK 后配置环境变量：计算机→属性→高级系统设置→高级→环境变量。
3.系统变量→新建 JAVA_HOME 变量。变量值填写 jdk 的安装或解压目录如 E:\jdk1.8。
4.系统变量→寻找 Path 变量→编辑。
如果是 win7 系统，Path 中的每个变量都是通过分号隔开，新的变量值需要追加在原变量的后面。如果原来 Path 的变量值末尾有没有；号。需要先输入分号后再加入下面的两段配置。
%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
如果是 win10 系统，Path 显示的方式有所不同，需要单独配置每个变量。通常使用下面的配置方式，将两个值分别进行配置。
5.系统变量→新建 CLASSPATH 变量。变量值填写如下：
.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
系统变量配置完毕。检验是否配置成功运行 cmd 输入 java -version 命令进行校验。
C:\Users\Administrator>java -version
java version "1.8.0_131"
Java(TM) SE Runtime Environment (build 1.8.0_131-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.131-b11, mixed mode)
注意：
-
JDK（Java Development Kit）称为 Java 开发包或 Java 开发工具，是一个编写 Java 的 Applet 小程序和应用程序的程序开发环境。JDK 是整个 Java 的核心，包括了 Java 运行环境（Java Runtime Envirnment），一些 Java 工具和 Java 的核心类库（Java API）。不论什么 Java 应用服务器实质都是内置了某个版本的 JDK。主流的 JDK 是 Sun 公司发布的 JDK，除了 Sun 之外，还有很多公司和组织都开发了自己的 JDK，例如，IBM 公司开发的 JDK，BEA 公司的 Jrocket，还有 GNU 组织开发的 JDK。
-
另外，可以把 Java API 类库中的 Java SE API 子集和 Java 虚拟机这两部分统称为 JRE（JAVA Runtime Environment），JRE 是支持 Java 程序运行的标准环境。
-
JRE 是个运行环境，JDK 是个开发环境。因此写 Java 程序的时候需要 JDK，而运行 Java 程序的时候就需要 JRE。而 JDK 里面已经包含了 JRE，因此只要安装了JDK，就可以开发 Java 程序，也可以正常运行 Java 程序。但由于 JDK 包含了许多与运行无关的内容，占用的空间较大，因此运行普通的 Java 程序无须安装 JDK，而只需要安装 JRE 即可。
-
JVM 是 Java Virtual Machine（Java虚拟机）的缩写，JVM 是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。
-
引入 Java 语言虚拟机后，Java 语言在不同平台上运行时不需要重新编译。Java 语言使用 Java 虚拟机屏蔽了与具体平台相关的信息，使得 Java 语言编译程序只需生成在 Java 虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。
-
二、java 三个体系
Java2 平台企业版（Java 2 Platform，Enterprise Edition）包括：标准版（J2SE）、企业版（J2EE）和微缩版（J2ME）三个版本。J2SE，J2ME 和 J2EE 这也就是 SunONE（OpenNetEnvironment）体系。J2SE 就是 Java2 的标准版，主要用于桌面应用软件的编程；J2ME 主要应用于嵌入式系统开发，如手机和 PDA 的编程；J2EE 是 Java2 的企业版，主要用于分布式的网络程序的开发，如电子商务网站和 ERP 系统。
-
Standard Edition（标准版）J2SE 包含那些构成 Java 语言核心的类。比如：数据库连接、接口定义、输入/输出、网络编程。
-
Enterprise Edition（企业版）J2EE 包含 J2SE 中的类，并且还包含用于开发企业级应用的类。比如：servlet、JSP、XML、事务控制。
-
Micro Edition（微缩版）J2ME 包含 J2SE 中一部分类，用于消费类电子产品的软件开发。比如：呼机、智能卡、手机、PDA、机顶盒。
简单讲就是：
J2SE：java2Standard edition（java2 标准版）
J2EE：java2 enterprise edition（Java2 企业版）
J2ME：java2 micro edition（Java2 微缩版）
他们的范围是：J2SE 包含于 J2EE 中，J2ME 包含了 J2SE 的核心类，但新添加了一些专有类。
应用场合，API 的覆盖范围各不相同。
笼统的讲，可以这样理解：J2SE 是基础；压缩一点，再增加一些硬件控制方面的特性就是 J2ME；扩充一点，再增加一些企业应用方面的特性就是 J2EE。
-
J2EE 更恰当的说，应该是 JAVA2 企业开发的技术规范，不仅仅是比标准版多了一些类。J2EE 又包括许多组件，如 Jsp、Servlet、JavaBean、JDBC、JavaMail 等。
-
J2SE 商业版本，标准版本（Java2 Standard Edition）定位在客户端，主要用于桌面应用软件的编程。
-
J2SE 包含那些构成 Java 语言核心的类。
比如：数据库连接、接口定义、输入/输出、网络编程，J2SE 是 J2EE 的基础，他大量的 JDK 代码库是每个要学习 J2EE 的编程人员必须掌握的。
从 JDK5 开始，不再叫 J2SE 而是改名为 Java SE 了，因为那个 2 已经失去了其应该有的意义。
三、第一个 java 程序
java 开发工具: 记事本、Notepad++、eclipse、idea
idea 官网地址：https://www.jetbrains.com/idea/，ideaIU-2020.1.win.zip 下载地址：链接
注意：不建议使用记事本直接创建 java 文件，会出现编译报错问题。
使用 idea 创建 java 项目，项目名为 hello，在项目中创建名为 HelloWorld 的 java 类，内容如下，找到该类的具体位置，可以看到该类是一 HelloWorld.java 文件。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
HelloWorld 程序中的第一行的内容是 public class HelloWorld，其中 HelloWorld 是一个类名，class 是判断 HelloWorld 为一个类名的关键字，而 public 是用来修饰类的修饰符，表示公开的。每一个基础类都有一个类体，使用大括号包括起来，类主要是用来存放方法的。
程序中的第二行为 public static void main(String args[])，简打（main 回车）它是一个特殊方法，主体是 main，其他的都是修饰内容。这条代码语句是一个 Java 类固定的用法，其中 main 定义一个 Java 程序的入口。和类具有类体，方法具有方法体一样，其同样也要使用大括号括起来。
程序的第三行为 System.out.println(“Hello World”)，简打（sout 回车）该语句的功能是向输出台输出内容。在该程序中输入的是 Hello World 信息。
四、编译与运行
1、java 源文件（.java）是不能直接运行的，需要由编译器 javac.exe 编译生成 java 字节码文件（.class）
2、字节码文件（*.class）由执行器 java.exe 将字节码文件加载到 java 虚拟器（jvm）后执行。
C:\Users\Administrator>cd Desktop
C:\Users\Administrator\Desktop>javac HelloWorld.java
C:\Users\Administrator\Desktop>java HelloWorld
hello world<br>
在 cmd 命令提示窗口中通过 cd Desktop 进入 windows 桌面，因为 java 文件在桌面上。注意，使用 cmd 编译时 java 文件中不能包含中文否则会编译不通过。如果 Java 文件中必须包含中文可以使用 idea 进行编译。
练习：
1.使用 idea 创建 Demo.java，向控制台打印“I love java!!”，并用命令行窗口编译和运行。
参考代码：
public class Demo {
public static void main(String[] args) {
System.out.println("I love java!!");
}
}
参考命令：
C:\Users\Administrator\Desktop>javac Demo.java
C:\Users\Administrator\Desktop>java Demo
I love java!!
五、注释
注释添加在代码中，是给程序员看的，当系统运行程序，读取注释时会越过不执行。随着技术的发展，现在具有百万行代码的程序已经很常见了，在这样一个大型的代码中，如果没有注释，可想而知对于后面的修改和维护会产生多大的麻烦。在 Java 语言中提供了完善的注释机制，具有三种注释方式。
1.单行注释
// 注释内容
2.多行注释
/*
1
2
3
*/
3.文档注释，常用在方法上表明方法的作用，调用参数和返回值，如下方法用于简单的求和运算，使用注释可以清楚的展示方法的参数与返回值。
public class HelloWorld {
public static void main(String[] args) {
int sum = sum(10, 20);
System.out.println(sum);
}
/**
* 这是一个求和的方法
* @param i1 这是加数1
* @param i2 这是加数2
* @return 他们的和
*/
public static int sum(int i1, int i2) {
return i1 + i2;
}
}
-
int ：表示整数。
-
void：表示方法执行后，不返回内容。
-
return：表示立即返回对应类型的内容。
-
sum：方法的名字，英文意思为求和。
-
param：英文意思为参数。
六、标识符
标识符是程序员为自己定义的类、方法或者变量等起的名称。也就是程序员起的类名、方法名、属性名、变量名。
在 Java 中是区分大小写的，而且还要求首位不能是数字和其中不能包含运算符（加（+）减（-）乘（*）除（/）与（&）或（|）非（!）等）。最重要的是，Java 关键字不能当作 Java 标识符。
合法标识符的示例：age，$salary，_value，__1_value。
非法标识符的示例：123abc，-salary，public。
命名规则：
- 类和接口名：每个字的首字母大写，含有大小写。例如：MyClass，HelloWorld，Time 等。
- 方法名和变量：首字符小写，其余的首字母大写，含大小写。尽量少用下划线。例如：myName，setTime 等。这种命名方法叫做驼峰式命名。
- 常量名：基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。对象常量可大小混写。例如：SIZE_NAME，MAX_VALUE。
java 关键字：
访问控制
private 私有的、protected 受保护的、public 公开的
类、方法、变量和修饰符
abstract 声明抽象、class 类、extends 扩允，继承、final 终极，不可改变的、implements 实现、interface 接口、native 本地、new 新，创建、static 静态、synchronized 线程同步、transient 短暂、assert 断言
程序控制语句
break 跳出循环、continue 继续、return 返回、do 运行、while 循环、if 如果、else 反之、for 循环、instanceof 实例判断、switch 开关、case 返回开关里的结果、default 默认
错误处理
catch 处理异常、finally 有没有异常都执行、throw 抛出一个异常对象、throws 声明一个异常可能被抛出、try 捕获异常
包相关
import 引入、package 包
基本类型
boolean 布尔型、byte 字节型、char 字符型、double 双精度、float 浮点、int 整型、long 长整型、short 短整型
变量引用
super 父类，超类、this 本类、void 无返回值、enum 枚举类型
注意：
const、goto 是关键字，虽然没用，但不能拿来当变量名。
true、false、null 不是关键字，但也不能用来当变量名。
七、基本数据类型
Java 是一门强数据类型语言，Java 程序中定义的所有数据都有一个固定的数据类型。
Java 中的数据类型基本可以分为两类：基本数据类型（也称原始数据类型）和复合数据类型（引用数据类型）。在本节中主要讲解基本数据类型，复合数据类型在后面的章节中将会讲到。学习数据类型的重点是了解每一种数据类型的取值范围。
整数类型、小数(浮点)类型、布尔类型、字符类型
1.整数类型
可以表示一个整数，常用的整数类型有
byte 占用内存 一个字节 范围：-128至127（-2^7 ～2^7 -1）
short 占用内存 两个字节 范围：-32768至32767（-2^15 ～2^15 -1）
int 占用内存 四个字节 范围：-2147483648至2147483647（-2^31 ～2^31 -1）
long 占用内存 八个字节 范围：-?至? （long 赋值时要在值后加L ）
在 byte 下二进制与十进制，根据下面的提示，从 0 到 10 的二进制列出来。
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
为什么 byte 只能装 127 到 -128？
基本上所有编程语言都规定，第一位表示符号：如果第一位为 1 则表示负数，如果为 0 则表示正数。
由于第一位表示符号，必然出现 1000 0000 这个数，通过字面理解 -0，只能往负数加一个。
byte b=127;
//0000 0000 0
//0000 0001 1
//0000 0010 2
//0000 0011 3
//0000 0100 4
//0000 0101 5
//0000 0110 6
//_111 1111 127
2.小数（浮点）类型
可以表示一个小数，常用的小数(浮点)类型有 float (单精度)和 double (双精度)，java 中的小数默认是 double 的。
float 占用内存 四个字节 范围：3.4E-38至3.4E+38 只能提供 8 位有效数字 （float 赋值时要在值后加 f ）
double 占用内存 八个字节 范围：1.7E-308至1.7E+308 可提供 16 位有效数字
3.布尔类型
可以表示"真"或者"假"，类型是 boolean，值只能是 true（真） 和 false（假） 。
boolean spBool = true; //给变量spBool定义为boolean型并赋值为真<br>
4.字符类型
可以表示单个字符，字符类型是 char，可以存放一个字母、一个符号或一个汉字，而且使用单引号包裹。
char c = 'A';<br>
由于字符存储是以 ASCII 码的数字存储，故字符的加减运算也是基于 ASCII 码的加减运算。
案例：
char c = 'a';
System.out.println(c + 1 - 1);
//97
注意：多个字符连在一起我们称为字符串，在 java 中用 String 这种数据类型表示
String（字符串）不是基本数据类型，而是复合数据类型（引用类型）。String 声明的变量使用双引号。字符串进行加法运算时是简单的拼接，不能进行减法运算。
char c = '1';
//字符必须用单引
String s1 = "大家好";
//字符串必须用双引
练习：
1.编写代码将自己的名字的单字形式的数字发按照如下格式输出。如：张(24352) 三(19977)
2.创建一个方法，传入一个小写字母，返回该字母的大写字母。提示：大写字母和小写字母之间在 ASCII 码表上对应相差 32。
参考代码：
public class MainTest {
public static void main(String[] args) {
t1();
int c = t2('a');
System.out.println((char) c);
}
private static void t1() {
System.out.println("张(" + (int) '张' + ")三(" + (int) '三' + ")");
}
private static int t2(char c) {
return c - 32;
}
}
八、基本数据类型转换
1.自动转换
数据类型可以自动的从低精度向高精度转换，换而言之就是高精度的类型可以存放低精度的变量。而高精度不能自动转为低精度。
精度大小顺序表：byte < short < int < long < float < double
double b = 3;<br>
2.强制转换
当需要让高精度变量转为低精度时需要使用强制类型转换，需要注意强制类型转换会丢失小数部分或发生数据溢出。强制类型转换需要在变量前面使用括号声明转换后的类型。
int a = (int) 1.2;
byte b = (byte) 255;
3.计算过程中的转换
当一个整数类型和一个 double 类型运算的时，运算结果会向高精度的 double 转换。
int a = 3;
double b = a + 3.4;
byte b=1;
b = b + 1;//编译报错
九、常用运算符
1.算术运算符：+加、-减、*乘、/除、%取余
在整数运算中：
- / 运算可以得到两个整数的商
- % 运算可以得到两个整数的余数
int quotient = 5 / 3;//1 商
int remainder = 5 % 3;//2 余
在小数运算中：/ 就是正常运算
double out = 5 / 3.0;
System.out.println(out);
2.算术运算符：++ 自加、-- 自减。
++ 表示变量自动增加 1
– 表示变量自动减少 1
案例：
int a = 90;
a++;
System.out.println("a:" + a);
int b = 89;
b--;
System.out.println("b:" + b);
变量 ++ 与 ++ 变量的主要区别在于自增的时机，通常有先用后加和先加后用的区别。如：i++ 表示先用后加，++i 表示先加后用。
案例：
int a = 56;
int b = a++;
System.out.println("b:" + b);
System.out.println("a:" + a);<br>
案例：
int a = 21;
System.out.println(a++);
System.out.println(a);
System.out.println(++a);
if (a++ == 23) {
System.out.println("进入if,a:" + a);
}
3.算术运算符：+=左加、-=左减、/=左除、%=左取模
这是开发中的一种简化操作，如：i += 5 等效于 i = i + 5，+= 操作能够自动转换类型如：byte i = 12; 执行 i=i+10;时会编译报错，而 i += 10；是合法的。
案例：
int a = 90;
a += 9;
System.out.println(a);
float b = 89.7f;
b += a;
System.out.println(b);
案例：
int a = 8;
int b = 9;
a -= 3;
b %= a;//b=b%a
System.out.println("a:" + a);
System.out.println("b:" + b);
4.关系运算符：== 等于、> 大于、< 小于、>= 大于等于、<= 小于等于、!= 不等于。
大于等于的真实含义表示既可以大于又可以等于，两个条件满足一个即可，它的要求要比大于底一些。
案例：
int a = 90;
int b = 90;
if (a == b) {
System.out.println("ok1");
}
b--;
if (a > b) {
System.out.println("ok2");
}
//90 >= 89
if (a >= b) {
System.out.println("ok3");
}
a--;
if (a != b) {
System.out.println("ok4");
}
5.逻辑运算符：&& 与、|| 或、! 非
&& （与）要求运算符两边的两个条件都要为真，结果才为真。简记：真真为真，其它都为假。
|| （或）要求运算符两边的两个条件只要有一个条件为真，结果就为真。简记：假假为假，其它都为真。
! （非）对运算符后面的条件取反。简记：真取假，假取真。
案例：
int a = 90;
int b = 90;
if(a == b || a > 8){System.out.println("ok1");}
b--;
if(a > b && a > 45){System.out.println("ok2");}
if(!(a <= b)){System.out.println("ok3");}
扩展：短路与与短路或
|| 或运算符前面如果为 true，则后面的不执行
&& 与运算前面如果为 false，则后面的也不执行
案例：
int a = 90;
if (1 != 1 || a++ == 1) {
}
System.out.println("a:" + a);//91
if (1 != 1 && a++ == 1) {
}
System.out.println("a:" + a);//91
练习
1.写一个将华氏温度转换成摄氏温度的程序，转换的公式是：°F = (9/5)*°C + 32
其中 C 表示摄氏温度，F 表示华氏温度。程序的输入是一个整数，表示华氏温度。输出对应的摄氏温度，也是一个整数。
2.编写一个方法用于将大写字母转换成小写，如果输入的不是大写字母则返回原字符。
3.创建一个方法，传入两个整数类型的参数，判断第一个参数是否是第二个参数整数倍数，如果是，则返回 true，否则返回 false。
提示：本质是判断第一个参数是否能被第二个参数整除。
参考代码：
public class MainTest {
public static void main(String[] args) {
int c = t1(45);
System.out.println(c);
char out = t2('B');
System.out.println(out);
boolean b = t3(12, 2);
System.out.println(b);
}
private static int t1(int f) {
return (f - 32) * 5 / 9;
}
private static char t2(char c) {
if (c >= 'A' && c <= 'Z'){
return c += 32;
}
return c;
}
private static boolean t3(int a, int b) {
return a % b == 0;
}
}
十、位运算符（了解）
1.位运算符通常有，按位与 &、按位或 |、按位异或 ^、按位取反 ~ 等一系列基于计算机二进制的运算操作符。
它们的运算规则是：
按位与 &：两位全为 1，结果为 1
按位或 |：两位有一个为 1，结果为 1
按位异或 ^：两位一个为 0，一个为 1，结果为 1
按位取反 ~：0->1，1->0
案例：
int i = 3;//0000 0011
int j = 7;//0000 0111
//0000 0011
System.out.println(i & j);//3
System.out.println(~i);//-4
2.（了解）移位运算符：算术右移>>、算术左移<<、>>>无符右移
byte a = 5;//0000 0101
System.out.println(a<<2);// 0001 0100
使用 String s = Integer.toBinaryString(6) 输出数字的二进制。
十一、分支结构
迄今为止，我们写的代码都是一条一条语句顺序执行，这种代码结构通常称之为顺序结构。然而仅有顺序结构并不能解决所有的问题，比如我们设计一个游戏，游戏第一关的通关条件是玩家获得 1000 分，那么在完成本局游戏后，我们要根据玩家得到分数来决定究竟是进入第二关，还是告诉玩家 “Game Over”，这里就会产生两个分支，而且这两个分支只有一个会被执行。类似的场景还有很多，我们将这种结构称之为“分支结构”或“选择结构”。分支结构分为单分支、双分支和多分支。
语法如下：
1、单分支语法：
if(条件表达式){
语句;
}
2、双分支语法：
if(条件表达式){
语句;
}else{
语句;
}
3、多分支语法：
if(条件表达式){
语句;
}else if(条件表达式){
语句;
}else if(条件表达式){
语句;
}else{
语句;
}
案例：通过运行参数获取两个数并做一个判断，如果两个数相等，则输出 “两个数为：123 他们相等”，否则输出 ： “两个数分别为123,456 他们的差为-333”，运行参数添加如上：
public static void main(String[] args) {
String s1 = args[0];
String s2 = args[1];
int i1 = Integer.parseInt(s1);
int i2 = Integer.parseInt(s2);
if (i1 == i2) {
System.out.println("两个数为：" + i1 + " 他们相等");
} else {
System.out.println("两个数分别为" + i1 + "," + i2 + " 他们的差为" + (i1 - i2));
}
}
三元（目）运算符：
Java 中有一个特殊的三元运算符，它支持条件表达式，当需要进行条件判断时可用它来替代 if-else 语句。它的简洁高效地完成 if else 的功能。其一般格式如下。
条件 ? 表达式1 : 表达式2
案例:
int i = 6;
int j = 1;
System.out.println(i == j ? "相等" : "不相等");
System.out.println(i > j ? "大于" : i < j ? "小于" : "等于");
补充：switch case 一样可以做多分支逻辑，条件表达式数据类型，就和 case 常量表达式一致，否则就会报错。
switch(变量名){
case 常量1:
语句1;
break; //break，表示跳出switch语句
case 常量2:
语句2;
break;
...
case 常量n:
语句n;
break;
default:
语句;
break;
}
Java5 以前 switch(expr)中，expr 只能是 byte、short、char、int。从 Java 5 开始，Java 中引入了枚举类型， expr 也可以是 enum 类型。 从 Java 7 开始，expr 还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。switch 分支语句不支持判断类型即 boolean 类型。
案例：
int i = 6;
switch (i) {
case 6:
System.out.println("周末");
break;
case 7:
System.out.println("周末");
break;
default:
System.out.println("工作日");
break;
}
练习：
1.通过运行参数做一个加法，减法，乘法计算器方法，要求输入三个数，最后一个数字控制程序的算法。（1表示加法，2表示减法，3表示乘法）
如下：
参数：123 12 1，时输出：123 + 12 = 135
参数：123 12 2，时输出：123 - 12 = 111
参数：123 12 3，时输出：123 x 12 = 1476
参数：123 12 4，时输出：参数错误。
2.编写一个输入圆半径 r，计算并返回圆周长。注意判断圆半径 r 是否大于零，如果小于 0 则返回 0。
如：输入：1，输出：6.48
3.编写一个输入圆半径 r，计算圆面积的方法。
如：输入：2，输出：12.56
4.分别利用三目运算符，if-else 完成如下评分业务，学习成绩大于等于 90 分的同学用 A 表示，70-89 分之间的用 B 表示，60-69 分之间的用 C 表示，小于 60 分用 D 表示。
5.利用三目运算符完成求两个数取最大值的方法 int max = max(int a,int b) 和求两个数求最小值的方法 int min = min(int a,int b)。
参考代码：
public class Demo {
public static void main(String[] args) {
t1(args);
double perimeter = t2(4);
double area = t3(4);
}
private static double t3(double r) {
return r * r * 3.14;
}
private static double t2(double r) {
return 2 * r * 3.14;
}
private static void t1(String[] args) {
int method = Integer.parseInt(args[2]);
int i1 = Integer.parseInt(args[0]);
int i2 = Integer.parseInt(args[1]);
if (method == 1) {
System.out.println(i1 + "+" + i2 + "=" + (i1 + i2));
} else if (method == 2) {
System.out.println(i1 + "-" + i2 + "=" + (i1 - i2));
} else if (method == 3) {
System.out.println(i1 + "x" + i2 + "=" + (i1 * i2));
} else {
System.out.println("参数错误");
}
}
private static int max(int i, int j) {
return i > j ? i : j;
}
private static int min(int i, int j) {
return i < j ? i : j;
}
private static String t41(int i) {
return i >= 90 ? "A" : i >= 70 ? "B" : i >= 60 ? "C" : "D";
}
private static String t42(int i) {
if (i >= 90) {
return "A";
} else if (i >= 70) {
return "B";
} else if (i >= 60) {
return "C";
} else {
return "D";
}
}
}
十二、循环结构
如果在程序中我们需要重复的执行某条或某些指令，比如在我们的程序中要实现每隔 1 秒中在屏幕上打印一个"hello，world"这样的字符串并持续一个小时，我们肯定不能够将打印输出这句代码写上 3600 遍，如果真的需要这样做那么编程的工作就太无聊了。
因此，我们需要了解一下循环结构，有了循环结构我们就可以轻松的控制某件事或者某些事重复、重复、再重复的发生。循环控制有通常有如下三种，for、while 与 do-while，这三种循环各自有自己的特点。它们的语法如下：
1、for循环 语法：
for(循环初值;循环条件;步长){
语句; //循环体
}
2、while循环 语法：
while(循环条件){
语句; //循环体
}
特别说明：while循环是先判断在执行语句。
3、do while循环 语法：
do{
语句; //循环体
}while(循环条件);
特别说明：do while循环是先执行，再判断。
案例：三种方式的输出 0 到 5
for (int i = 0; i < 6; i++) {
System.out.println(i);
}
System.out.println("*********************");
int i = 0;
while (i < 6) {
System.out.println(i);
i++;
}
System.out.println("*********************");
i = 0;
do {
System.out.println(i);
i++;
} while (i < 6);
如上便是使用 3 种循环完成从 0 到 5 的输出。
案例：求和 0+1+2+…+100=?
public static void main(String[] args) {
int sum = 0;
for (int i = 0; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
}
练习：
1.鸡兔同笼：上有 35 头，下有 90 足，问鸡兔各多少？编程计算出鸡兔数量为：
鸡：25
兔：10
2.百钱买百鸡：公鸡五钱一只，母鸡三钱一只，小鸡一钱三只，现有百钱欲买百鸡，共有多多少种买法，编程计算出结果为 4 种。
3.乞丐乞讨：天桥有一个乞丐，每天去遵义路天桥要钱，每天要到的钱都是上一天的两倍。如：
- 第一天要了 1 块钱
- 第二天要了 2 块钱
- 第三天要了 4 块钱
- 第四天要了 8 块钱
以此类推， 问： 乞丐干 10 天，收入是多少？请编写代码计算，并标出最终输出结果为：1023。
参考代码：
public class MainTest {
public static void main(String[] args) {
t1();
int count = t2();
System.out.println(count);
int sum = t32();
System.out.println(sum);
}
/**
* 4.乞丐乞讨1
*
* @return 乞讨到的钱
*/
private static int t32() {
int sum = 0;
int temp = 1;
for (int i = 0; i < 10; i++) {
sum += temp;
temp *= 2;
}
return sum;
}
/**
* 3.乞丐乞讨1
*
* @return 乞讨到的钱
*/
private static int t31() {
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += Math.pow(2, i);//数学函数中取 2 的 i 次方
}
return sum;
}
/**
* 2.百钱买百鸡
*
* @return 多少种
*/
private static int t2() {
int count = 0;
for (int i = 0; i <= 100; i++) {
//假设公鸡的数量为 i
for (int j = 0; j < 100; j++) {
//假设母鸡数量为 j，则小鸡数量为：（100-i-j）
if ((i * 5 + j * 3 + (100 - i - j) / 3.0) == 100) {
System.out.println("公鸡：" + i);
System.out.println("母鸡：" + j);
System.out.println("小鸡：" + (100 - i - j));
count++;
}
}
}
return count;
}
/**
* 1.鸡兔同笼
*/
private static void t1() {
for (int i = 0; i <= 35; i++) {
//假设 i 就是鸡的数量，则兔的数量为：35-i
if ((i * 2 + (35 - i) * 4) == 90) {
System.out.println("鸡：" + i);
System.out.println("兔：" + (35 - i));
}
}
}
}
十三、跳转语句
跳转语句是指打破程序的正常运行，跳转到其他部分的语句。在 Java 中支持 3 种跳转语句：break 语句、continue 语句和 return 语句。这些语句将程序从一部分跳到程序的另一部分，这对于程序的整个流程是十分重要的。
1.break 跳出语句
break 语句主要有三种用途。第一，它可以用于跳出 switch 语句，前面的 switch 语句已经使用了该语句。第二，break 语句可以用于跳出离它最近的循环。第三，可以用于大语句块的跳出。
案例：跳出循环
for (int i = 0; i < 10; i++) {
if (i == 5){
break;
}
System.out.println(i);
}
案例：跳出指定循环，如下案例跳出外层循环。
block: for (int i = 0; i < 10; i++) {
for (int i1 = 0; i1 < 10; i1++) {
if (i1 == 5) {
break block;
}
System.out.print(i1);
}
System.out.println();
}
2.continue 继续语句
停止一次循环剩余的部分，同时还要继续执行下次循环。
案例：continue 用法
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue;
}
System.out.println(i);
}
3.return 返回语句
return 语句用于一个方法显示的返回，它把程序的控制权交给方法的调用者。如果是在主函数中 return 则结束整个主函数。
案例：return 用法
public class Hello {
public static void main(String[] args) {
int sum = sum(12, 34);
System.out.println(sum);
}
public static int sum(int i1, int i2) {
return i1 + i2;
}
}
案例：
private static String t41(int i) {
if (i >= 90) {
return "A";
}
if (i >= 70) {
return "B";
}
if (i >= 60) {
return "C";
}
return "D";
}
这就是 break 语句、continue 语句和 return 语句的用法，在后面的项目中我们将继续练习。
练习：
1.编写一个程序用来计算 2～100000 之间的素数的个数，最后输出结果。（素数（prime number）又称质数，有无限个。一个大于 1 的自然数，除了 1 和它本身外，不能被其他自然数整除，如：7 和 11）。
2.设计一个猜数字小游戏，计算机生成出一个 [1,100] 之间的随机数，人输入自己猜的数字，计算机给出对应的提示信息，如：猜大了或猜小了。限制 7 次机会人猜出计算机出的数字。备注：Math.random() 会得到一个 [0,1) 之间的随机浮点数。
参考答案：
import java.util.Scanner;
public class MainTest {
public static void main(String[] args) {
t2();
}
private static void t2() {
int number = (int) (Math.random() * 100 + 1);
Scanner scanner = new Scanner(System.in);
int count = 0;
while (count < 7) {
System.out.println("请输入你猜的数字");
int i = scanner.nextInt();
count++;
if (i == number) {
System.out.println("恭喜你猜对了");
return;
} else {
System.out.println(number > i ? "猜小了" : "猜大了");
}
}
System.out.println("这么简单的问题都不会，好好反审一下自己");
}
private static void t1() {
int count = 0;
for (int i = 2; i < 100000; i++) {
boolean flag = true;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
flag = false;
break;
}
}
if (flag) {
System.out.println(i);
count++;
}
}
System.out.println(" 2～100000 之间的素数的个数共：" + count);
}
}
十四、三大流程整合
三大流程控制分为：顺序（从上往下）、分支（根据条件选择执行的代码块）和循环（重复执行）
在开发过程中，经常会遇到比较复杂的业务逻辑，通常大部分可以由循环加判断完成。如下案例可以完成一个递增数组的样式输出。
最终效果如下：
[ 1, 2, 3, 4, 5, 6, 7, 8, 9,10]
[ 2, 3, 4, 5, 6, 7, 8, 9,10,11]
[ 3, 4, 5, 6, 7, 8, 9,10,11,12]
[ 4, 5, 6, 7, 8, 9,10,11,12,13]
[ 5, 6, 7, 8, 9,10,11,12,13,14]
[ 6, 7, 8, 9,10,11,12,13,14,15]
[ 7, 8, 9,10,11,12,13,14,15,16]
[ 8, 9,10,11,12,13,14,15,16,17]
[ 9,10,11,12,13,14,15,16,17,18]
[10,11,12,13,14,15,16,17,18,19]
案例：递增数组
for (int i = 0; i < 10; i++) {
System.out.print("[");
for (int i1 = 1; i1 <= 10; i1++) {
System.out.print(i1 + ",");
}
System.out.println("]");
}
输出结果，如下:
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
[1,2,3,4,5,6,7,8,9,10,]
1.bug解决最后多出的逗号:
System.out.print(i1 + (i1 == 10 ? "" : ","));
2.每一排依次递增，效果如下:
[1,2,3,4,5,6,7,8,9,10]
[2,3,4,5,6,7,8,9,10,11]
[3,4,5,6,7,8,9,10,11,12]
[4,5,6,7,8,9,10,11,12,13]
[5,6,7,8,9,10,11,12,13,14]
[6,7,8,9,10,11,12,13,14,15]
[7,8,9,10,11,12,13,14,15,16]
[8,9,10,11,12,13,14,15,16,17]
[9,10,11,12,13,14,15,16,17,18]
[10,11,12,13,14,15,16,17,18,19]
3.对齐上面的数字，即位数等于1时后面添加空格。
代码如下：
int out = i1 + i;
System.out.print((out < 10 ? " " + out : out) + (i1 == 10 ? "" : ","));
通过上面的代码，我们便完成递增数组的输出。
练习：
1.超级玛丽：通过运行参数获取玛丽位置，当参数为 5 4 时，用 @ 标出玛丽的位置。如下所示：
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * @ * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
2.数字反转：给出一个 int 类型的有符号整数，将这个整数中每位上的数字进行反转。
示例：
输入：123 输出: 321
输入：-123 输出: -321
输入：120 输出: 21
3.根据如下的框线图开发一个方法，传入 t 变量并返回运算的结果 s。
参考代码：
public class HelloTest {
public static void main(String[] args) throws Exception {
t1(args);
t21(args);
int s = t3(4);
}
private static int t3(int t) {
if (t < 1) {
return 3 * t;
}
return 4 * t - t * t;
}
private static void t21(String[] args) {
int x = Integer.parseInt(args[0]);
int n = 0;
while (x != 0) {
n = n * 10 + x % 10;
x = x / 10;
}
System.out.println(n);
}
private static void t22(String[] args) {
int x = Integer.parseInt(args[0]);
int rev = 0;
while (x != 0) {
int pop = x % 10;
x /= 10;
rev = rev * 10 + pop;
}
System.out.println(rev);
}
private static void t1(String[] args) {
int x = Integer.parseInt(args[0]);
int y = Integer.parseInt(args[1]);
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
System.out.print(x == i && y == j ? " @ " : " * ");
}
System.out.println();
}
}
}
十五、Java 内存模型（自）
java 内存模型（Java Memory Model，JMM）是 java 虚拟机规范定义的，用来屏蔽掉 java 程序在各种不同的硬件和操作系统对内存的访问的差异，这样就可以实现 java 程序在各种不同的平台上都能达到内存访问的一致性。Java 内存模型的主要目标是定义程序中变量的访问规则。即在虚拟机中将变量存储到主内存或者将变量从主内存取出这样的底层细节。
需要注意的是这里的变量跟我们写 java 程序中的变量不是完全等同的。这里的变量是指实例字段，静态字段，构成数组对象的元素，但是不包括局部变量和方法参数（因为这是线程私有的）。这里可以简单的认为主内存是 java 虚拟机内存区域中的堆，局部变量和方法参数是在虚拟机栈中定义的。
1、程序计数器（线程私有）一块较小的内存空间，是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。正在执行 java 方法的话，计数器记录的是虚拟机字节码指令的地址（当前指令的地址）。如果还是 Native 方法，则为空。这个内存区域是唯一一个在虚拟机中没有规定任何 OutOfMemoryError 情况的区域。
2、虚拟机栈(线程私有) 是描述 java 方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。栈帧（ Frame）是用来存储数据和部分过程结果的数据结构，同时也被用来处理动态链接（Dynamic Linking）、方法返回值和异常分派（Dispatch Exception）。栈帧随着方法调用而创建，随着方法结束而销毁——无论方法是正常完成还是异常完成（抛出了在方法内未被捕获的异常）都算作方法结束。
3、本地方法区（线程私有）本地方法区和 Java Stack 作用类似，区别是虚拟机栈为执行 Java 方法服务，而本地方法栈则为 Native 方法服务，如果一个 VM 实现使用 C-linkage 模型来支持 Native 调用，那么该栈将会是一个 C 栈，但 HotSpot VM 直接就把本地方法栈和虚拟机栈合二为一。
4、堆（Heap-线程共享）-运行时数据区是被线程共享的一块内存区域，创建的对象和数组都保存在 Java 堆内存中，也是垃圾收集器进行垃圾收集的最重要的内存区域。由于现代 VM 采用分代收集算法，因此 Java 堆从 GC 的角度还可以细分为：新生代（Eden 区、From Survivor 区和 To Survivor 区）和老年代。
5、方法区/永久代（线程共享）即我们常说的永久代（Permanent Generation），用于存储被 JVM 加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。HotSpot VM把GC分代收集扩展至方法区，即使用Java 堆的永久代来实现方法区，这样 HotSpot 的垃圾收集器就可以像管理 Java 堆一样管理这部分内存, 而不必为方法区开发专门的内存管理器(永久带的内存回收的主要目标是针对常量池的回收和类型的卸载，因此收益一般很小)。 运行时常量池（Runtime Constant Pool）是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。Java 虚拟机对 Class 文件的每一部分（自然也包括常量池）的格式都有严格的规定，每一个字节用于存储哪种数据都必须符合规范上的要求，这样才会被虚拟机认可、装载和执行。
章节练习：（默写 30 分钟）
1.利用双层循环输出下面的正方形。
* * * * * *
* * * * * *
* * * * * *
* * * * * *
* * * * * *
* * * * * * <br>
2.利用双层循环输出下面的直角三角形。
*
* *
* * *
* * * *
* * * * *
* * * * * * <br>
3.利用循环输出下面的九九乘法表，要求行列对齐。
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 <br>
4.要求运行时参数中输入三个整数
如：3 5 1（最后一个数字用来控制执行的算法） 1：加法，2：减法，3：求平均数，4：输出最大一个数
5.从运行时参数中获取一个整数 n，计算
累加和：1+2+3+…+n 的结果。
如：输入 10 时，输出为 55；
6.求闰年：
①、普通年能被 4 整除且不能被 100 整除的为闰年。（如2004年就是闰年，1901年不是闰年）
②、世纪年能被400整除的是闰年。(如2000年是闰年，1900年不是闰年) 运行时参数获取年份并判断是不是闰年。
7.编写一个 Java 程序计算
即 1！+2！+3！+……+10！的和。 注意：8！=8765432*1
运算结果为：4037913
8.水仙花数：利用循环和判断打印出所有的水仙花数，所谓水仙花数是指一个三位数，其各位数字立方和等于该数本身。
例如： 153 是一个 "水仙花数 "，
因为 153 = 1 的三次方＋5 的三次方＋3 的三次方。
9.判断字符：有一行字符，其中包含各种字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
注意：字符串可以通过 toCharArray() 方法获取字符串的字符数组，数组都拥有 length 的属性可以获取数组的长度。
10.利用循环计算 9 + 99 + 999 + 9999 +…+999999999 的值为：1111111101。
参考代码：
public class HelloTest {
/**
* 1.正方形
*/
public static void t1() {
for (int i = 0; i < 6; i++) {
System.out.println();
for (int j = 0; j < 6; j++) {
System.out.print("*" + "\t");
}
}
}
/**
* 2.等腰直角三角形
*/
public static void t2() {
for (int i = 0; i < 6; i++) {
System.out.println();
for (int j = 0; j <= i; j++) {
System.out.print("*" + "\t");
}
}
}
/**
* 3.乘法九九表
*/
public static void t3() {
for (int i = 1; i <= 9; i++) {
System.out.println();
for (int j = 1; j <= i; j++) {
System.out.print(i + "x" + j + "=" + i * j + "\t");
}
}
}
/**
* 4.小计算器
*/
public static void t4(String[] args) {
String s1 = args[0];
String s2 = args[1];
String s3 = args[2];
int i1 = Integer.parseInt(s1);
int i2 = Integer.parseInt(s2);
int i3 = Integer.parseInt(s3);
if (i3 == 1) {
System.out.println(i1 + "+" + i2 + "=" + (i1 + i2));
} else if (i3 == 2) {
System.out.println(i1 + "-" + i2 + "=" + (i1 - i2));
} else if (i3 == 3) {
System.out.println((i1 + i2) / 2);
} else {
System.out.println(i1 >= i2 ? i1 : i2);
}
}
/**
* 5.累加求和
*/
public static int t5(String[] args) {
int n = Integer.parseInt(args[0]);
int out = 0;
for (int i = 1; i <= n; i++) {
out += i;
}
return out;
}
/**
* 6.求闰年
*/
public static void t6(String[] args) {
String s = args[0];
int n = Integer.parseInt(s);
if (n % 100 == 0 && n % 4 == 0) {
System.out.println(n + "年是闰年");
} else if (n % 100 != 0 && n % 4 == 0) {
System.out.println(n + "年是闰年");
} else {
System.out.println(n + "年不是闰年");
}
}
/**
* 7.阶乘和
*/
public static int t7() {
int sum = 0;
for (int i = 1; i <= 10; i++) {
int out = 1;
for (int j = i; j >= 1; j--) {
out *= j;
}
sum += out;
}
return sum;
}
/**
* 8.水仙花数
*/
public static void t8() {
for (int i = 100; i < 1000; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100;
if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i){
System.out.println(i);
}
}
}
/**
* 9.判断字符
*/
public static void t9() {
String args = "Aar bgs [0]1231";
char[] chars = args.toCharArray();
int sum = 0;
int al = 0;
int nulls = 0;
int other = 0;
for (int i = 0; i < chars.length; i++) {
if (chars[i] >= '0' && chars[i] <= '9') {
sum++;
} else if ((chars[i] >= 65 && chars[i] <= 90) || (chars[i] >= 97 && chars[i] <= 122)) {
al++;
} else if (chars[i] == ' ') {
nulls++;
} else {
other++;
}
}
System.out.println("数字的个数是：" + sum);
System.out.println("字母的个数是：" + al);
System.out.println("空格的个数是：" + nulls);
System.out.println("其他字符的个数是：" + other);
}
/**
* 10.九九累加
*/
public static int t10() {
//9个9
int sum = 10;
int out = 0;
for (int i = 1; i <= 9; i++) {
out += (sum - 1);
sum *= 10;
}
return out;
}
}
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
