jdk的使用和安装：
jdk是java开发工具包，包括jre和java运行工具
java运行工具有：
调试器，编译器，javadoc.exe java.exe,javac.exe
jre是java运行环境，包括jvm和类库
jvm是java虚拟机，用程序模拟一台计算机，使java程序能够运行在此程序上
类库是资源库
jdk:程序员用jdk；
jre :写好的程序用jre
javadoc.exe，调用编译器对源文件进行编译，生成字节码文件(.class)文件，编译过程中会检查源文件语法，如果源文件语法 有错误，就不会生成字节码文件。
安装好jdk后，需要配置环境变量，在计算机的属性设置中-->高级设置-->高级-->环境变量-中配置
需要对path的值进行追加，在系统变量里创建JAVA_HOME和CLASSPATH,并且写上变量值
检验jdk是否安装成功的方法
打开DOS命令窗口：
输入 javac
java -version
只要不出现“不是内部或外部命令”即安装成功
变量
变量是jvm在内存中开辟的一个存储空间，用于存储数据
变量的命名规则：
（1）变量是由字母，数字，_和$等任意组成，数字不能作为开头
（2）大小写敏感
（3）驼峰命名法 见明知意
（4）不能使用关键字
（5）可以使用汉字，但是不建议使用
变量的使用规则：
（1）变量首先进行定义和初始化
（2）变量可以重复使用，再次使用不用强调类型，变量名必须要和类型一致
（3）变量有自己的作用域，即从一大括号的开始到大括号的结束；出了作用域，在想使用变量，需要重新定义和初始化。
java语言的特点：
（1）跨平台性
也即任何的操作系统都可以使用java语言
例如：Linux，Mac等都有自己的运行平台，但是所有的运行平台都可以运行.class文件（字节码文件），
（2）强类型转换
byte short char 类型先转换成int类型，再进行运算，结果也是int类型
再进行多个数据类型数据进行运算时，先转换成较大的类型
java语言的数据类型分为两大类：
（1）基本数据类型：8种
（2）引用数据类型：无数种
基本数据类型：
整型
byte，short，int，long
浮点型
float,double
字符类型
char
布尔类型
Boolean
byte是最小的数据类型，也叫字节类型，在内存中占8位二进制，1字节大小（不常用）
最小的数 1111 1111 -128
最大的数 0111 1111 127
byte类型的范围就是-2^7~2^7-1 -128~12
short 也叫短整型，在内存中占16位二进制，2字节大小（不常用）
范围 -2^15~2^15-1
-65536~65535
int 也叫整型，在内存中占32位二进制，4字节大小（常用）
范围-2^31~2^31-1
-2147483648~2147483647
int数据类型在运算时是封闭式运算，即max+1=min，min-1 = max；
long 也叫长整型，在内存中占64位二进制吗，8字节大小（常用）
范围：-2^63~2^63-1；
封闭式运算
float 浮点数类型
在内存中占4字节大小，32位二进制
范围：
-3.403E38~3.403E38
double 浮点数类型
在内存中占8字节大小，64位二进制
范围：
-1.79E308~1.79E308
字面量问题，整型的字面量默认的是int类型，在不规定类型时赋值都是int类型；
如；int a = 5;
a = 10;//10也为int类型
在进行赋值时，如果想要转化成自己想要的类型；
int 转换成byte或short
可以：如：byte a = (byte)5;
short b = (short)6;
也即在想要赋的值前面加上括号，括号内是较小类型的类型名
int 转换成long类型只需要在值后面加上L/l;
如：
long c = 8L;
就可以将int类型的8转换成long类型的8；转换的原理是在原来的数的二进制表达式上加上32个0；
浮点数类型的字面量默认是double类型，想要float类型需要进行类型转换；
如：float d = 5F;
在值后面加上F/f;
char 字符类型；
字符类型与String字符串类型的区别；
（1）字符类型用单引号括起来
如
char a = '王';
字符串类型用双引号括起来；
如：
String a = "王"；
（2）字符类型内有且只有一个字符，字符串类型可以有至少0个字符；
（3）引用字符可以做字符串拼接操作
另外，低层二进制也是无符号的整数类型，在书写时直接赋值，存入时是整数对应的值
范围 0~65535
如：
char s = 14687;//运行时显示的是在Unicode字符集上对应的数值
如果想找某个汉字在Unicode上对应的低层二进制数，
int a = "王"；
System.out.println(a);
a~z;97~122
A~Z;65~90
0-9;48~57
\t 制表符
\r 换行符
\n 回车符
"\'"单引号
"\""双引号
"\\"反斜线
特殊字符之转义字符 \:意思是将特殊字符转义成普通字符对待
类型转换分为两种
自动类型转换：是将较小类型的转换城较大类型的数据，也叫隐式转换
强制类型转换：是将较大的数据类型转换成较小的数据类型
运算符：
（1）关系运算符：>,<,>=,<=,==,!=
（2）逻辑运算符:&&,||,!
&&，与，即当左右的条件都为true时，输出为true，有一个为false，结果就输出为false；
||，或，即当条件表达式中有一个为true时，条件表达式就输出为true，当所有的条件为false时，才会输出false，
有一个为真，结果为真
！，当条件为true时，输出为false，当条件为false时，输出为true；
（3）赋值运算符:+=，-=,*=,/=,%=
（4）三目运算符:条件表达式1：变量 = 条件表达式2？值1：值2；
表达式为true时，输出值1，表达式为false时，输出值2，表达式的值要与条件类型要么一样，要么可以进行自动类型转换
（5）字符串拼接符:+
（6）算术运算符:+,-,*,/,&
程序的运行结构
（1）顺序结构
（2）分支结构
（3）循环结构
顺序结构，程序自上而下运行
分支结构，程序在运行的过程中，可以向多个分支选择运行，
常用的分支结构有if，if else if，switch：
if分支的结构为：
if(条件表达式){
代码块；//条件表达式为true时执行
};
if 语句在执行过程中，如果条件表达式为true，执行大括号内的语句，如果为false，跳出分支，执行后续代码，在执行if语句时，程序有可能全部执行if语句内的表达式，也有可能一条也不执行；
if(条件表达式1){
代码块；//条件为true时执行；
}else if(条件表达式2){
代码块1；
}else{
代码块2；
}
if else 在程序执行过程中，先进行判断条件表达式1，如果为true，执行代码块1，如果为false，进行判断条件表达式2，如果为true，执行代码块2，如果为false，执行后续代码.if else语句在程序执行的过程中一定会执行一条分支
switch语句，
switch(整数表达式){
case1：
System.out.println();
break;
case2:
System.out.println();
break;
case3:
System.out.println();
break;
......
default;
根据整数表达式中的值来判断执行哪条分支，break，有打断循环的作用，防止程序进行死循环；
循环结构：
循环三要素：
（1）循环变量的声明和初始化；
（2）循环条件的判断；
（3）循环变量的改变方向。
for循环，while循环，do while循环
for循环：
for(循环条件 ){
循环体；
}
当程序遇到for循环时，程序一定先执行一遍变量的声明和初始化，然后判断条件是否成立，如果成立执行循环体内的代码，
然后进行变量的改变，再判断条件数否成立....
for循环嵌套：
外层循环执行一次，内层循环执行一遍；
外层循环控制行数，内层循环控制列数；
while循环中写的是整数表达式；
int i =0；
while(循环条件){
循环体；
i++;
}
while循环相较于for循环的循环三要素体现的不是很明显，循环变量的声明和初始化在循环结构以外，
程序在执行时一定先执行循环条件，条件为true时就执行循环体，为false跳出循环
do{
循环体；
}while(循环条件);
do while循环结构在循环时一定先执行一次循环体，然后进行循环条件的判断，直到循环条件为真跳出循环；
do while 循环容易陷入死循环；
for循环适用于知道循环次数的循环，
while和do while循环适用于不知道循环次数的循环
do while 循环：
做......直到...
while循环：
当......就执行....
引用类型：
Scanner，Math.random，Arrays，
数组：
（1）数组的概念：
数组是一类相同数据的组合；
数组也是一种类型，一种引用类型；
（2）数组的名称：
数组的名称不是固定的，与要存放的类型匹配；
如，字符串类型 String[] arr1 = {};//默认值为null；
整数类型 int[] b = {};//默认值为0；
字符类型 char[] c = {};默认值为"\u0000"；
布尔类型 boolean[] d = {};//默认值为false；
浮点数类型double[] e = {};//默认值为0.0；
float[] = {};
（3）数组的声明和初始化：
数组的声明：元素类型[] 变量名
数组的初始化时机：
<1>声明时直接初始化；
<2>先声明，再初始化（使用时初始化）
数组的定义有三种，
1，静态初始化：int[] arr2 = {1,2,4};
2，动态初始化：
规定长度的写法：
int[] arr3 = new int[8];//规定数组的长度为8
不规定数组长度的写法：
int[] arr4 = new int[]{};
double[] arr5 = new double[]{};
（4）数组的下标：
数组是从0开始的，最后一个元素的位置为length-1；
所以数组的长度为0~length-1；
int[index];
System.out.println(int[index]);//查询下标为index的数组元素的数据；
（5）数组的赋值，替换
int[index] = value;
（6）数组的下标越界异常：
数组要查询的下标超过数组的长度，就会出现数组越界异常。
（7）数组的遍历：
添加一个for循环
for(int i = 0;j<arr.length;i++){
System.out.println(arr[i]);
}
（8）数组的长度
数组名.length；数组长度的查询
System.out.println(arr.length);
（9）数组间的赋值
数组之间如果改变某一个数组内的数据的话，另外一个数组也会改变，
（10）引用数组Arrays
Arrays.toString();//将元素拼接成字符串输出
System.out.println(Arrays.toString(arr));
Arrays.sort();//将数组内的元素进行排序
（11）数组的复制
数组一经创建，长度无法改变
系统复制法：
System.Arrays.copyOf(arr1,index1,arr2,index2,length)
arr1:源数组，即被复制的数组
index1:即从下标为index1的位置开始复制
arr2:复制的数组
index2:从复制的数组的下标index2处开始复制
length：即要复制的长度
（12）工具类提供的复制方法
Arrays.copy(src,newlength);
src:源数组
newlength:新数组的长度
从下标为0开始复制
String info = Arrays.toString(数组名)；
数组的排序：
冒泡排序法
数组下标为0的数据与下标为1的数据比较，结果为true，说明arr[0]>arr[1]，进行数组元素的互换，如果为false，不进行数组元素
的互换，然后arr1与arr2进行比较，直到找到最大值放到数组的最后一位上，依次比较，找出较大值，直到按从小到大排列；
用for循环结构，
for(int i = 0;i<arr.length-1;i++){
for(int j = 1;j<arrlength-1-i;j++){
if(arr[i]>arr[j]){
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
}
系统排序法：找出一个数组中的最大值，放到最旁边，然后再找数组的较大值，依次进行排序
写两层for循环
for(int i = 0;i<arr.length;i++){
int index = i;
boolea f = true
for (int j = i+1;j<arr.length;j++){
if(arr[index]<arr[j]){
index = j;
f = flase;
}
}
if(!f){
int t = arr[i];
arr[i] = arr[index];
arr[index] = t;
}
}
二维数组：
{{1,2,4},{3,5,1},{2},{}}
二维数组的声明和初始化
int[]][] a = new int[8][3];
等长数组，每个数组元素的数组长度相同，即矩阵
int[][] b = new int[8][];
只规定了高维数组，此时每个高维数组内的元素为null；
null在使用时，需要重新定义，数组的长度任意；
面向对象
方法内：
引用数据类型与基本数据类型的区别：
引用数据类型的数据，称为对象，存储在某一个特定区域，称之为堆；
引用数据类型的变量，也存储在某一个特定区域内，称之为栈；
引用数据类型的变量里存储的不是数据，是对象的地理信息
基本数据类型的数据，不叫对象；
基本数据类型的变量，存储的不是变量的地理信息，是数据
（1）方法：即功能，封装了一段逻辑代码；
（2）方法的定义：
修饰词 返回值类型 方法名（形式参数）{
逻辑代码
}
（3）方法的位置：
在类中，方法是并列的，与main方法是并列关系，在一个类中可以有多个方法；
（4）修饰词：public 公共类
private：私有类
protected：受保护的类
（5）返回值类型：
void 无返回值类型；
如果返回值类型标记的是java语言的某一个类型名时，return关键字后面必须跟着一个此类型的数据或者变量，
return关键字后面的数据就是要返回的数据，返回给调用者使用；
如：public int Number(){
int num = Math.random();
return num;
}
在这段代码中，Math.random()返回一个随机数据给main方法，返回的随机数据存储在num中，main方法调用num来获取返回的数据；
4种类型
reg1:
public void Angelbaby(){
int a = 5;
int b = 4;
int c = a+b;
System.out.println(c);
}
reg2
public int Angelbaby(){
int a = 5;
int b = 4;
int c = a+b;
return c;
}
reg3
public void Angelbaby(int a,int b){
int c = a+b;
System.out.println(c);
}
reg4
public int Angelbaby(int a,int b){
int c = a+b;
return c;
}
方法的调用：
reg1
public static void main(String[] args){
Angelbaby();
}
reg2
public static void main(String[] args){
int x = Angelbaby() ;
System.out.println();
}
reg3
public static void main(String[] args){
Angelbaby(3,5);
}
reg4
public static void main(String[] args){
int x = 5;
int z = 4;
int y ==Angelbaby();
System.out.println(y);
}
总结：
无返回值时，
方法名（有参就传参 ）;
有返回值时
返回值类型 变量名 = 方法名（有参就传参）;
面向对象（使用eclipse）
新建项目 java protect
在src里创建一个包；
包名为 域名后缀.域名.项目名.模块
在包里创建一个类，类是程序里的基本单元，类里可以写多个方法，
想把那个在内存中运行的那个图画下来，好像不能画图
java编程语言是纯粹的面向对象思想语言，
现在程序开发有两个主流方法：
（1）结构化程序设计，也叫面向过程程序设计
结构化程序设计主张以功能步骤来进行软件设计。
如在解决问题时，主张是思考的是解决问题的思想步骤；
如在围棋游戏中；
游戏开始，白起先走，画图，判断输赢，黑棋走，画图，判断输赢...返回，游戏结束
结构化程序设计是以函数为程序单元，从一个函数开始，调用其他普通函数，进行一些数据处理，一直调用下去
设计思想：
自顶而下，逐步精分，模块化
（2）面向对象程序设计
它使用类，对象，继承，封装，消息等概念来进行程序设计，主要从现实世界的客观事物（即对象）出发来进行开发软件系统
尽可能的运用人的自然思维方式，从客观事物来思考问题，认识问题，从这些事物的本质特点，来抽象出系统想要的类，
类是程序的基本单元
运用面向对象思维来设计围棋游戏；
黑白棋子 棋盘 输赢规则；
类是面向对象编程的基本单元，类含有一类事物的共同特征，类可以产生多个对象，这些对象构成了程序中所需要的数据，
软件系统是由多个类组成，类是一类事物的抽象体现，而这些事物都有一些状态数据，即Filed，如人有身高，体重，名字，爱好等，在做程序设计时，只关心业务所需要的数据
Filed，我们称之为成员变量，成员变量是在类体中定义的，也可以称之为属性，是类带有的属性信息，
局部变量，是在方法中定义的，是用来实现方法的，
类除了封装一些事物的状态信息外，还提供了操作这些状态数据的方法（Method），实现逻辑
从以上我们可以总结出：
成员变量+方法 = 类的定义
完成一个"猪八戒吃西瓜"这样的逻辑
面向过程：函数是核心
吃（猪八戒，西瓜）
面向对象：类是核心
猪八戒.吃（西瓜）
面向对象的粒度要比面向过程大，相对来说简单，容易
用成员变量总结一类事物的共同特征；
用方法来总结一类事物的共同行为，
类的定义： = 成员变量+方法
格式语法：
修饰词 class 类名{
type Filed1；
type Filed2；
...
修饰词 返回值类型 Method1；
修饰词 返回值类型 Method2；
....
}
定义一个Person类；
public class Person{
String name;
char gender;
int age;
String haboy;
public String name(){
String str = "他的名字叫"+name;
return str;
}
调用的用法如下：
public static void main(String[] args){
Person p = new Person();
p.name = "Angelbaby";
p.name();
}
对象：是类的实例化，即类中的个体；
如何创建对象，使用关键字new；
类名 对象名（引用变量） = new 类名();
引用变量，简称引用，存储的是对象在内存中的位置信息；
成员变量的调用：
引用.变量名 =
方法的调用：
引用.方法名(有参就传参)；
类与对象的关系：
类是对象的模板，对象是类的实例化
内存管理机制：
jvm将其管理的内存分为三个区域：方法区，堆，栈
方法区：在程序运行时，将所需要的class文件（类的信息）加载到此空间；
堆：用于存放引用类型产生的对象，如果对象有成员变量，会给成员变量分配空间；
栈：方法内的变量（局部变量）是在栈中开辟的；
值传递：
基本数据类型的变量里存储的是基本数据类型的变量；
int a = 5;
int b = a;//将a中的5复制了一份，传递给了b；
址传递：
引用数据类型的变量里存储的是对象的地址信息；
Car c = new Car();
Car d = c;//将c里的地址信息复制了一份，转递给了d;
空指针异常：
程序在运行过程中，可能会出现空指针异常，出现的原因：
Car a = null;
System.out.println(c.color);