目录
1.循环可以通过人为输入某些特定数据来改变循环条件，从而停止循环
编程语言
1.语言
机器语言←低级语言 高级语言→Java、PHP、C、C++等
机器可以识别运行的二进制语言 ← （编译器）编译 ←人可识别或者书写的语言
- 解释（动态语言/脚本语言）：一边翻译为二进制一边运行。
- 编译与解释：编译器编译为中间状态的字节码，由解释器一边翻译一边运行。
2.编译运行过程
- 程序员编写的Java源文件(.java)首先要经过编译，生成字节码文件(.class)
- Java程序的运行需要JVM的支持。JVM是一个软件，安装在操作系统中，为字节码文件提供运行环境。
Java源文件.java → Java字节码文件.class → JVM → 操作系统
3.关于JDK、JRE、JVM
- JDK ---Java Development Kit (Java开发工具包) *开发一个java程序的最小环境
- JRE--- Java Runtime Environment (Java运行环境) *运行一个java程序的最小环境
- JVM ---Java Virtual Machines (Java 虚拟机)
①JDK目录结构
②环境配置
注： JAVA_HOME --JDK主目录 Path----JDK的bin目录
4.为什么选择java？
①Java是一门跨平台、“半解释半编译”的“面向对象”语言。
②优点突出：
- 面向对象
- 半截是半编译
- 开源
- 简单
- 多线程
- 安全
- 跨平台 -------安装Java后，再安装的JVM(Java Virtual Machine称为Java虚拟机)，它会解释源文件编译过后的.class字节码文件。此JVM能够在不同的平台上正常运行。
第一个Java 程序
千里之行，始于此。
public class HelloWorld{
public static void main(String[] args){
System.out.printIn( “HelloJava”);
}
}
非常简单的一串输出特定字符的代码。而更重要的是了解java编译的流程。
①以下为通过cmd进行javac命令，把以上代码编译为中间态——字节码。
②通过java命令运行字节码文件，得到结果
但用此方法书写更加复杂的程序效率非常低，且多有不便，因此我们使用了专业的编译软件IDEA协助编译。
安装步骤非常简单，在此略过。
认识IDEA
首先要明白自己手中的“工具”是做什么的，如何使用。
创建一个新工程后，找到源码目录，新建 package→新建class，就可以开始书写我们第一个java程序了。
数据类型
1.原始类型
整型
类型 字节大小 取值范围 byte 1字节（8位） -128~127 short 2字节（16位） -32768~32767 int 4字节（32位） -2147483648~2147483647 long 8字节（64位） -2^63~2^63-1
注：取值范围可通过对应的二进制位数来确定，但其中首位为符号位。
在long类型中，由于java默认直接量为int类型，输入超出int类型的数据时，需要在数据后添加“ L ”，来提醒输入的数据是long类型。
浮点型
类型 字节大小 取值范围 精度 float 4字节 0-3.403E38 单精度 double 8字节 0-1.798E308 双精度
注：E代表的是10 E后面的数字是10的指数。
double 的精度高于float，因此在精度计算较高的场合，常用double。
由于浮点型存在舍入，因此计算结果有微小误差是正常情况。
| 类型名 | 字节大小 | 范围 |
| char | 2字节（16位） | 详见ASCII码表 |
注：char仅能插入一个字符，且需要用单引号（ ‘ ）。eg：char a=‘ 梦 ’；
| 类型名 | 所占字节大小 | 范围 |
| boolean | 1字节 | True--False |
注：boolean类型较为特殊，它有且仅有两个取值，并且不能和其他类型转换。不能赋值除true和false以外的值。
2.引用类型
| 类型名 | 表达方法 |
| 数组 | 原始类型名 [] |
| 类 | class |
| 接口 |
注：数组书写方式多样，若想规定其中的元素，用“{ ，， }”就行。
创建数组必须规定数组长度，数组中的元素下标是从0开始的。
3.类型转换
- 自动类型转换：小字节类型数据可以直接转换为大字节类型数据，通常会自动转换。
int ia=12;
double da=ia;//自动转换为double类型。
System.out.println("da="+da); //da=12.0
char cb='A';
int ib=cb; //自动转换为对应整形的ASCII码
System.out.println("cb="+cb); //cb=65- 强制类型转换：将大字节类型转换为小字节类型，不会自动转换，且会因数据超过小字节类型范围而引发”溢出“。
double big=13.22； int small=(int)big; System.out.println("small="+small); //small=13
变量
1.变量的概念
保存数据的内存区域，其中的数据可以变化。
2.定义变量
语法： 数据类型+变量名（=赋值）； eg：int a（=1）；
注：整数默认为int，小数默认为double。
变量需要定义，才能被使用。
运算符
1.算数运算符
| 符号 | 名称 | 作用 |
| + | 加 | 数值型数据计算和、拼接字符串 |
| - | 减 | 数值型数据相减 |
| * | 乘 | 数值型数据相乘 |
| / | 除 | 数值型数据相除 |
| % | 取余 | 数值型数据相除，取余数 |
注：如果有大数据类型参加运算，结果类型一定是参与运算的最大类型的数据类型。
整型数据之间的运算，结果为整型（除法没有余数表示）
2.逻辑运算符
| 符号 | 名称 | 用法 |
| && | 逻辑与 | 全真为真，有假为假 |
| || | 逻辑或 | 全假为假，有真为真 |
| ！ | 逻辑非 | 真假颠倒 |
注：&&和||也是”短路运算“，如果能通过第一个表达式决定结果，则不用判断第二个。
3.赋值运算符
| 符号 | 名称 | 类型 | 作用 |
| = | 赋值 | 赋值运算符 | 将右侧变量或表达式赋值给左侧变量 |
| += | 加等于 | 复合运算符 | a+=1→a=a+1 |
| -= | 减等于 | a-=1→a=a-1 | |
| *= | 乘等于 | a*=1→a=a*1 | |
| /= | 除等于 | a/=1→a=a/1 | |
| %/ | 取余等于 | a%=1→a=a%1 |
注：=为赋值运算符，而==是等于比较判断。
4.自增、自减运算符
| 符号 | 名称 | 作用 |
| ++ | 自增1 | 结果+1 |
| -- | 自减1 | 结果-1 |
注：++或--独立成行使用，无论符号在前在后，结果都将+/-1
非独立成行时，++a表示先+1再进行其他运算a++表示先进行其他运算再+1
5.条件运算符
语法格式：表达式a？表达式b：表达式；
- 也称三目表达式，必须有三个表达式参与。==if的双分支语句。
- 顺序：运算表达式a，为真则执行表达式b，为假则执行表达式c
6.运算符的优先级
小括号>单目运算>算术运算符>关系运算符>逻辑运算符>条件运算>赋值/复合赋值运算符
条件语句
1.if
满足条件时执行大括号里语句
if(判断条件){ //单分支if语句
if(){
执行语句 //if嵌套
}
}else if(判断条件){ //多分支if语句
return; //不再执行后续代码，结束程序。
}else{ //其余条件都不满足，执行
执行语句
}注：嵌套不应过多，影响可读性和整洁性。
2.switch
经一个确切的变量值选择对应的语句执行。
switch(a){ //要判断的变量，只能是非long整型、字符型char和字符串String和枚举类型
case 1:
执行语句; 如果变量的值与当前case的值匹配，执行这里的代码
break;//结束switch
case 6:
执行语句;
case 8:
执行语句;
break; //若没有break，程序会一直执行直到没有代码或遇到break；这里若是a=6，则会从case6运行到这里。
default:
执行语句； //若没有任何值和变量的值匹配，执行此代码
break;
}注：switch的贯穿性：如果多个case后执行的内容一致，可以省略break，将统一要做的代码放在最后的case后。
循环语句
1.while 与 do-while
while(循环条件){
满足循环条件时重复执行的代码;
}
do{
满足循环条件时重复执行的代码;
}while(循环条件);注：whlie循环可以不执行，但do-while循环至少会执行一次。
2.for
for(定义循环变量;判断循环条件;循环变量更新){
循环体;
for(定义循环变量;判断循环条件;循环变量更新){ //循环嵌套
循环体;
}
}注：可以使用外部定义的循环变量
可以在循环体重更新循环变量
3.死循环
没有指明结束条件的情况，即循环条件恒为ture，会造成死循环（循环一直持续，不会停止）。
循环控制
1.停止（break 和 return）
- 所有的循环都可以使用break和return停止循环。
- break是停止循环后，继续执行循环之外的内容。
- return是结束方法，不再执行return之后的内容。
2.跳过本次循环（continue）
- 在循环语句中，使用continue，可以停止本次循环，不再执行continue之后的代码，直接进行下一次循环。
数组
Q：什么是数组：
A：数组是相同数据类型的元素组成的集合 ，元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素； 除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）,可以通过元素所在位置的顺序号（索引）做标识来访问每一个元素（索引从0开始，最大到元素的个数-1）
1.定义数组
数据类型[ ] 数组名 eg： int[ ] arr;
数据类型 数组名[ ] eg. int arr[];
*定义数组后，不初始化数组，将无法使用。
2.初始化数组
语法：数组名=new 数据类型[数组大小]；
int[] arr;//定义数组
arr = new arr[3];//初始化
int a[]=new int[3];//定义和初始化同时进行3.赋值
数组也需要赋值，若不赋值，则会有默认的初始值。
//动态赋值
//语法：数组名[索引] = 值
int[] arr = new int[5];
arr[0]=1;//索引从0开始
arr[4]=5;//索引最大值为数组长度（数组名.length）-1，超出会抛出数组越界异常
/***************************************************/
//静态赋值
//语法1：数据类型 [] 数组名 = new 数据类型[]{元素1，元素2,...}
int[] arr = new int[]{1,2,3,4};
//语法2：数据类型 [] 数组名 = {元素1，元素2,...}
int[] arr = {2,4,6,8}初始默认值
| 数组数据类型 | 默认值 |
| 整型 | 0 |
| 浮点型 | 0.0 |
| 布尔型 | false |
| 字符型 | 空白字符 |
| 引用类型 | null |
注：
- 数组一旦初始化后，数组大小不能改变，其中的元素类型要统一。
- 数组的索引范围是[0,数组大小-1]，使用时不能超出范围。在编译时无法识别是否超出数组索引，但运行时会抛出"数组索引溢出"异常。
*数组的读取可以通过 数组名[索引] 来调取，灵活运用循环可以读取多个数据。
数组的排序
1.数组元素交换位置
// 1. 创建整形数组
int[] arr = new int[]{10,15,8,40,25,5};
// 2. 把数组中最大的数据值移动到最末位。
for(int i=0 ; i <= arr.length -2 ; i ++){
if(arr[i] < arr[i+1]){ // 当前元素 小于 下一个元素， 不交换位置， 反之交换位置
continue; // 跳出本次循环
}else{
int temp = arr[i];
arr[i] = arr[i+1]; //数据的交换
arr[i+1] = temp;
}
}2.冒泡排序法
int[] arr = new int[]{10,15,8,40,25,5};
// 1. 升序排序
for(int i= 0 ; i < arr.length - 1 ; i++ ){
for(int k = 0 ; k < arr.length - 1 ; k++){ // k = 0 ， 1，2， 3，4， k+1 = 1,2,3,4,5
if(arr[k] < arr[k+1]){
continue;
}else{ // 下一个小，就交换位置
int temp = arr[k];
arr[k] = arr[k+1];
arr[k+1] = temp ;
}
//2.降序
if(arr[k] < arr[k+1]){
int temp = arr[k];
arr[k] = arr[k+1]; //升序的if判断交换
arr[k+1] = temp ;3.数组排序函数sort
import java.util.Arrays;
/* ··· */
String[] names ={"tom","cat","jerry"};
Arrays.sort(names);
System.out.println( Arrays.toString(names) ); 4.数组的赋值和扩容
复制：JDK提供对数组进行复制的方法，即将一个数组（源数组）中的各个元素值复制到另一个数组（目标数组）中：
| System. | arraycopy | src, | secPos, | dest, | destPost, | length |
| 要复制的源数组 | 从原数组复制的起始位置 | 复制的目标数组 | 复制道目标数组中的起始位置 | 要复制的袁术个数 |
扩容：数组的长度在创建后不可以改变的。所谓“扩展”是指创建一个更大新数组，并将原有数组的内容复制到其中。 Jdk提供了一个方法，Arrays.copyOf 可以实现数组的“扩容”
| Big= | Arrays.copyOf | small, | small.length+n |
| 扩展后数组 | 原数组 | 扩展后长度 |
一部分学习中的所得
1.循环可以通过人为输入某些特定数据来改变循环条件，从而停止循环
未利用break和return；
在做”收银台“作业时，实际生活中收银不会只收银一次就结束程序，而是一直循环整个收银流程，类似于”死循环“，直到下班了（输入特定数据），来终止循环。
System.out.println("收银中：");
//循环开始
int flag=1;
while(flag==1) {
System.out.println("等待商品单价输入：(元)");
double prize = sc.nextDouble();
System.out.println("请输入数量：");
double number = sc.nextDouble();
System.out.println("本次应收：" + (prize * number) + "元");
System.out.println("等待付款金额：");
double money = sc.nextDouble();
if (money < (prize * number)) {
System.out.println("金额不足。清补足" + (prize * number - money) + "元");
System.out.println("等待金额补足：");
double bz = sc.nextDouble();
System.out.println("找零" + (money + bz - prize * number) + "元");
System.out.println("交易成功！");
} else {
System.out.println("找零：" + (money - prize * number) + "元");
System.out.println("交易成功！");
}
if(prize==0&&number==0&&money==0){
flag=0; //循环停止
}
}
2.根据输入数字n，求得9+99+...，n为9的个数。
System.out.println("2.求和：");
System.out.println("请输入9的个数：");
int num9= sc.nextInt();
long total9=0;
long tempt=9;
long tempt2=0;
if (num9==1){
System.out.println("答案是9.");
}
for (;num9>1;num9--){
tempt2=tempt; //9 99
tempt=10*tempt+9; //99 999
total9=tempt2+total9; //9+99 99+999
}
System.out.println("答案是："+total9);
//更优解法 使用Math.pow()
long all9=(long)(Math.pow(10,num9)-1); //Math.pow()默认为double，需要强制类型转换
//此处为计算出n个数位的9
for(;all9>0;){
total9+=all9; //求和
all9/=10; //整数之间相除，取整，相当于减少一位9，同时改变判断变量。
} //当9/10=0==all9 不满足循环条件all9>0,结束循环
System.out.println("Sum="+total9)l;
最开始困惑于如何把输入的数字转换为9的位数，用较多变量交换数据达成从9一直加到所需，占用变量多，计算比较复杂，代码整洁度不高，编写时经常把自己绕晕。
后来学习了Math.pow()的方法，整个计算就变得非常简单易懂，节省了变量，整洁性也非常高。
3.验证身份证合法性（利用数组 & toArray() ）
System.out.println("作业3：验证身份证号码合法性");
/*从控制台输入一个18位身份证号码，验证身份证号码的合法性。
验证规则:
1、将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数(coefficient)分别为:
7-9-10-5-8-4-2-1-6-3-7 -9-10-5-8- 4 - 22 将这17位数字和系数相乘的结果相加。
3、用加出来和对11取余，得到余数。
4、通过余数获取校验位。校验位(check)为:
1 - 0-x -9-8-7 -6 - 5 - 4- 3 -2。
5、将获取校验位与身份证最后一位对比，相同则合法，反之不合法。*/
Scanner sc=new Scanner(System.in);
int sum=0;
int e=0;
int d=0;
int check[]={1,0, 120,9,8,7,6,5,4,3,2}; //校验,x的ascii码为120
int sfz[]=new int[18];
int coe[]={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,22};
for (int i=0;i<=16;i++){
System.out.println("请输入身份证号码第"+(i+1)+"位：");
int a=sc.nextInt();
sfz[i]=a;
int b=sfz[i]*coe[i];
sum+=b; //系数和相乘的结果相加
d=sum%11; //求余
e=check[d]; //获取校验位
}
int c=sc.nextInt();
if (c==e){
System.out.println("身份证合法");
}else {
System.out.println("身份证不合法");
}
//更优解
//身份证数据：
/*int[]id17={5,0,0,3,8,1,2,0,0,1,0,1,2,3,4,2,1}; //身份证号码的前17位
char id18='X'; //最后一位*/
Scanner sc=new Scanner(System.in);
String next=sc.next();//字符串输入
System.out.println("输入身份症号：");
char[] id=next.toCharArray(); //toString-转为字符串
//toCharArray-转为字符数组
int[] id17=new int[17];
for (int i=0;i<id17.length;i++){
id17[i]=id[i]-48; //参考ascii码
}
char id18=id[id.length-1];//身份证号码最后一位
//2.系数
int[]datas={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
//3.校验位
char[] valids={'1','0','X','9','8','7','6','5','4','3','2'};
//4.累加算法
int sum=0;
for (int i=0;i<id17.length;i++){
sum+=id17[i]*datas[i];
}
//5.取余
int yu=sum%11;
//6.余数作为valids数组的下标，获取到数组元素
char data=valids[yu];
if (data==id18){
System.out.println("V");
}else {
System.out.println("X");
}编写方法大同小异，我自己的方法是利用循环一位一位的进行相应的计算，在最后一位进行char到int的类型转换，通过ASCII码来解决一部分身份证末尾为X的情况，输入繁琐。
利用数组 并且使用toArray()，将输入的数据转化为字符串,利用数组特性来进行有序的、便捷的计算，输入次数大幅减少。
个人总结
以上就是Java基础阶段的学习，有以往在校学习的基础，本次阶段学习较为轻松，也很快就掌握了，但是也发现了对于一部分java提供的方法掌握不熟练、不清楚，导致自己在编写代码的时候走了不少弯路，用一个小本本把这部分记下来，时常回看，加强记忆。
个人自觉在编写时并不能非常熟练的写下代码，偶尔会有语法错误，还得不断练习，加强记忆和理解。
515
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
