java for循环如何递归 java for循环顺序

Java1

环境介绍

最初sun公司用于智能家电设计（oak语言），J2SE（单机应用程序），J2ME（移动端Java应用-----安卓，已经寄了。。。），J2EE（web开发）

JDK（java developer kits） ：Java开发者工具集

JRE（java runtime environment）：Java运行时环境

JVM（java virtual machine java）：Java虚拟机

语言特性

1. 高级语言
1. 编译语言（先编译后运行）：编译前后缀（.java）编译后后缀（.class）
1. 可移植性强，跨平台性强：一次编译，到处执行（JVM）

配置环境变量

1. path：cmd会在path存储的目录里进行寻找（ %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin; ）
1. classpath：让java能找到编译之后的（.class文件）路径位置（ .;%JAVA_HOME%/lib;%JAVA_HOME%/lib/tools.jar ）
1. java_home：存储JDK目录位置（ C:\software\jdk1.8.0_181 ）

// 测试代码
public class HelloWorld{                       // 文件名要和类名一致，且类名首字母需要大写(大驼峰命名)
	public static void main(String[] args){   // 主方法，所有java都会从主方法开始运行
		System.out.println("Hello World!");  // 输出字符串
	}
}

// 运行方法（控制台）
// 先编译，生成.class文件（javac + 文件名(.java)）
// 运行文件，运行的其实是生成的类（java + 类名（不加后缀））

开发规范

Java指令负责在.class文件中，查找相关类的数据，并执行这个类的main方法，Java文件中允许多个类存在，编译过程中，每一个类都会单独编译。

开发规范要求，一个Java文件里只能有一个类，且必须于文件名一致。

命名规范

Java中变量的概念

Java本身是一个强类型语言，在变量声明的时候，必须定义变量的数据类型

1. 只有数字，字母，下划线，$ 可以作为变量的命名组成，并且不能以数字开头，中文也可以做变量名（最基础的编译要求）
1. 不建议使用中文，纯下划线，变量不能以下划线开头
1. 不建议使用拼音，首字母缩写，或者是拼音 + 中文
1. 建议使用英文单词进行命名
1. 变量名使用小驼峰命名，类名使用大驼峰命名
1. 见名知意

a = 1; // 错误，没有定义数据类型，编译报错
int a = 1; // 正确，通过编译
int _robot01_ = 1; // 能编译，不符合规范

数据类型（8种基本数据类型）

4种整型（byte，short，int，long）

byte（-2^7 ~ 2^7-1）：8位二进制数，第一位符号位，后七位存数据，占一个字节（8bit）
	short （-2^15 ~ 2^15 -1）：16位二进制数，第一位符号位，后15位存数据，占两个字节（16bit）
	int （-2^31 ~ 2^31 -1）：32位二进制数，第一位符号位，后31位存数据，占四个字节（32bit）
	long （-2^63 ~ 2^63 -1）：64位二进制数，第一位符号位，后63位存数据，占八个字节（64bit）

小类型转大类型：几乎没有风险，一般自动转化

大类型转小类型：强制类型转换，可能发生数据溢出

// 字面量和变量的数据类型是分开的
long tmp = 2147483648; // 出现数据溢出错误，字面量默认通过int类型存储
long tmp = 2147483648L; // 不会出现数据溢出，字面量使用long类型存储

2种浮点型（float，double） + 高精度数（bigdicimal）

浮点型所存储的范围要远大于整型，所有小数的字面量，默认使用 double 类型存储，浮点型的运算会很慢且会出现误差

float 单精度浮点型：一共有32位，占据四个字节，指数部分位8位，尾数部分位23位，符号位1位
		float 和 int 类型：位数相同，但是float 的数据范围要远大于int 类型，但精度小于int 类型。
	double 双精度浮点型：一共有64位，占据八个字节，指数部分11位，尾数部分52位，符号位1位
		double 和 long 类型：差异同 float 和 int

小类型转大类型时，需要注意可能出现的精度丢失问题！！！！

// 由于所有小数的字面量，默认使用 double 类型存储
float tmp = 1.1; // 报错，显示精度丢失，编译失败
// 因此在定义浮点变量时要标记字面量的数据类型
float tmp = 1.1f; // 正常编译
double tmp = 1.1d; // 正常编译

1种布尔型（boolean）

true / false 常用于运算表达式，没啥好写的

1种字符型（char）

字符类型，只能存储一个字符（单一字符集的单一字符），只限制字符数量，不限制字符类型

// 使用char类型存储单引号（'），使用转义字符（\）
char tmp = '\'';
// 使用char类型存储转义字符（\）
char tmp = '\\';
// Java底层使用 Unicode 进行字符集编码，（\u0000 空字符）
char tmp = '\u0000';

运算符

加减乘

正常运算方式

除（\）

// 整型运算，去尾
int a = 4;
int b = 10;
 // 去尾结果为2

自增，自减（++ , --）

System.out.println(tmp++); // 先输出tmp，在进行自增操作
System.out.println(++tmp); // 先输出tmp，在进行自增操作

关系运算符

// 非，或，与
// || 和 | 连接的左右两边的运算表达式都为false，总结果为false
// && 和 & 连接的左右两边的运算表达式都为true，总结果为true

// || 短路于 && 短路或，如果符号左边的运算表达式，已经能决定整个结果，右边的表达式就会跳过
int tmp1 = 1;
int tmp2 = 2;
int tmp3 = 3;
System.out.println((tmp2 < tmp1) & (tmp3++ < tmp1++)); // 因为右边的表达式没有被跳过，所以tmp3和tmp1都会自增
System.out.println((tmp2 < tmp1) && (tmp3++ < tmp1++)); // 因为右边的表达式会被跳过，所以tmp3和tmp1不会自增

位运算符

// 按位与运算 &
System.out.println(10 & 8); // 先转换二进制，1010 & 1000 = 1000 结果为8
// 按位或运算 |
System.out.println(10 | 8); // 先转换二进制，1010 | 1000 = 1010 结果为10
// 按位异或运算 ^
System.out.println(10 ^ 8); // 先转换二进制，1010 ^ 1000 = 0010 结果为2
// 按位取反 ~
System.out.println(~10); // 先转换二进制,添加符号位，按位取反，再进行补码运算得出结果，结果为-11 
// 左移(<<)右移(>>)运算
System.out.println(2>>2); // 结果0
System.out.println(2<<2); // 结果8s

顺序结构，分支结构，循环结构

分支结构

1. switch（必须添加break！）

int leval = 1;
switch(leval){
    case 1:
    	System.out.println("1");
        break;
    case 2:
        System.out.println("2");
        break;
    case 3:
        System.out.println("3");
        break;
    default:
        System.out.println("else");
}

1. if else（经典分支条件判断）（不建议多层嵌套）
   基本数据类型使用 == 进行判断，但引用数据类型（string）通过 equals 方法进行比对

String name = "robot01";
if(robot01.name("robot01")){
    System.out.println("Welcome back! robot01! ");
}
else if(robot01.name("robot02")){
    System.out.println("Welcome back! robot02! ");
}
else{
    System.out.println("Who are you? ");
}

循环结构

用三种循环结构，求1~100 的和：

1. for

int res = 0;
for(int i = 0; i <= 100; i++){
    res += i;
}
System.out.println(res);

1. do while

int res = 0;
int i=0;
do{
    res += i++;
}while(i<=100);
System.out.println(res);

1. while

int res = 0;
int i=0;
while(i<=100){
    res += i++;
}
System.out.println(res);

1. break & continue
   break：退出当前循环
   continue：跳过当前层循环，进入下一层循环

// 常用于多层循环嵌套
loop: // 给当前循环起一个名称
for(int i=0;i<50;i++){
    if(i%2 == 1){
        continue loop; // continue 不加名称，跳过当前循环，continue加名称，跳过指定循环
    }
}
//=============================
int res = 0;
loop:
for(int i=1;i<=50;i++){
    if(i%3 == 0 && i%5 == 0 && i != 15){
        res = i;
        break loop;
    }
}
System.out.println(res);