软件的安装
java开发目前主流的工具有eclipse，myeclipse，idea等，但是官方推荐的是eclipse，所以我们前期选择使用eclipse，后期采用idea。
网盘链接：https://pan.baidu.com/s/10kka1vjTbZV_IbCioIFrjg
复制这段内容后打开百度网盘手机App，操作更方便哦
提取码：biaw
eclipse简介：
①eclipse解压安装即可用
②eclipse的使用
概念：
工作空间（workspace）：里面可以存储多个项目
项目（project）：一个项目
eclipse界面简介：
上侧工具栏，中央是工作区，其他的选项卡即view（视图）
打开选项卡：window->showview->other->搜索选项卡->确认
选择视角：右侧open perspective（打开所有视角），选择需要的视角。
切换工作空间：file->switch workspace->other 输入工作空间
eclipse开发java项目：
1）新建java项目：file->new->other 选择所要创建的项目
2）java项目文件结构：
①jre：每一个项目中都必须有自己的jre
②src：资源文件夹，存放.java源文件
③bin：用来存储编译后的文件（.class）
3）更改项目文件结构：
右键项目——>properties->java build path（java构建路径）
第一个选项卡：资源目录（src）和bin（二进制目录）
第三个选项卡：更改jre（jdk）
4）创建java源代码文件，编译运行：
编译：编写好.java文件就自动保存
运行：右键.java文件->run as->java application
jdk的安装以及环境配置
概念：
jdk是java（J2SE）开发环境，包含解析器、jre（java运行环境），以及其他工具。
安装：
1.获取jdk安装包，然后解压获得java主目录
解析包里主要文件有bin和jre：
①bin目录里面是存放二进制命令文件，其中主要文件有：
java：可以用来测试版本
javac：将源码文件转化为电脑可识别的文件（.class）
jar：将.class文件打包，便于运输和管理
②jre目录：java运行时环境（包含jvm）
2.配置环境变量
未配置环境变量时：
注意：我这里是因为原来有一个版本的jdk，可以忽略。
右键计算机->属性->高级设置->环境变量->path（系统环境变量中的path）后追加java主目录/bin（path主要做用是快速访问） 
配置完成：
3.测试
在一个文件夹下新建一个文本文档Test01，并输入代码，将文件后缀改为.java：
打开控制台，进入文件路径，然后输入javac Test01.java:
可以观察到源文件夹，多了一个Test01.class的文件，然后在控制台继续输入 java Test01：
输出hello，world！则成功调试。
注意：测试过程中，如果出现GBK字符不能转译，则将原来的文本文件另存为ANSI格式，然后再编译。
java变量与应用
变量
概念：变量是可以不断改变的存储量。
变量与常量命名规范：
变量内容由数字，字母，下划线，$，中文等。
变量第一个内容不能以数字开头。
如：
byte 1a//不合法
byte _ss//合法
变量名不能是关键字
如：
int byte=10；//不合法
定义变量：（变量名存放在栈空间 stack）类型 名称；变量必须在申明后才能使用
使用变量：
①赋值（无限次赋值）
变量名=值（这个值存放在常量区）
②取值（根据变量名取值）
int a=10；
a=a+10；
数据类型
不同的数据类型分配不同大小栈空间
二进制：每一个0 1码，表示一个二进制位数
字节：八位二进制就是一个字节；
字符：
常见的基本数据类型有八种：
整数型（4种）：
byte：1个字节（范围-128——127）-27——27-1
short：2个字节（-215——215-1）
int：4个字节（-231——231-1）
long：8字节（-263——263-1）
浮点型（2种）：
float：单精度 4个字节
float 变量名=小数f（f表示单精度类型小数，如果不加则默认小数为doule类型）； 如：float a=1.5f；
double：双精度 8个字节
boolean：值只有true或者false。如：Boolean b=15>10 值为true。
char：两个字节，值用单引号‘’；A—Z：65-90；a-z：97-122
例如：char ch=‘a’;int i=ch;System.out.println(i);//输出a=97
数字类型转换规则：
小转大，直接转：byte a=10；short b=a；
大转小，强制类型转化：int a=10；short b=（short）a；（直接赋值会报错，不能直接大专小）
运算过程中整数运算默认为int类型，小数默认为double类型。如果定义不同的类型，进行运算则选大类型。
常量（一次定义一次赋值）
语法：final 如：final byte b=28；b=12；会报错，不能进行再次赋值
输入（input）与输出（output）
概念：
程序接受的信息叫输入，程序显示的信息叫输出。
输出：
System.out.println();//打印完后换一行
System.out.print()；//只打印不换行
System.err.println()；//红色打印 换行
转义符号：标志
\n 新起一行
\t 制表对齐
输入：
创建输入工具实例：
Scanner input=new Scanner(System.in);//复杂的变量都是存放在堆中，需要new
接受输入信息：
类型 变量名=input.next类型();
如：
byte age=input.nextByte();//接收Byte
java运算符
单目运算符：++、- -
双目运算符：+、-、、/、%（目指操作数）
%求余数
++ - -
a++:先用后加1
++a：先加1后用 如：int a1=10;int b1=(a1++)+(++a1)+(a1++);结果为34.
a- -：先用后减
- -a：先减后用
注意：如果++或者- -是单独一行，则直接执行自加或自减
赋值运算符
+=、-=、=、/=、%=：先运算后强转赋值
如：short ss=6;
ss=ss+6//报错，因为没有强转，6是int类型。
ss+=5;//+=除了进行运算还能进行强转
逻辑运算符
语法：逻辑表示1 逻辑运算符 逻辑表达式2
&逻辑与：两个逻辑表达式都必须执行
|逻辑或：两个逻辑表达式都必须执行，只要有一个为真就为真
&&短路与：如果第一个表达式为false，则第二个不会执行
||短路或：如果第一个表达式为true，则不会执行第二个
如：int ii=3;
int nn=3;
boolean b0=ii++>5&ii++<4;//两个表达式都执行
boolean bb1=nn++>2&&nn++<2;//如果第一个为false则不执行第二个
条件运算符
>=,<=,==,!=
取反：！逻辑表达式
如：boolean b=！（10>5） //结果为false
三元运算符
语法：
逻辑表达式？表达式1：表达式2
如：int ll=5;
int cc1=10;
int min=ll>cc1?ll:cc1;//求两个中哪个大用>,哪个小用<.
如果逻辑表达式为true则执行表达式1，反之执行表达式2。
运算符优先级
=优先级最高，（）优先级最高，单目高于双目高于三目
选择与循环
概念
根据多种条件选择不同分支
代码块：多行代码
if else 选择结构
语法：标准if else
if(条件表达式1){
满足条件1
}
else if{
不满足条件1且满足条件2
}
else if（表达式n）{
…
}else{
…都不满足
}
第一种改写：if（）
第二种改写：if，else if，…else 每个语句中只有一个语句
第三种改写：if（）esle（）
第四种该写：if() else if()
switch case 选择结构
if else 条件判断，满足条件，执行分支的代码块
switch case 等值判断
switch(变量){
case 值1：
case 值2：
case 值3：
default：（默认值，所有case不满足则进入case）
}
小节：
switch case，将变量的值和每一个case比较，如果相等就进入该case，如果不等就匹配下一个case
如果所有case都没匹配上，则进入default。
如果匹配到的case没有break，则执行该case下的所有case，包括default。
如果default不在代码最后且没有break，也会执行下一个case。
case的值必须是常量，类型是char，byte，short，int。jdk7后增加string，enum（枚举）。
循环
概念
循环：重复n次执行的操作，重复次数和重复操作
标准for循环：
for（初始表达式；逻辑表达式；表达式3）{
}
初始表达式：所有循环开始前执行的代码，只执行一次
逻辑表达式：控制循环次数，每次循环前执行
表达式3：每次执行完该次循环后需要执行的代码。（即循环体内的表达式执行完）
while循环
while（条件表达式）{//条件表达式控制次数
重复次数
}
do while循环
语法：
do{//不管条件成不成立，都要执行一次重复操作
}while（条件表达式）；//第n-1次执行前操作
如：
int a=0;
do {
System.out.println(“第”+a+“次打印”);
}while(a++<10);//执行次数是0到10.
break与continue关键字
break：终止整个循环；
continue：终止本次循环。//continue后的代码都不执行
如：
int sum=0;
for(int i=1;i<=100;i++) {
if((i+1)%2==0) {
continue;
}
sum+=i;
}
System.out.println(“偶数和为：”+sum);
嵌套循环
语法：
for（）{//外层循环
for（）{
内
}
}
数组
数组
概念
数组：一个可以定义多个同类数的类型，再内存（堆空间）中是连续的一段地址空间
定长、连续的一组数据（不可变）。
定义数组
语法：
第一种：类型[] 数组名
如：String name[]= {“tom”,“anna”,“lisa”};
第二种：类型 数组名[]
如：int[] sorce= {11,22,33,44};
初始化数组
第一种：只申请空间，每一个成员都是默认值
类型[] 数组名=new 类型[长度];
样例：
//申请了10个short长度的空间，每个成员为0
short[] ages=new short[10];
//每个成员的默认值为false
boolean[] b=new boolean[3]
//每个成员的默认值为null
String[] s=new String[3]
第二种：
类型[] 数组名=new 类型[]{成员1，成员2…}
样例：long[] l=new long[] {1,2,3,4};
第三种：
类型[] 数组名={成员1，成员2…}
样例：short[] s= {1,2,3,4};
小节：
同一个数组变量，第二次初始化时不能使用第三种类型
样例：
byte[] age=new byte[10];
age=new byte[20];//第二次初始化
age=new byte[] {1,2,3,4,5};
age= {1,3,5,6};//会报错。重新申请空间，必须初始化空间new 类型[]
使用数组
数组设置成员：
语法：数组名称[下标]=值；
获取数组成员（下标）：
数组名[下标]
循环操作数组：
标准for循环：
byte[] age=new byte[10];
for(int i=0;i<age.length;i++) {
byte a=age[i];
System.out.println(“第”+i+“个：”+a);
}
增强for循环：
for（类型 别名：数组名）
样例：
for(byte b:age) {//可以即快速操作数组，但是无法看到下标
System.out.println(b);
}
数组工具
jdk自带的用于操作数组的快捷工具
两个数组对比：Arrays.equals（数组a，数组b）。两个数组长度相同，并且每个下标对应的值相同，才是相同数组
样例：
int[] a= {1,2,3,4,5};
int[] b= {1,2,4,3,5};
int[] c= {1,2,3,4,5};
int[] d= {1,2,3};
boolean flag=Arrays.equals(a,c);
System.out.println(flag);
排序（升序）：
Arrays.sort(数组名)；
样例：
Arrays.sort(b);
for(int i=0;i<b.length;i++) {
System.out.println(b[i]);
}
填充：
Arrays.fill（数组名，初始值）：统一设置成某个值
样例：
Arrays.fill(a, 9);
for(int i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
数组复制：
Arrays.copyof(数组，新数组长度)
样例： int[] b=Arrays.copyOf(a, 5);
tostring：将数组的所有成员转化成字符串：[成员1，成员2…]。
Arrays.tostring(数组)；
样例：String a=Arrays.toString(a);//可以快速查看数组的成员
System.out.println(a)；//数组需要循环输出，转成字符串直接输出
binarysearch：
Arrays.binarysearch(数组，被查找的数据)：查找对应数组的下标（采用二叉查找）
数据必须时升序排好
数组中有被查找的数据，返回对应的下标
样例：
int[] a= {1,2,3,4,5,6,7};
int b=Arrays.binarySearch(a, 4);
System.out.println(b);//输出结果为3
如果找不到：①返回为负数②找第一个比被查找大的数③下标从1开始
样例：
int[] a= {1,2,3,5,6,7};
int b=Arrays.binarySearch(a, 4);
System.out.println(b);//输出结果为-4。
//如果被查找的值比数组中最大的值都大，则返回最大的位置。（查找的理念为二叉树）
字符串
概念：有多个字符构成的一个值即为字符串。
字符串定义与初始化：
定义：String 变量名；
初始化或赋值：
String a=“张三”;
String a=new String(“张三”)
字符串操作：
只能进行+操作，任何类型和string相加都变成一个string
样例1：int a=5；
string b=“a”+a//输出a5
样例2：
String a=“Hello”+“world”;
for(int i=0;i<a.length();i++)
{
System.out.print(a.charAt(i));//chart(下标)：获取对应字符串下标字符
}
二维数组
概念：一维数组的每一个成员也是一个一维数组，该数组为二维数组
定二维数组：
第一种：类型[][] 数组名;
第二种：类型 数组名[][];
初始化二维数组：
第一种：指定了一维数组、二维数据统一的长度
类型[][] 数组名=new 类型[一维长度][二维长度]
第二种：只指定以为数组的长度
类型[][] 数组名=new 类型[一维长度][]
类与对象
概念
类：（抽象）具有相同特征数据的集合，或者相同特征对象的抽象叫做类，如生产的模具
如：人类，猫类，汽车类，飞机类等等
对象：（具体的）类的一个实例即为一个对象。
如：张三，白猫，别克川aXXXX(用数据具体描述出来)
类的构成：类名，属性（静态特征），方法（动作行为）
如：
学生类{
//属性
学号，性别，年龄，所在班级 所在年级
//方法
考试（）
上课（）
}
定义类的步骤
类的构成：
class 类名{
//成员变量1（属性，即具体对象的属性）
//成员变量2
//成员方法（具体对象的行为）
//局部变量（只作用于当前代码块，调用一次执行一次，不能前面加static）
//成员代码块
//静态方法（所有成员都有的，一模一样的行为；在类创建的时候静态方法就加载）
//静态变量（成员变量前加上static修饰词；不能放在代码块中）
//静态代码块
//构造方法（）
}
样例：
class 鞋{
尺码
颜色
价格
品牌
穿（）
走路（）
}
定义类步骤：
定义类名（发现类）
定义类的属性（大部分都是成员变量）
定义类的方法
创建类的一个对象（实例）：
定义一个对象：
类型 对象；
初始化一个对象：
对象=new 类型
方法
概念：可以重复调用（通过名称）的代码块{} //用什么类型的类型名取决与你要返回的是什么类型的数值
语法：
修饰符 [static] void 方法名（参数列表）{
方法体
}
方法名：调用的唯一关键字，只能通过方法名调用
参数列表：为方法体服务，调用该方法时必须全部满足（参数列表中的即为局部变量）
方法体：重复调用的代码块
返回值：
最后一行逻辑代码；该行代码后无可执行代码
如果方法体中没有return，表示没有返回值，则类型必须为void（注意：构造函数没有返回值）
方法的返回值在方法体执行完之后返回给调用者（return返回的数据，不能直接读取，需要先设置一个接收数据）
方法体中return的类型必须和方法规格（类型名）中的返回值类型一致
样例：
Person类
int laught(String age,String gender) {//定义一个方法；参数列表可以多个，用逗号隔开
System.out.println(age+gender+name+“在哈哈大笑”+(++count)+“次”);//成员方法可以调用成员变量
return count;//无返回值用void，有返回值用int
Person调用
p1.laught(“24岁”,“男”);//对象调用成员方法;如果调用的成员方法有参数列表，则在调用的时候把参数列表的值填充
p1.laught(“24岁”,“男”);
int cnt=p1.laught(“24岁”,“男”);//这里使用的调用者（p1.laught(“24岁”,“男”)）相当于count
void没有返回值
参数列表和成员变量的区别：
成员变量一般是一个对象里不易改变的的信息，如姓名，年龄等。
参数列表一般是一个对象里需要改变的，如乘坐的交通工具
简写：
void 方法名（）{//{}方法体
可重复调用的代码块
}
在java中常见的三种方法：成员方法（要有对象才能实现），类方法，构造方法
成员方法：必须通过对象调用，该方法属于成员
调用：对象.方法（参数列表）
类方法（静态方法）：
该方法归属于类，可以通类名或对象名同时调用，方法前必须有stati关键字。类方法不能调用成员变量。
调用：
类名.方法（参数列表）
或
对象.方法（参数列表）
构造方法：（主要针对成员变量）
语法：
修饰符 类名（参数列表）{方法体} 注:方法名是类名，没有返回值
构造方法的作用:创建一个对象(主要是初始化成员变量)
new 构造方法名（参数列表）；//构造方法即为类名
对象必须都是new出来的（通过构造方法），每一个类至少有一个构造方法，如果类（class）中
没有自定义构造方法，程序就会默认增加一个无参的构造方法。
例如：
class Person{
Person（）{}
}
构造方法通过new构造方法直接调用
样例：
类：
Person(){
System.out.println("***************");
}
调用：
Person p1=new Person()//运行可直接输出：***************
变量
成员变量：对象的变量（成员变量也可以不给值，默认有初始值）
静态变量：
语法：变量前static关键字，只能在成员变量前加关键字，可以通过类名直接访问
静态变量可以不给初始值，有默认值
使用方法：
类名.静态变量
对象.静态变量
局部变量：在代码块中定义的变量（{}）
语法：和成员变量相同（但是不能加static）
使用方式：
使用前必须初始化赋值，不给值会报错
局部变量有生命周期（有效期），有效期的范围是代码块里面
局部变量名称可以和成员变量名称相同，优先使用局部变量的值
样例：
String name=“张三”
System.out.println(name);//访问局部变量
System.out.println(this.name);//访问成员变量
this关键字（当前对象）
this.成员变量
this.成员方法
样例：
public void dog()
{
//访问成员变量（如果没有与局部变量同名可以省略this）
System.out.println(this.gender+name);
//访问成员方法
this.speak();（speak的方法：public void speak()）
//访问静态方法(成员方法可以访问静态，静态不可以访问成员)
this.cat();（cat的方法：public static void cat()）
}
this()：调用本对象的构造方法，只能出现在构造方法中，调用另一个构造方法，且必须加在第一行
第一种：this（）->无参的构造方法
样例：
public Person(String name) {//带参构造方法
this();//this（）只用于构造方法中，调用另一个（重载）构造方法
}
第二种：this(name)->带参的构造方法
样例：
public Person(String name,String gender)
{
this(name);//调用带参的构造方法
this.gender=gender;
}
构造方法
修饰符
概念：限制访问范围，即作用域
修饰符出现的位置：
①类：修饰符 class 类
②成员变量：修饰符 类型 成员变量
③成员方法（类方法）：修饰符 [static] 返回值 方法名（参数列表）
④构造方法：修饰符 类名（参数列表）
修饰符的值：
private（私有）<default（默认）<protected(保护)<public(公有)//没有修饰符默认为default
private（私有）:在同一个类中可以使用
default（默认）:在同一个包中可以使用
protected：在子类中可以使用
public：其他地方
包（package）
包是一种文件管理规范，类似于d盘下面的文件夹
包：域名（一级包名）.项目名.分类
如：cn.sina.bbs.utils//新浪的bbs项目下的工具包
使用包：不同包之间相互引用，需要在class上引用
只有两个文件相互作用，且都在一个包下才不需要import
代码块
成员代码块
语法：{}
只执行一次，创建对象时最后执行
静态代码块//初始化数据的作用，不能直接调用
语法：static{}
创建类的时候最后执行
方法扩展知识
方法参数使用
传值：值拷贝
当方法的参数为8大基本类型或者string类型时，方法中的形参都是一个原值的拷贝
示例：
类中：
double PI=3.14;
public void cycle(double r)
}
double s=PIrr;
System.out.println(s);
}
程序中：
int a=10;
p1.cycle(a);//将a的值拷贝给r
System.out.println(a);//输出还是10
传址：址传递
当参数为复杂类型，（除8+string类型外）
方法重载（overload）
概念：同一个类中，方法名相同的多个方法，必须符合重载的要求
简化了类调用方法的代码
条件：
同一个文件（同一个类）
方法名相同
参数列表不同（参数相同是参数列表能一一对应，有一个不能对应就不是相同）
和修饰符和返回类型无关
样例：
//重载
public void max(int a,int b)
{
System.out.println(a>b?a:b);
}
//重载参数列表
public void max(double a,double b)
{
System.out.println(a>b?a:b);
}