本文已参与「新人创作礼」活动，一起开启掘金创作之路。

一 .JAVA开发环境

1.JAVA开发环境

（1）java编译运行过程

程序员编写的java源文件(.java)先经过编译生成字节码文件(.class)
java程序的运行需要JVM的支持,JVM是一个软件,安装在操作系统中,为字节码提供运行环境.只要是标准的.class文件就可以"到处运行"

（2）JDK、JRE、JVM关系

运行一个java程序所需要的最小环境为JRE,开发一个java程序所需要的最小环境为JDK

JDK-java开发工具包 JDK包括JRE和编译\运行等开发工具
JRE-java运行环境 JRE包括java系统类库和JVE
JVM-java虚拟机

（3）安装JDK

编辑

（4）配置环境变量

如果希望用到JDK所提供的编译（javac）、运行（java)等命令，需要让操作系统可以找到这些命令文件所在的路径；
可以通过配置PATH环境变量来实现；
PATH环境变量是一系列的目录，在执行命令时，操作系统会依次在PATH环境变量中的每一个目录中查找该命令；

在Linux系统中，配置文件的路径为：/etc/profile；

可以使用cat命令查看配置文件内容：
cat/etc/profile

profile文件中的配置信息：
export JAVA_HOME=/opt/jdk
export CLASSPATH=.
export PATH=/opt/jdk/bin:$PATH
JAVA_HOME 指向JavaJDK安装目录，通知某些软件如何找到JDK安装目录。
CLASSPATH表示类的搜索路径，简单的可以使用点（.）
PATH 指向JDK的bin目录，javac、java等命令就安装在此目录中。

2.Eclipse IDE

Eclipse简介

Eclipse 是目前主流的IDE开发环境(集成开发环境)；
所谓集成开发环境(IDE，Integrated DevelopmentEnvironment)是专为程序员提供的应用软件，这些软件往往具备功能强大的图形界面。在IDE的辅助下，程序员可以更加高效的完成编译、调试、提交、重构等工作。作为一个合格的程序员应该对主流的IDE工具有较高的熟练度，但也要防止“过分依赖IDE"问题。
对于Java程序员有许多IDE环境可以选择，但最主流的要数大名鼎鼎的Eclipse了。Eclipse是IBM斥资数千万美元打造的开源项目，如今几乎统治了IDE市场。除了开源之外，Eclipse成功的最大原因在于它是基于“插件”的特性。Eclipse本身是一个平台框架，提供标准的服务，众第三方厂商可以通过开发插件扩展Eclipse的功能，相较于其他功能相对固定的IDE，Eclipse具有高度的灵活性。
可以从Eclipse的官方网站（www.eclipse.org/downloads/)…
Eclipse下载完成后，不需要特殊的安装，仅仅需要将下载的压缩包解压在某个文件夹中即可。由于Eclipse本身也是用Java语言编写的，它的运行需要有JRE环境，因此必须先安装JDK（或JRE）。

二.变量

1.什么是变量

变量

变量就是指代在内存中开辟的存储空间,用于存放运算过程中需要用到的数据.

int a=5; int b=6； int c=a+b;

变量a、b和c指代内存中三块用于存储整数的存储空间，分别用来存储两个整数以及这两个整数之和。

对于变量我们需要关注起如下几个方面：

变量的声明：用特定的语法声明一个变量，让运行环境为其分配空间；
变量的初始化：变量声明后，要为其赋一个确定的初值后再使用；
变量的访问：可以对变量中的数据进行存取、操作，但必须和其类型匹配。
变量的命名:变量需要有个见名知意的名字,而且要符合java语言规范

2.变量的声明

（1）变量的声明

当需要使用一个变量时，必须对该变量进行
声明变量的声明包含两点：变量名和变量类型。

变量必须指明其类型
必须指明变量名称
JVM会根据不同的变量类型开辟不同的存储空间(结构).

（2）一条语句中声明多个同类型变量

如果变量类型一样可以在一条语句中声明，中间用逗号分隔。

    public static void main(String[] args){
        int a=1,b=2;//声明了两个整型变量，分别赋值为1和2。
        int c,d=3；//声明了两个整型变量，d赋初值为3，c没有赋初值。
}

3.变量的初始化

（1）在声明变量时初始化

可以在变量声明时初始化：

变量类型变量名称=初始值

public static void main(String[] args){
         int sum=0； 
         int a=5；
         int b=6； 
         sum=a+b；
         System.out.println(sum);
}

（2）在第一次使用变量前初始化

可以在变量声明以后，通过赋值语句对变量进行初始化，但一定确保在第一次使用该变量之前。

    public static void main(String[l args){ 
                int sum; 
                sum=0；∥在使用sum变量之前对其进行初始化。
                sum=sum+100； 
                System.out.println(sum)；
}

4.变量的访问

（1）可以对变量的值进行存取、操作

变量是存放数据在空间,可以对其赋值\更改和操作;要把对变量的操作理解为是对其所存储的数据的操作.

    public static void main(Stringll args){
              int a=100；
              a=a + 200；//该条语句的含义为：
                         //将变量a中的值加上200所得结果再存入变量a
}

（2）变量的操作必须与其类型匹配

变量在声明时指定了类型,java编译器会检测对该变量的操作是否与其类型匹配,如果对其变量的赋值或者操作与其类型不匹配,会产生编译错误。

public static void main(String[] args){
         int salary; 
         salary=15000.50；//编译错误 
                          //整型变量不可以赋予浮点值（小数）。
}

（3）未经声明的变量不能使用。

java语言语法规定,变量使用之前必须声明,否则会有编译错误。

public static void main(String[] args){ 
        a=1；//编译错误，变量没有声明 
        int score=0; 
        scord=100；//编译错误
        System.out.println(score);
}

变量没有声明有时候是拼写错误造成的。

（4）未经初始化的变量不能使用。

Java语言规定变量在使用之前必须初始化，即必须给该变量赋予特定的值。

public static void main(Stringl[] args){ 
            int a,b=10； 
            int c=a+b；//编译错误，变量a没有初始化 
            System.out.println(c)；
}

5.变量的命名

（1）命名需要符合标识符语法要求

标识符语法要求:

只能由字母、数字、"_"和"$"符组成;
不能以数字开头
大小写敏感，严格区分大小写
不能使用java关键字(一些java语言规定好的,有特殊含义的字符),如:int、if、for、break等;
中文可以作为变量名,但不提倡用。

（2）命名需要见名知意，且符合Java规范

Java变量名的定义应“见名知意”；
同时，Java编程规范要求：变量的命名需采用“驼峰命名法”，即如果变量的名字由多个单词组成，除第一个单词外，其他单词的首字母大写，其余的字母小写。
例如：salary、javaScore、studentName等。

三、JAVA基本类型

1.八种基本数据类型

八种基本数据类型分别用于存储整数、浮点数、字符数据和布尔类型数据。
整数类型

byte: 1字节8位 -128到127; 存储字节数据（较常用）
short: 2个字节16位 -32768到32767 兼容性考虑（很少使用）
int: 4字节32位 -21亿多到21亿多; 存储普通整数（常用）
long: 8字节64位很大; 存储长整数（常用）

浮点型:

float ： 4字节32位比long的范围大，大约为3.4e+38 存储浮点数（不常用）
double: 8字节64位比float大，大约为1.7e+308 存储双精度浮点数（常用）

如何存储?

——指数部分是一个整数 float类型分配8位专门来存储指数 ,剩下23位用来存储尾数 ,大概可以表示小数点后的6到7位;后七位表示的128次幂

——double分配了11位剩下的52位用来存尾数可以表示小数点后的15到16位，首字母表示正负

字符型

char字符型存储1字符两字节16位 0到65535 存储一个字符（常用）
boolean 1字节8位存储逻辑变量(true false) 存储逻辑变量（true、false)（常用）

2.int类型

（1）int类型

int是最常用的整数类型。一个int类型的变量占用4个字节（32位），最大表示范围为：-2^31~~2^31-1，即-2147483648~~2147483647。

（2）整数直接量是int类型:

所谓整数直接量（literal）就是直接写出的整数;
例如：下面的语句中，100就是直接量。

int a=100；

关于整数直接量，需要注意如下要点：

整数的直接量默认为int类型,如果字节写出的整数超过了int的表达范围,将会出现编译错误。
除了通常的十进制书写形式,整数直接量也经常写16进制的形式(以OX或Ox开头)或8进制的形式(以0开头)。

int a=100000； //10进制
int b=0x186a0; //16进制
int c=0303240；//8进制

//编译错误，因为整数直接量超过了整数的范围
int d=10000000000；

10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。

（3）整型数据的除法运算中的取整

两个整数相除,会舍弃小数部分(不是四舍五入),结果也是整数。

    int c= 5/3； 
    System.out.println(c)；//c的值为1 

    int total=87; 
    int error=23; 
    int percent=error/total*100; 
    System.out.println(percent+"%"); 
    //结果为0%，23除以87整数部分为0 
    percent=100* error /total;
    System.out.println(percent+"%"); 
    //结果为26%，2300除以87整数部分为26

（4）运算时要防止溢出的发生

整数运算的溢出：两个整数进行运算时，其结果可能会超过整数的范围而溢出。

    int a=2147483647; 
    int b=-2147483648； 
    a=a+1; 
    b=b-1; 
    System.out.println("a="+a)； 
    System.out.println("b="+b)；

输出结果：
a=-2147483648溢出，结果错误。
b=2147483647溢出，结果错误。

3.long类型

（1）long类型

在表示整数时，如果int类型的范围不够，可以使用long型，一个long型的变量占用8个字节（64位），最大表示范围为：-2^63~~2^63-1，即-9223372036854775808~~9223372036854775807。
如果要表示long直接量，需要以L或I结尾。

         long a=10000000000；//会有编译错误

         long b=10000000000l；

（2）使用long类型进行较大整数的运算

对于较大的整数运算（超过int的表达范围），可以使用long型。

    long distance1=10000*365*24*299792458L； 
//必须有一个long型数据参与的运算结果才是long型
    System.out.printin("distance1="+distance1); 
//distance1=26261819320800000结果正确

   long distance2=10000*365*24*299792458； 
   System.out.printin("distance2="+distance2)；
// distance2=1271239424溢出

（3）通过时间毫秒数来存储日期和时间

JDK提供System.currentTimeMillis0方法，返回1970年1月1日零点到此时此刻所经历的毫秒数，其数据类型为long，该方法经常用于计时操作。

      long time=System.currentTimeMillis);
      System.out.println(time)；
      //输出的结果为：1383835712828

4.double类型

（1）使用double进行浮点数的运算

浮点数就是小数,包括:float和double
double类型的精度值是float类型的两倍,这正是其名称(双精度)的来由。
大多数场合使用double表示浮点数。

   double pi=3.14； 
   double r=8.0; 
   double s=pi*r*r; 
   System.out.println("s="+s); 
   //输出的结果为：s=200.96

（2）浮点数的直接量是double类型

浮点数的直接量有两种写法：

-通常写法，如：3.14、314.0、0.1、.5。
-科学计数法，如：1.25E2、1.25e2、1.25E-2。其中，1.25E2表示1.25乘以10的2次方。

默认的浮点直接量为double型，如果需要表示float类型的直接量，需要加“f”或“F”后缀。例如：

float fl=3.14；会有编译错误，应该写成3.14f

（3）double运算时会出现舍入误差

2进制系统中无法精确的表示1/10,就好像十进制系统无法精确的表示1/3一样。
所以2进制表示10进制会有一些舍入误差,对于一些精确运算的场合会导致代码的缺陷。

double money=3.0； 
double price=2.9； 
System.out.println(money-price); 
//输出的结果是：0.10000000000000009

(如果需要精确的运算可以考虑放弃使用double或float而采用BigDecimal类实现)

5.boolean类型

使用boolean变量进行关系运算

boolean类型适用于逻辑运算，表示某个条件是否成立。一般用于程序的流程控制。
boolean类型只允许取值true或false，true表示条件成立而false表示条件不成立。
boolean型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小相等等关系。

int age=18； 
boolean isChild =age<16;//isChild的值为false 
System.out.println(isChild)； 
boolean running =true; 
boolean closed=false;

6.char类型

（1）char类型

字符类型事实上是一个16位的无符号整数,这个值是对应字符的编码
java字符类型采用Unicode字符集编码,Unicode是世界通用的定长字符集,所有的字符都是16位
字符直接量可以采用诸如:'中'的形式,也可以采用16进制的表示形式如:'\u4e2d' 其中'4e2d'为'中'所对应的16位Unicode编译的16进制表示形式。 '\u'表示转义为Unicode编码

（2）对char型变量赋值

在对char型变量赋值时,可以用三种形式:

字符直接量如'A'变量中实际存储的是该字符的Unicode编码(无符号整数值),一个char型变量只能存储一个字节。
整数直接量:范围在0到65535之间的整数,变量中实际存储的即该整数值,但表示的是该整数值所对应的Unicode字符。
Unicode形式:形如'\u0041'Unicode字符的16进制形式

char c1=65;
char c2='A';
char c3='\u0041';

（3）使用转义字符

对于不方便输出的字符采用转义字符表示,例如:

'\n'  表示换行符 new line      
'\r'  表示回车符 return 
'\'  表示反斜杠()   
'''  表示单引号(')  
'''' 表示双引号('')
char c="//";
System.out.println(c)；//输出的结果为：\

7.基本类型间转换

（1）基本类型间的转换

不同的基本类型直接可以相互转换:

-自动类型转换(隐式类型转换):从小类型到大类型可以自动完成.类型的大小关系如下:byte->short->int ->long->float->double char->int
强制转换：从大类型到小类型需要强制转换符：（需要转换成的类型）变量但这样转换有可能会造成精度损失或者溢出。

（2）强制转换时的精度丧失和溢出

基本类型转换示例，注意强制转换时可能会造成的精度丧失和溢出。

int a=100;
int b=200;
long c=a+b;//自动将int转换为long

long l1=1024l;
int i=(int)l1;//需要加强制转换符，由于1024在int的范围内没有产生溢出

long l=1024L*1024*1024*4；
int j=(int)l;//会产生溢出
System.out.println(j);//结果为：0

double pi=3.1415926535897932384;
float f=(float)pi;//会造成精度的损失
System.out.println(f);//结果为:3.1415927

（3）数值运算时的自动转换

多种基本类型参与的表达式运算中，运算结果会自动的向较大的类型进行转换：

//由于有long型的直接量参与，整个表达式的结果为long
long distance=10000*365*24*299792458l;
//由于有double型的直接量599.0参与，
//整个表达式的结果为double
double change=800-599.0;

double persent1=80/100;
//结果为0.0，右边都是int型数据运算结果也为int类型，结果
//为0，再赋值给double型，将0转换为0.0

double persent2=80.0/100;
//结果为0.8，右边表达式有double型直接量参与，
//运算结果为double型

（4） byte、char、short转换为int

byte、char、short 三种类型实际存储的数据都是整数，在实际使用中遵循如下规则：

int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。
byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。

四、运算符和表达式

1.算数运算符

（1）使用%运算符

Java算术运算符除通常的加（+）、减（-）、乘（*）、除（/)之外，还包括取模运算（%）和自增（++)及自减（--)运算。
取模运算（%）意为取余数，可适用于整数、char类型以及浮点数。

//输出255除以8所得的余数。
int n=225;
System.out.println(n%8);//结果为1

（2）使用“++”和“--”运算符

Java的自增运算符（++)和自减运算符（--）继承自C++，可以使变量的值加1或减1，但其写在变量前和变量后有不同的效果：

如果写在变量前表示在使用这个变量之前加1或减1
如果写在变量之后表示这个变量使用完之后再加1或减1

int a=10,b=20;
int cl=a++;
int c2=++b;
System.out.println("a="+a+",b="+b+"，c1="+C1+",c2="+c2);
//输出的结果为：a=11,b=21,c1=10,c2=21

2.关系运算

使用关系运算符

使用关系运算符用于判断数据之间的大小关系,包括大于(>) 小于(<) 大于等于(>=) 小于等于(<=) 等于(==) 不等于(!=)六个运算符.关系运算符的结果为boolean类型成立为true 否则为false

3. 逻辑运算

（1）逻辑运算

逻辑运算建立在关系运算的基础之上，逻辑运算符包括：与（&&）、或（||）和非（！）。
参与逻辑运算的变量或表达式都是boolean类型，运算结果也为boolean类型。

（2）使用“&&”运算符

两个boolean变量参与“&&"运算时，只有当两个变量均为true时，运算结果才为true，否则结果为false

（3）使用“I”运算符

两个boolean变量参与""运算时，当两个变量有一个为true时，结果即为true，只有当两个变量均为false时结果为false

（4）使用“！”运算符

"！"运算相对简单，只会有一个boolean变量参与运算，运算的值与该变量相反，变量为true时结果为false，变量为false时结果为true

（5）关于“短路逻辑”的问题

Java逻辑运算遵循“短路逻辑”的原则：

对于“&&"，当第一个操作数为false时，将不会判断第二个操作数，因为此时无论第二个操作数为何，最后的运算结果一定是false；
对于"I"，当第一个操作数为true时，将不会判断第二个操作数，因为此时无论第二个操作数为何，最后的运算结果一定是true。

4.赋值运算

（1）使用=进行赋值运算

用于对变量赋值.关于赋值运算符除了将右边的表达式计算出来赋给左边以外还具有如下特点:赋值表达式本身也有值,其本身之值即为所赋之值.

（2）扩展赋值运算符

在赋值运算符前面加上其他的运算符,即为扩展赋值运算符 += 表达式 X += 5 计算X= X+5 结果15 -= *= /= %=

5.字符连接运算

使用“+”进行字符串连接

使用+实现字符串的连接,同时可以实现字符串与其他数据类型"相连"

6.条件(三目)运算符

（1）使用条件(三目)运算符

条件运算符又称“三目”运算符，其结构为：

boolean表达式？表达式1：表达式2

条件运算符的规则如下：

先计算boolean表达式；
如果boolean表达式的值为true，整个表达式的值为表达式1的值；
如果boolean表达式的值为false，整个表达式的值为表达式2的值。

（2）条件（三目）运算符的嵌套

条件运算符可以嵌套使用，所谓嵌套是指在条件（三目）表达式：“boolean表达式？表达式1：表达式2”中的表达式1或表达式2也是条件（三目）表达式。

五.分支结构与循环语句

1.什么是分支结构

任何复杂的程序逻辑都可以通过“顺序"，“分支"，"循环”三种基本的程序结构实现。

2.四种分支结构

if语句 ifelse语句 else if语句 switch-case语句和break联合使用
swith-case的优势 1常常和break语句结合使用实现分支的功能 2在实现分支功能时if-else的主要区别在于switch-case结构的效率要高结构更清晰. 3从JDK7开始switch-case支持字符串表达式.
default其他不走才走这个

3.循环

循环一定要分析出需要解决业务的3个部分

循环的初始状态
循环的条件
循环变量的改变

while语句使用break语句跳出循环 do-while先执行在判断
循环中使用continue语句其作用为跳过循环体中剩余语句而执行下一次循环
循环问题

循环问题定义-"当"循环循环语句的选择

如果业务转换为"当"这样的语句时,优先选择while语句来实现
如果业务可以转换为"直到.."这样的句式时,优先选择do-while语句来实现
如果业务中可以获取到一个确切的循环次数考虑for循环

六.数组

1.什么是数组

程序=算法+数据结构前面学习的if if-else switch 循环解决的都是流程问题即算法问题所谓数据结构,简单说就是把数据按照特定的某种结构来保存,设计合理的数据结构是解决问题的前提.
数组是相同数据类型的元素的组成的集合

2.数组的定义

定义基本类型数组声明语法:数据类型[] 数组名=new 数据类型[大小];例:int[] arr=new int [10];
int[] arr与int arr[]两种写法均可声明数组时不规定数组长度,new关键字分配空间时需要指定分配的空间大小. 执行new语句才使得数组分配到了指定大小的空间

3.初始化数组

基本类型的数组创建后,其元素的初始值:byte short char int long 为0;float和double为0.0;boolean为false
可以在数组声明的同时对数组的元素进行初始化,例如: int[] arr={10,20,30,-10,21};元素个数即为数组的长度此种写法只能用于声明时的初始化,不能用于赋值.
可以通过下面的方式给已经声明的数组类型变量进行初始化: int[] arr; arr=new int[]{10,20,30,-10,96};注意[]中不可以写长度,元素的个数就是数组的长度.

4.数组的访问

获取数组的长度用.length()来实现
数组中的元素通过下标的方式进行访问

5.数组的遍历

遍历数组元素，通常选择for循环语句，循环变量作为访问数组元素的下标，即可访问数组中的每一个元素

int[] arr=new int[10]；
for（int i=0；i<arr.length;i++)
{arr[i]=100;}

注意：循环的计数器的变化范围从0到length-1

遍历数组元素，正序输出

    int[] arr=new int[]{10,20,30,40,50};
    for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);}

遍历数组元素，倒序输出

   int[] arr=new  int[] {10,20,30,40,50}
   for(int i=(arr.length-1);i>=0;i--{
   System.out.println(arr[i]);}

6.数组的复制

System.arraycopy复制数组：使用System.arraycopy（）方法用于数组复制参数（源数组，源数组的起始位置，目标数组，目标数组的起始位置，要复制的数组元素的数量
Arrays.copyOf复制数组：类型[] newArray =Arrays.copyOf( 类型[] original,int new Length); 特点：生成的新数组是原数组的副本

newLength小于源数组，则进行截取
newLength大于源数组，则用0或null填充所以产生的新数组可以大于源数组的长度

所以产生的新数组可以大于原数组的长度

int[] a={10,20,30,40,50};
int[] a1=Arrays.copyOf(a,6);
a1数组元素为：10 20 30 40 50 0

数组的扩容：数组的长度在创建后是不可改变的，所谓扩容是指创建一个更大的新数组并将原有数组的内容复制到其中。

int[] a={10,20,30,40,50};
a=Arrays.copyOf(a,a.length+1);
扩展后的数组       源数组 扩展后的长度
输出a数组元素：10，20，30，40，50，0

7.数组的排序

排序的算法有：插入排序、冒泡排序、快速排序等。
对于元素多的数组，排序算法的优劣至关重要；一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣。
JDK提供了Arrays.sort()方法封装了数组的排序算法：
int[] arr={19,4,6,777,3};
Arrays.sort(arr);
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}

8.引用类型数组

数组是引用类型，数组对象存在堆中，数组变量属于引用类型，存储数组对象的地址信息，指向数组对象
数组引用变量存在栈中
数组的元素可以看做是数组对象的成员变量(类型全都相同)
数组的类型可以是基本类型数组也可以是引用类型数组

引用类型数组的初始化

引用类型数组new之后每一个元素默认初始值为null
如果需要每一个元素都指向具体的对象，需要单独对每一个元素都进行new

七、方法（函数，过程）

各种语言都有方法的概念（有的语言称为函数或过程）方法用于封装一段特定的逻辑功能如：执行计算或操作；方法可以在程序中反复被调用；方法可减少代码复用，便于程序的维护。
定义方法（函数，过程）的功能：方法用于封装一个特定的功能；定义方法的五个要素：修饰词、返回值类型、方法名、参数列表、方法体；
方法的参数是指：在调用时传递给方法，需要被方法处理的数据；
方法可有参数也可有没有参数，有参可以使方法处理更加灵活；
在方法定义时，需要声明该方法所需要的参数变量。
在方法调用时，会将实际的参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。
定义调用结束后哭返回一个数据，称为返回值；方法在声明时必须指定返回值的类型。若方法不需要返回数据，将返回值类型声明为void。若方法需要返回数据，将返回值类型声明为特定数据类型。
方法的调用：可通过return语句返回，return语句的作用在与结束方法与数据返回给调用方。

java基础知识(语言基础)