第一天
1.Linux:
开源操作系统、免费的，服务器端
目录(/根目录),挂载点(目录),高
基于命令的----pwd,ls,cd
绝对路径、相对路径
2.java运行环境:
.java，经过编译，生成.class字节码文件
jvm加载.class并运行.class
跨平台，一次编程到处使用
JVM:java虚拟机
JRE:java运行时环境
JRE=JVM+java系统类库
JDK:java开发工具包
JDK=JRE+编译、运行等工具
3.eclipse
Linux分两种:
1.带图形界面的------为了便于你们操作
2.不带图形界面的----真正的服务器的操作系统
Windows--------公司中的是
Linux----------java程序写好后配到服务器
补充知识点：
1.Linux目录结构
Windows操作系统的目录结构，是以盘符为单位，C盘、D盘、E盘等等，数据存储在各个盘符之下，而Linux操作系统最顶层只有一个根目录root，所有文件都存储在这一个根目录之下。
Windows操作系统若插入一个外部设备（U盘等），在系统中是多了一个盘符H，对H盘的操作就是对外部设备的操作。Linux操作系统是在根目录root下有一个名叫mnt的子目录，在这个目录下，会出现一个目录，假设为sdcard，称之为挂载点，对它的操作就是对外部设备的操作。
Windows操作系统某用户登录系统后，对所有文件都具有增删改查的权限，即：可以操作任意目录，假设将C盘下Windows目录删除，则会导致系统异常，安全性较差。Linux操作系统对权限要求比较严格，用户登录后并非对所有目录具有增删改查权限，默认的当前目录为根目录下的home目录下的soft01，称之为主目录，对这个目录具有最高权限，其余目录文件一般都是只读的，不能随意删除，这样就保证了安全性。
2．Java程序遵循着先编译、后执行的原则。首先，通过javac命令将JAVA源程序（.java文件）编译为JAVA字节码（.class文件），而后，通过java命令启动JVM，由JVM来加载.class文件并运行.class文件。
3.系统类库即为java提前封装好的功能类，只需拿来直接使用即可，可以大大的提高开发效率。
4. JVM就是一个软件。它是用软件“虚拟”出的一个硬件机器。和真实的硬件机器一样，这个“虚拟机”定义有指令集、寄存器、存储区等细节；而Java字节码可以看成是在这个“虚拟机”上运行的机器码。正是由于Sun定义了JVM规范，而且不同的操作系统提供了不同的JVM实现，才使得相同的一个字节码文件可以在不同的系统上运行（当然这些系统必须安装有适用于该系统的JVM），从而使Java赢得了“一次编译，到处使用”的称谓。JVM是用本地C实现的，所以，Linux系统和Windows系统使用的JVM不同。
5. 名词解释JVM、JRE、JDK
JVM （Java Virtual Machine）称之为Java虚拟机，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台上不加修改地运行。JVM在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。
JRE（Java SE Runtime Environment）称之为Java SE运行时环境，提供了运行Java应用程序所必须的软件环境，包含有Java虚拟机（JVM）和丰富的类库（Libraries）。运行一个已经开发好的Java应用必须安装JRE。
JDK（ Java Development Kit）称为Java开发工具包，是JRE的超集，或者说JDK包含了JRE。JDK中除了包含有JRE的所有内容之外还提供了编写Java程序所必须的编译器和调试工具等。对于进行Java开发的人士一般需要下载JDK，目前的主流版本为JDK 6。
6. 在Linux系统下可以使用./eclipse启动执行程序eclipse
第二天
1.变量:存数的，代词，指代的就是它所存的那个数
1)声明:
int a; //声明一个整型变量，名为a
int b,c,d; //声明三个整型变量，名为b,c,d
2)命名:
2.1)只能包含字母、数字、_和$符，
并且不能以数字开头
2.2)严格区分大小写
2.3)不能使用关键字
2.4)可以中文命名，但不建议
建议:见名知意、驼峰命名法
3)初始化:第一次赋值
3.1)声明同时初始化
int a=250;
3.2)先声明后初始化
int a;
a=250;
4)使用:
4.1)必须与数据类型匹配
int a=25.678; //编译错误，类型不匹配
4.2)对变量的操作就是对那个数的操作
int a=5,b=10;
int c=a+b; //取出a中的5，加上b中的10，赋值给c
System.out.println(c); //输出c中的那个数15
4.3)变量用之前必须声明并初始化
System.out.println(m); //编译错误，变量未声明
int m;
System.out.println(m); //编译错误，变量未初始化
int m=250;
System.out.println(m); //正确
2.基本数据类型:
1)int:整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认为int型，若超范围则编译错误
1.2)两个整数相除，结果还是整数，小数位无条件舍弃
1.3)运算时，若超出int范围，则溢出----需要避免
2)long:长整型，8个字节，很大很大很大
2.1)long类型的直接量为数字后加L或l
2.2)运算时若有可能超范围则设置第一个数加L
2.3)System.currentTimeMillis();
获取自1970.1.1零时到此时此刻的毫秒数
3)double:浮点型，8个字节
3.1)小数直接量默认为double型
3.2)double有舍入误差，精确运算场合不可使用
4)boolean:布尔型，1个字节
4.1)只能取值为true和false
5)char:字符型，2个字节
5.1)采用unicode编码格式，每个字符对应一个码
ASCII码--‘a‘(97) ‘A‘(65) ‘0‘(48)
5.2)字符需放在一对单引号中
必须有并且只有一个
5.3)特殊符号需使用\来转义
3.数据类型间的转换:
类型从小到大如下所示:
byte-short-int-long-float-double
char--
1)两种方式:
1.1)自动类型转换:从小类型到大类型
1.2)强制类型转换:从大类型到小类型
强转可能会溢出或精度丢失
2)两点规则:
2.1)整数直接量可以直接赋值给byte,short,char， 但不能超范围
2.2)byte,short,char类型变量参与运算时，
先一律转换为int再运算
4.Scanner的用法:
1)在package下:
import java.util.Scanner;
2)在main的{}中:
Scanner scan = new Scanner(System.in);
3)在第2步之下:
int age = scan.nextInt();
double price = scan.nextDouble();
补充知识：
1.直接量超范围--------编译错误
算术运算超范围------溢出(不是错误，不好的现象)
2. 通过代码计算一段程序运行的时间
使用了JDK提供的 System.currentTimeMillis() 方法，该方法返回1970年1月1日零点到此时此刻所经历的毫秒数，其数据类型为long，经常用于计时操作。
3. char ascii=98;
System.out.println(ascii);
上述代码的输出结果为：b
原因是如果把0~65535范围内的一个int整数直接量赋给char类型变量，系统会自动把这个int类型整数当成char类型来处理。
4.. byte b1=10;
byte b2=20;
byte b3=b1+b2; 上述代码在第三行会出现编译错误，原因是b1+b2的结果为int类型。使用强制类型转换，将int类型结果转换为byte类型
第三天
1.运算符:
1)算术运算符:+-*/%,++,--
2)关系运算符:>,<,>=,<=,==,!=
3)逻辑运算符:&&,||,!
4)赋值运算符:=,+=,-=,*=,/=,%=
5)字符串拼接:+
6)三目运算符:boolean?数1:数2
2.分支结构:
1)if结构:1条路
2)if...else结构:2条路
3)if...else if结构:多条路
4)switch...case结构:多条路
优点:效率高、结构清晰
缺点:整数、相等
break:跳出switch
补充：
1.使用“+”进行字符串连接
“+”除了可以进行算术运算以外，还可以实现字符串的连接，同时可以实现字符串与其他数据类型的“相连”。
当 + 号作用于两个数字类型变量时，是在进行算术运算。
当 + 号两边的变量有一个是字符串类型，即””括起来的时候，则其进行的是字符串的连接，连接后的结果为字符串类型
2. java语法规定，当if语句块中只包含一条语句时，可以省略“{}”，但是if语句块也只能作用于它下面的一条语句。考虑到代码的可读性、扩展性，建议即便if语句块中只有一条语句，也不要省略“{}”。
3. ，switch是以case后的整型常量值作为入口的，若值相等，即开始执行其后面的语句。
使用switch时需要注意两个问题，第一，case后面的常量值必须不同，第二，switch后面的整型表达式的值必须是整型或字符型
4. 1.算术运算符:+,-,*,/,%,++,--
1)%:取余、取模----余数为0即为整除
2)++/--:自增1/自减1，可放在变量前也可放在变量后
2.1)单独使用时，在前在后无差别
2.2)在被使用时，在前在后有差别
2.2.1)a++的值为a的值
2.2.2)++a的值为a+1的值
第四天
1.循环:反复的执行一段相同或相似的代码
2.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在循环过程中所改变的那个量
3.循环结构:
1)while:先判断后执行，有可能一次都不执行
2)do...while:先执行后判断，至少会执行一次
第1要素与第3要素相同时首选
3)for:应用率最高的
补充
- 随机生成0到99之间的随机数Math.random()*100
Math.random()--------0.0到0.99999999.....
- public static void main(String[] args) {
int count=0;
while(count<5);
{
System.out.print(count+" ");
count++;
}
}
这段代码会形成一个死循环。
乍一看，这段代码片段没有任何问题，但仔细看一下这个程序，不难发现while循环的循环条件表达式后紧跟了一个分号。在Java中，一个单独的分号表示一个空语句，不做任何事情的空语句，这意味着这个while循环的循环体是空语句。空语句作为循环体也不是大问题，问题是当Java反复执行这个循环时，循环条件的返回值没有任何变化，这就形成了一个死循环。分号后面的代码块则与while循环没有任何关系。
3. 变量的作用域/范围:
从变量的声明开始，到包含它最近的大括号结束
.变量的同名问题:
作用域重叠时，变量不能同名
第五天
1.三种循环结构的更佳适用情况:
1)while:"当..."循环
2)do...while:"直到..."循环
第1要素与第3要素相同时首选
3)for:固定次数循环
2.嵌套循环:
1)循环中套循环，一般多行多列时使用
外层控制行，内层控制列
2)执行过程:外层循环走一次，内层循环走所有次
3)循环层次越少越好，能用一层就不用两层，能用两层就不用三层
如果需求必须3层以上才能实现，说明设计有问题
4)break只能跳出一层循环
3.程序=算法+数据结构
算法:解决问题的流程/步骤(顺序、分支、循环...)
数据结构:将数据按照某种特定的结构来保存
数怎么存
设计良好的数据结构会导致好的算法
4.数组:
1)相同数据类型元素的集合
2)数组是一种数据类型(引用类型)
3)数组的定义/声明:
int[] arr = new int[4];
4)数组的初始化:
int[] arr = new int[3]; //0,0,0
int[] arr = {1,3,5}; //1,3,5
int[] arr = new int[]{1,3,5}; //1,3,5
int[] arr;
arr = {1,3,5}; //编译错误
arr = new int[]{1,3,5}; //正确
5)数组的访问:
5.1)通过.length获取数组的长度
int[] arr = new int[4];
System.out.println(arr.length); //4
5.2)通过下标/索引来访问数组中的元素
下标从0开始，最大到.length-1
int[] arr = new int[3];
arr[0] = 100; //给arr中第一个元素赋值为100
arr[1] = 200; //给arr中第二个元素赋值为200
arr[2] = 300; //给arr中第三个元素赋值为300
arr[3] = 400; //异常
System.out.println(arr[arr.length-1]); //输出最后一个元素
6)数组的遍历:
int[] arr = new int[4];
for(int i=0;i<arr.length;i++){
arr[i] = 100;
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
7)数组的复制:
System.arraycopy(a,1,a1,0,4);
int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
8)数组的排序:
Arrays.sort(arr); //升序排
冒泡排序
补充：
1. 冒泡原理:
1)4个数冒3轮
2)每一轮都是从第1个元素开始比
每一次都是和它的下一个元素比
3)冒出来的数就不带它玩了
2. Pascal之父Nicklaus Wirth说过一句话并因此而得了图灵奖，这句很经典的话就是，程序即为：算法+数据结构，所谓数据结构，简单的说就是把数据按照特定的某种结构来保存，设计合理的数据结构是解决问题的前提条件。
3. 数组为相同数据类型的元素组成的集合，数组元素按线性顺序排列，所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”），可以通过元素所在位置的顺序号（下标）做标识访问每一个元素（下标从0开始，最大到元素个数-1）
4.定义基本类型数组的要点包括：
确切的数据类型：用于开辟空间大小
整体的数组名字：用于对数据的引用
不能缺少的“ [ ] ”
注意在定义数组时使用的new关键字， 正是因为new语句，才使得数组分配到了指定大小的空间（后面详细讲解）。
5.声明数组的时候，int[] arr 与 int arr [] 两种写法均可。常用方式为int[] arr。
6.声明数组时不规定数组长度（可以看到声明时仅指定了int[]，未指定长度）,new关键字分配空间时需指定分配的空间大小(new int[10])。
7.总结出Arrays.copyOf（）方法的特点如下列表所示：
生成的新数组是原始数组的副本；
newLength小于源数组，则进行截取；（自己通过代码演示效果）；
newLength大于源数组，则用0或 null进行填充；
第六天
1.方法:
1)用于封装一段特定的逻辑功能
2)方法应尽可能独立，一个方法只干一件事
3)方法可以被反复调用多次
4)结构清晰、便于维护、便于协作开发
2.方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
3.方法的调用:
1)无返回值:
方法名(有参传参);
2)有返回值:
数据类型 变量 = 方法名(有参传参);
4.return:
1)return; //结束执行(void方法中)
2)return 值; //结束执行并返回结果(有返回值方法中)