java01-08，
java01-08，
jdk:java development kit-java开发工具包
--java开发工具：
编译器，调试器，javadoc.exe java.exe javac.exe
程序员开发：需要jdk
--jre(java runtime environment)--java运行环境
--jvm(java虚拟机）：
使用程序模拟一台计算机，使java程序运行在jvm上
--类库(资源库)
写好的程序：需要jre
jdk与jre的区别：
jdk是开发环境(开发程序所需要的环境)，包含开发工具和jre，开发工具有编译器，调试器，javadoc等
jre是运行环境(程序运行所需要的环境)，包含jvm和类库
配置jdk的环境变量：
计算机-->属性-->高级系统设置-->高级-->环境变量-->系统变量：
新建一个环境变量名为：
JAVA_HOME
变量值：E:\Program Files\Java\jdk1.7.0_80
JDK安装路径(即一堆命令所在目录bin的父目录)
新建一个环境变量名为:
CLASSPATH
变量值：
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\jre\lib\tools.jar;
找到系统变量里的path:追加值。
追加的内容如下：
;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
检查是否配置成功；
打开命令提示符界面：
输入两个命令：
java -version 回车
javac 回车
不出现“不是内部或外部命令。。。” 即为成功
注意：
jdk安装路径一定不能有中文汉字
java语言特点：
跨平台
因为每个平台(操作系统)都有自己版本的jvm 而任何版本的jvm都会执行.class文件(二进制字节码文件)
强类型
变量必须在定义期间规定一个类型，赋值时类型必须匹配
java语言运行原理：
java源文件(.java)
|
|---编译过程(javac.exe)
| javac 源文件名称(一定带上扩展名)
java字节码文件(.class)
|
|---开启jvm 运行字节码文件
| java 字节码文件名称(一定不要带上扩展名)
| java Demo
|
程序开始跑起来
=========================================================================
进入命令提示符界面：
切换盘符：
直接输入 F：
cd:表示切换目录(文件夹)
cd ..切换到父目录下
.:当前目录
..:父目录
如：从F:下进入1802里的day01里
cd 1802\day01
javac.exe：调用编译器对源文件进行编译成字节码文件
编译期间会检查源文件中的语法
如果语法没有错误 就会生成.class文件
编译期间的语法错误，称为编译错误
java：启动虚拟机，让虚拟机调用main方法
=========================================================================
=========================================================================
System.currentTimeMillis();会返回一个long类型的数据。
此数据为1970年1月1日0时0分0秒到系统当前时间之间所有毫秒数。
=========================================================================
注释有三种:
1 文档注释：
/** 注释 */
2 多行注释：
/* 注释 */
3单行注释：
// 注释
通常：文档注释用于解释类或方法
单行或多行注释用于解释方法内的逻辑
变量：
语文课本中：可变化的量
你-->张三
-->李四
我-->赵六
-->陈七
java语言
就是jvm在内存中开辟的一个很小的存储空间，用来存储一个类型中的一个数据的
1、程序通过操作变量名来操作存储空间
2、变量必须定义一种类型
变量的命名规则：
1、名称由字母数字_和$任意组成 数字不能开头
2、大小写敏感3
3、可以使用汉字，但是不建议使用
4、驼峰命名法，见名知意
myDogName = "旺财
5、不能使用关键字
变量使用规则：
1、必须先定义(声明，创建)和初始化
2、变量可以重复使用，即可以进行多次存取操作，不需要强调类型，
但是存储数据时一定要与第一次声明时的类型匹配
3、变量的作用域：变量有自己的使用范围，出了范围变量失效。
作用域：从定义开始到所在的{}的结束符号为止。
出了作用域，想使用需要重新定义和初始化。
java语言的数据类型：java语言中共分两大类型
1、基本数据类型(原始数据类型) 8种
byte short int long float double char boolean
整数类型4种：
byte(不常用)；也叫字节类型，在内存中占8位二进制，即在内存中占1字节大小的空间，
是数据存储最小的单位。
0000 0000 0
0111 1111 127
1000 0000 -128
1111 1111 -1
范围：-128~127
幂表示：-2^7~2^7-1
short(不常用)：也叫短整型，在内存中占16位二进制，即在内存中占2字节大小的空间，
0000 0000 0000 0000 0
0111 1111 1111 1111 32767
1000 0000 0000 0000 -32768
1111 1111 1111 1111 -1
范围：-32768~32767
幂表示：-2^15~2^15-1
int(常用)：也叫整型，在内存中占32位二进制，即在内存中占4字节大小的空间
范围：-2147483648~2147483647
幂表示：-2^31~2^31-1
long(常用)：也叫长整型，在内存中占64位二进制，即在内存中占8字节大小的空间
范围：正负922亿亿左右
幂表示：-2^63~2^63-1
在给变量赋值时，直接写的整数值，默认就是int类型的数，在内存占32位。
在给byte和short类型的变量赋值时，直接写的整数值 只要没超出相应类型的范围就不会出现编译错误
直接写的整数值叫字面量
int类型的所有数值计算结果一定都是32位的
01111111 11111111 11111111 11111111 +
00000000 00000000 00000000 00000001
---------------------------------------
10000000 00000000 00000000 00000000
int类型的封闭式运算：
max+1=min
min-1=max
浮点数类型：
float：单精度浮点数类型，在内存中占32位二进制，即在内存中占4字节大小
范围：-3.403E38~3.403E38
double：双精度浮点数类型，在内存中占64位二进制，即在内存中占8字节大小
范围：-1.79E308~1.79E308
字面量：默认类型为double，即64位浮点数类型，如果想直接写32位浮点数，需要在书之后添加F/f
浮点数存储数据时，会有舍入误差，即不够精确但是double要比float更精确(相比float要精确一倍)
浮点数类型无法精准表示1/10，就像十进制数无法表示1/3
所以在运算时，多数情况下，都是不精确运算，可以精确表示1/2
范围大小从大到小排序：
double>float>long>int>short>byte
精度从大到小排序：(int long float double)
long>int>double>float
字符类型：
char:在内存中占16位二进制，即在内存中占2字节大小
赋值特点：
1、值中有且只有一个字符
2、字符必须使用单引号引起来
另外特点：底层二进制是无符号的整数类型，
即 0~2^16-1--->0~65535
所以赋值时可以赋值整数，但是存入变量空间后，其实是其整数对应的字符。
\t(制表符) \r(换行符) \n(回车符号)
java语言默认使用的字符集位unicode。
unicode字符集：
无论字母，还是汉字，都占两个字节大小
'A'---00000000 01000001
'a'---00000000 01100001
'0'---00000000 00110000
字符集：
二进制与字符的一一对应关系的表
布尔类型：
boolean
2、引用数据类型(无数种，除了现有的，还可以自定义类型)
String:字符串类型
赋值特点：
1、必须使用双引号
2、双引号内有0或0个以上字符
3、字符串的数据之间可以进行拼接操作，拼接后的数据仍是字符串类型
Math类和Scanner类
Math：是一个数学类型，此类型中有很多方法即功能
如：
Math.random():功能是随机产生一个[0,1)区间内的任意浮点数(小数)
范围：0~0.99999...
double num = Math.random();
如果想要[m,n)区间内的任意小数
Math.random()*(n-m)+m
如果想要[m,n)区间内的任意整数
(int)(Math.random()*(n-m)+m)
如果想要[m,n]区间内的任意整数
(int)(Math.random()*(n+1-m)+m)
Scanner：是一个开启键盘输入的类型，此类型中有很多方法
如：
可以扫描键盘输入的整数，浮点数，布尔类型，字符串类型
这些功能都有阻塞程序的效果，当扫描到数据后，并回车，阻塞效果消失，程序继续向下运行
nextInt():扫描整数
nextDouble():扫描浮点数
nextBoolean():扫描布尔类型
next():扫描字符串
nextLine():扫描字符串
使用步骤：
1、导包
import java.util.Scanner;
2、新建对象
Scanner scan = new Scanner(System.in);
3、使用功能
int num = scan.nextInt();
double num = scan.nextInt();
String str = scan.next();
String name = scan.nextLine();
运算符：
两原一封：
两个原则：
1、不同类型的数据做运算时，一定会先转换成较大范围的类型再运算。
2、byte,short,char 这些类型运算时一定会先转成int类型再运算 结果为int类型。
封：
一定要注意封闭式运算。
算数运算符：
+，-，*，/，%，++，--
/:
1、参与运算类型都是整型时，做取整运算，即 商n余m 结果为n
2/3---商0余2 结果为0
2、只要有一个浮点数参与，就会做类似精确运算
%:取余运算符号(取模运算符号)
做除法运算时，商n余m，结果为m
1、参与运算都是整数时，余数是精确值
2、有浮点数参与时，余数不一定是精确值
两个整数的取余，结果为正
两个负数的取余，结果为负
一正一负时，被除数为正，结果为正
一正一负时，被除数为负，结果为负
取余运算常用于判断某一个数能否被另外一个数整除
++/--:
自增自减运算符，符号要与变量一起使用，表示自动+1或自动-1；
如：
++a/a++/--a/a--
++a/a++:是a=a+1的简写
--a/a--:是a=a-1的简写
1、与变量在一起，不与其他任何符号连用时(单独使用)
++a; a++; --a; a--;
此时，变量一定会+1或-1
2、自增/自减运算与其他符号连用时,需要考虑表达式的值
++a/a++/--a/a-- 整体看成表达式
口诀：
符号在前，先运算再赋值
符号在后，先赋值再运算
解析：
符号在前时，变量先自增/自减，新值赋值给表达式
符号在后时，先把变量赋值给表达式，再自增/自减
如：
int a = 1;
a = ++a;
System.out.println(a);
关系运算与逻辑运算统称为条件运算
关系运算符：
>, >=, <, <=, ==, !=
用来判断条件是否成立，一般都用在分支结构或循环结构中
逻辑运算符(短路运算符)：
当有两个条件以上进行判断是否成立时，需要使用逻辑运算符。即与 或 非
当使用&&或||时，第一个条件就能确定结果时，就不会执行第二个条件，这种行为可视为短路现象
&&(与):用于判断两个条件是否同时成立
全真为真，一假则假
1<a<3 ---> a>1 && a<3
||(或):用于判断两个条件是否有条件成立
一真即真，全假则假
!(非):用于条件的否定
非真即假，非假即真
单个符号的 &(与) |(或) 没有短路现象
赋值运算符：
=，赋值运算，给前面的变量赋值
扩展赋值运算符
+=，-=，*=，/=，%=
a+=b-----> a = a+b
a-=b-----> a = a-b
a*=b-----> a = a*b
a/=b-----> a = a/b
a%=b-----> a = a%b
字符串拼接符号：
+
当+前后只要有一个是字符串类型，就做拼接操作，拼接后的结果是字符串类型
三目运算符(三元运算符)：
变量类型 变量 = 条件表达式?值1:值2
变量类型：需要与值1或值2的类型相同，值1与值2 类型要么相同，要么可以自动转换
程序的运行顺序：
顺序结构：从程序开始到程序结束
分支结构：在顺序结构基础上，根据条件进行选择执行方向
根据条件的成立与否选择执行方向。
1、if分支结构：
语句1：
if(条件表达式){
代码块 //条件成立时执行的逻辑
}
语句2：
执行逻辑：执行完语句1后，碰到if一定会执行条件表达式，结果为true就执行代码块，结构为false就跳过代码块执行语句2
if(条件表达式){
代码块1 //条件成立时执行的逻辑
}else{
代码块2 //条件不成立执行的逻辑
}
执行逻辑：当程序执行到if时，一定会执行条件表达式，结果为true执行代码块1，结果为false跳过代码块1执行代码块2
if(条件表达式1){
代码块1 //条件1成立时执行的逻辑
}else if(条件表达式2){
代码块2 //条件1不成立条件2成立时执行的逻辑
}else if(条件表达式3){
代码块3 //条件1条件2不成立条件3成立时执行的逻辑
}else{
代码块4 //条件都不成立时执行的逻辑
}
//有else{}一定会执行其中的一条语句，没有else{}有可能一条分支都不执行
执行逻辑：程序执行到if时，一定执行条件1，进行结果为true，执行代码块1
结果为true，执行代码块1，
结果为false，执行条件2，进行判断
结果为true，执行代码块2，
结果为false，执行条件3，进行判断
......
2、switch-case语句
格式：
sittch(整数表达式){ //整数表达式：即能获得一个整数表达式 jdk1.7以上版本，支持字符串表达式
case value1:代码块1; //case后的值与()内的结果类型要相同
break; //break:有打断 毁掉 跳出 结束的含义
case value2:代码块2;
break;
.......
[default:代码块n;] //[]表示可有可无
}
执行逻辑：
当程序遇到switch计算表达式的值，然后匹配case后的值，然后执行对应的分支逻辑，如果此分支有break，就结束分支结构
如果此分支没有break，就继续执行下一条分支逻辑，直到遇到break或default或全部执行完后续的所有分支
循环结构：在顺序结构基础上，根据条件进行多次执行相同的或相似的代码
循环三要素：
1、循环变量的声明：用于控制循环次数的循环因子
2、循环条件：用于判断是否执行相同或相似内容(循环体)的条件
3、循环变量的改变方法：向着循环结束的方向改变
break关键字：用在循环结构中时，表示结束/打断循环
continue关键字：用在循环结构中，表示结束当次循环体，继续下一次循环
1、for循环：
语法：
for(变量的声明和初始化;循环条件;变量的改变方向){
循环体;
}
执行逻辑：程序遇到for关键字时。一定执行变量的声明和初始化，然后进行循环条件的判断，如果为false会跳过循环结构，执行后续代码
如果为true执行循环体，再执行变量的改变，再执行循环条件的判断......
双层循环：
外层变量执行一次，内层变量执行一遍
外层变量控制行数，内层变量控制列数
2、while循环：
语法：
while(循环条件){
循环体
}
执行逻辑：
当程序遇到while时，一定执行循环条件，如果结果为false结束循环结构，执行后续程序
如果结果为true执行循环体，再判断条件
3、do-while循环：
语法：
do{
循环体
}while(循环条件);
执行逻辑：
当程序遇到do关键字时，一定先执行一次循环体，然后判断循环条件，如果条件为false，结束循环结构，执行后续代码
如果为true，再执行一次循环体，然后判断条件是否成立......
while 和 do-while运用环境：
当......就执行......：适合使用while
做......直到......：适合使用do-while
while/do-while/for的区别：
for：适合知道循环次数的逻辑
while/do-while：适合不知道循环次数的逻辑
while/for：一般先判断条件，再执行循环体
do-while：一定先执行一次循环体，再判断
数组：
1、概念：
一组相同类型的数据的组合 数组也是一种引用类型
2、名称：
数组名称不是固定的，与存放的数据的类型有关，
如：存放一组int类型的数据，数组名称为 int[]
存放一组字符串类型的数据，数组名称为 String[]
存放一组Scanner类型的数据，数组名称为 Scanner[]
存放一组字符类型的数据，数组名称为 char[]
3、元素：
数组中的每个数据都是这个数组的元素。
4、数组的声明与初始化：
声明： 元素类型[] 变量名;
元素类型 变量名[];----不建议此写法
初始化：第一次赋值
时机：1、声明时直接初始化 2、先声明再初始化
数组的变量初始化：
1、静态初始化(1种)
String[] names = {"a","b"};
int[] nums = {1,2,3};
2、动态初始化(2种)
规定数组长度的写法：
int[] ages = new int[length];
其实有默认的元素：
整数类型：0
浮点数类型：0.0
字符类型：'\u0000' //整数0对应的字符
布尔类型：false
引用数据类型：null
不规定数组长度的写法：
int[] ages = new int[]{};
double[] counts = new double[]{1.2,3.14};
5、数组的长度：
数组元素的个数
表示方法：变量名.length
6、数组的下标(index)：
下标从0开始，最后一个元素的下标为:length-1;
下标范围：0~length-1
7、数组元素的访问：
通过下标进行查看
语法：变量名[index];
元素的遍历(从头到尾依次查看)
for(int i = 0; i <变量名.length; i++){
System.out.println(arr[i]);
}
8、数组元素的覆盖(赋值，替换)：
语法：
变量名[index] = value;
9、数组间的赋值：
变量之间的赋值：
通过一个变量对数组的元素进行修改，那么与之相关的变量对应的数组的元素也会发生变化
10、数组下标越界异常：
java.long.ArrayIndexOutOfBoundsException
出现的原因：
访问数组元素时的下标超出了范围
正确范围：0~length-1
错误下标：变量名[-1] 变量名[length]
11、引用类型之Arrays：
是数组的工具类，此类提供了很多对数组操作的功能方法
如：
String info = Arrays.toString(数组名);
Arrays.toString(); 此方法是将数组的元素一一拼接成字符串
格式如下：
"[元素1,元素2,元素3,...]"
12、数组的复制：
数组的特点：
一经创建，长度不可变。
系统复制方法：
System.arraycopy(src,start,des,start2,length);
src：源数组(被复制的数组)
start1：源数组复制的开始下标
des：目标数组，即复制到的数组名
start2：目标数组复制的开始下标
length：复制的长度
工具类提供的复制方法：
元素类型[] 变量名 = Arrays.copyOf(src,newLength);
src：源数组
newLength：新数组的长度
功能解释：
从源数组的下标为0的元素开始复制，复制到长度为newLength的新数组中，
新数组存放元素的开始位置为0,此功能有扩容或缩容的效果
数组的排序：
冒泡排序
简单选择排序
工具类Arrays里的排序方法：
Arrays.sort(数组名); 对基本数据类型的数组与引用数据类型的数组都可排序
二维数组：
概念：数组的元素是数组
int[] a = {1,2,3,4};
int[][] b = {{1,2},{2,3,4,5,6},{1,2,3}};
访问：
b[0]-->{1,2} b[1]-->{2,3,4,5,6} b[2]-->{1,2,3}
b[0][0]-->1 b[1][4]-->6 b[2][1]-->2
初始化：
静态初始化：
如： int[][] a = {{1},{1,2},{2,3,4}};
动态初始化：
1、等长式初始化
int[][] a = new int[3][2]; 表示a有三个元素，每个元素都是2个长度的数组
2、只规定高维数组的长度
int[][] a = new int[3][]; 表示a有三个元素，但是都是null，null在使用时需要新建数组对象(长度任意)
方法内：
引用数据类型与基本数据类型的区别：
引用数据类型的数据，称之为对象。存储在内存中某一个特定区域中，即：堆
引用数据类型的变量也存储在内存中的一个特定区域，即：栈
引用类型的变量存储的内容不是对象，而是对象在堆空间的位置信息
基本数据类型的数据，不叫对象。直接存储在栈的变量空间里
基本数据类型的变量存在栈里，存储的内容是基本类型的数据。
===============================================================================================================================
方法：
即 功能，封装了一段逻辑代码。
方法的定义：
修饰词 返回值类型 方法名(形式参数){
逻辑代码
}
方法的位置：
在类体中，与main方法是并列关系，类体中可以有多个方法。
修饰词：
(1)public---公共的
(2)protected---受保护的
(3)provate---私有的
也可以不写修饰词，即默认的(default)
static修饰词可以与上述三个修饰词连用
返回值类型：
(1)void---无返回值类型
(2)java语言的任意一种类型，可以使基本数据类型，也可以是引用数据类型
方法名：
命名时尽量做到见名知意，驼峰命名法，首字母小写
形式参数：
用于接收调用者传入的数据。与变量的声明语法相同
关键字return：
作用1：结束方法逻辑
作用2：如果返回值类型标记的是java语言类型的某一个类型名，那么return关键字后必须跟着一个此类型的数据或变量
当方法有返回值类型时，return关键字后的数据就是此方法要返回的数据，返回给调用者
如：
int num = Math.random();
方法random()返回一个数据给main方法。
main方法存入num变量中
如：
reg1
public static void sum(){
int a = 3;
int b = 5;
System.out.println(a + b);
[return;]-----返回值类型处写void时，return可有可无
}
reg2：计算两个整数a和b的和
public static void sum(int a,int b){
int sum = a + b;
System.out.println(sum);
[return;]
}
ps：方法定义期间，就是制定逻辑流程模板:
reg3：
public static int sum(){
int a = 3;
int b = 5;
int sum = a + b;
return sum;
}
reg4：
public static int sum(int a, int b){
int sum = a + b;
return sum*3;
}
方法的调用：即使用
reg1如何使用：
main(String[] args){
sum();
}
reg2如何使用：
main(String[] args){
/*
调用者main在使用sum(int a, int b)时，需要给形式参数赋值，赋的值叫实际参数
*/
int x = 1;
int y = 2;
sum(x,y);
}
reg3如何使用：
main(String[] args){
int n = sum(); //8
}
reg4如何使用：
main(String[] args){
int m = 10;
int n = 20;
int num = sum(m,n); //90
}
调用方法时；
无返回值时：
方法名(有参就传参);
有返回值时：
返回值类型 变量 = 方法名(有参就传参);
===============================================================
eclipse：
是eclipse基金会提供的一款集成开发环境(IDE)，也是一款绿色免安装免费的开发工具。
使用前需要JDK开发环境。
其他开发工具如：myeclipse,ideas,netBean,JBiuder
使用步骤：
(1)新建项目
File-->new-->Java Project--name--finish
(2)新建包(package)
命名规则：
域名后缀.域名.项目名.模块名称
src-->new-->package--name--finish
(3)创建源文件(.java)
选中包-->new-->class--name--finish
补全健：alt+?
main方法快捷方式：main + 补全健
System.out.println()：syso + 补全健
相关文章
- 暂无相关文章
用户点评