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:应用率最高的

补充

1. 随机生成0到99之间的随机数Math.random()*100

Math.random()--------0.0到0.99999999.....

1. 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 值; //结束执行并返回结果(有返回值方法中)