Java学习第一阶段（1）
1.相对路径和绝对路径
相对路径：从当前目录开始定位，形成的路径
绝对路径：从根目录开始定位，形成的路径
###2.JDK, JRE, JVM的关系
JDK=JRE+Java开发工具
JRE=JVM+核心
###3.程序中加号的使用
system.out.println(100+98);//198 加号两边都是数值型时，做加法运算
system.out.println("100"+98);//10098 有一边是字符串时，做拼接运算，""是字符串
system.out.println(100+3+"hello");//103hello 先从左边开始，做加法运算，再做拼接
system.out.println("hello"+100+3);//hello1003 先做拼接
###4.注释快捷键 ctrl+/
取消就是再按一次
###5.基本数据类型转换
5.1精度小的可以自动转换为精度大的
char → \rightarrow → int → \rightarrow → long → \rightarrow → float → \rightarrow → double
byte → \rightarrow → short → \rightarrow → int → \rightarrow → long → \rightarrow → float → \rightarrow → double
int a = 'c'; //char可以自动转换为int，所以这个是对的
double d = 80;//80是int型，可以自动转换为double
####5.2 byte ,short 和char之间不会自动转换
5.3 当有多种数据类型参与运算时，系统首先自动将所有数据转换为容量最大的那种数据类型，然后就进行计算
5.4
10是int型？
byte b = 10 //byte的范围是-128-127
//先判断该数是不是在byte范围内
####5.5 byte，short, char ,他们三者可以计算，在计算时转换为int型
byte a = 1;
byte b = 2;
short s1 = 1;
short s2 = s1 + a;//错的，a+s1->int
byte d = a + b;//错的，a+b->int
5.6 boolean 类型不参与转换
5.7 自动提升原则：表达式结果的类型自动提升为操作数中的最大类型
byte a = 1;
short b = 2;
int c = 3;
double d = 4;
a + b + c + d ;// 结果只能是double型的
6.强转符号
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
int x = (int)10*3.5+6*1.5;//double->int 错的
int y = (int)(10*3.5+6*1.5)//(int)44.0->44
###7.
####7.1 基本数据类型 → \rightarrow → string
加 " "就可以
int n1 = 100;
float f1 = 1.1F;
double d1 = 4.5;
boolean b1 = true;
String s1 = n1 + " ";
String s2 = f1 + " ";
String s3 = d1 + " ";
String s4 = b1 + " ";
System.out.println(s1+" "+s2+" "+s3+" "+s4+" ");
// 运行结果:
//100 1.1 4.5 true
####7.2 string → \rightarrow → 基本数据类型
使用基本数据类型对应的包装类的相应方法
String s5 = "123";
int num1 = Integer.parseInt(s5);
double num2 = Double.parseDouble(s5);
float num3 = Float.parseFloat(s5);
byte num4 = Byte.parseByte(s5);
boolean b = Boolean.parseBoolean("true");
short num5 = Short.parseShort(s5);
long num6 = Long.parseLong(s5);
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
System.out.println(num5);
System.out.println(num6);
System.out.println(b);
//运行结果：
123
123.0
123.0
123
123
123
true
####7.3 怎么把字符串转换为字符char（含义是指 把字符串的第一个字符得到）
System.out.println(s5.charAT(0));
//运行结果：
1
###8. 算术运算符
####8.1 /号
System.out.println(10 / 4); //2
System.out.println(10.0 / 4); //2.5
double d = 10 / 4;
System.out.println(d); //2.0
8.2 %取余(取模）
%的本质就是一个公式：a % b = a - a / b * b
System.out.println(10 % 3); //1
System.out.println(-10 % 3); //-1
System.out.println(10 % -3); //1
System.out.println(-10 % -3);//-1
8.3 自增
作为独立语句使用，i++；和++i：的意思一样，都是i = i + 1;
作为表达式使用：
int i = 8;
int k = ++i; //先自增，i = i + 1；k = i； i = 9 ，k = 9
int k = i++; //后自增，k = i; i = i + 1; i = 9,k = 8
面试题1：
使用临时变量：
(1)temp = i;
(2)i = i + 1;
(3)i = temp;
int i = 1;
i = i++；
System.out.println(i);//1
面试题2：
使用临时变量：
(1)i = i + 1;
(2) temp = i;
(3)i = temp;
int i = 1;
i = ++i；
System.out.println(i); //2
算术运算符练习
1.假如假期还有59天，问合几星期零几天？
思路分析：
(1) 使用int变量 保存天数
(2) 一个星期是七天，星期数=天数/7，零几天用天数取余
int days = 59;
int week = days / 7;
int day = days % 7;
System.out.println(days+"天 合"+week+"星期零"+day+"天");
结果：59天 合8星期零3天
2.定义一个变量保存华氏温度，华氏温度转摄氏温度的公式为5/9*(华氏温度-100)，请求出华氏温度对应的摄氏温度。
思路分析：
(1)先定义一个doule 变量保存 华氏温度
(2)根据给出的公式，进行计算即可
考虑数学公式和Java语言的特性：5/9*(华氏温度-100)，在Java中5/9等于0，后面运算都会为0，所以要将int型改为double型，5.0/9*(华氏温度-100)
double huashi = 234.6
double sheshi = 5.0 /9 *(huashi - 100);
System.out.println("华氏温度对应的摄氏温度为："+sheshi);
结果：华氏温度对应的摄氏温度为：74.72222222222223
9.逻辑运算符
9.1 逻辑与&，短路与&&
a，b同时为真才为真
逻辑与&，第一个条件如果为假，后面的条件仍然会判断，效率低
短路与&&，第一个条件为假，就结束了，不会判断后面的条件，效率高
9.2 逻辑或| ，短路或||
a，b有一个为真，结果就是真，
逻辑或|，不管第一个是否为真，后面的条件都会判断，效率低
短路或||，第一个条件为真，后面的条件就不会判断，效率高
9.3 ！a取反
或者叫非运算，a为真时，！a为假
9.4 a^b 逻辑异或
当a和b不同时结果为真
逻辑运算符练习
boolean x = true;
boolean y = false;
short z = 46;
if((z++==46)&&(y=true)) z++; //把true赋值给y，这个语句就是真的
if((x=false)||(++z==49)) z++;//把false赋值给x，现在这个语句就为假
System.out.println("z="+z);
//z=50
10.复合赋值运算符会进行类型强转
byte b = 3;
b += 2; //等价于 b=(int)(b+2);
b = b + 2 // 这样写就是错的
b++; //也进行了类型转换，不会报错
11.三元运算符
int a = 10;
int b = 99;
int result = a>b ? a++: b--;
System.out.println("result="+result);
//结果是99
解读：
(1)a >b 为false
(2) 返回 b–【一真大师：如果关系式为真，返回第一个表达式，否则返回第二个】
(3)b–是后自减，所以先返回b的值，99，b再进行自减
11.1三元运算符细节：
表达式1和表达式2要为可以赋给接收变量的类型(或者可以自动转换或者强制转换)
int a = 3;
int b = 8;
int c = a>b ? (int)1.1 : (int)3.4;// 强制转换 double->int
double d = a>b ? a:b+3; //自动转换，int->double
####11.2 三元运算符可以转换为if – else语句
三元运算符练习
实现十个数的最大值
int a = 2;
int b = 5;
int c = 4;
int d = a>b? a: b;
int max = d>c ? d: c;
System.out.println("max="+max);
结果：max=5
12. 运算符的优先级
12.1 只有单目运算符和赋值运算符是从右向左运算的
12.2 优先级
(1) ()，{}等
(2)单目运算符，只针对于一个数的，++，–
(3)算术运算符 加减乘除取余
(4)位移运算符 >> << >>>
(5)比较运算符 < > <= >= == !=[他俩的优先级小于前面四个]
(6)逻辑运算符 逻辑与或非 的优先级大于短路与非
(7)三元运算符 ？：
(8)赋值运算符 = *= += 等等
13. 标识符的命名规则和规范
规范：
(1) 包名：多单词组成时所有字母都小写 aaa
(2) 类名，接口名：多单词组成时，所有单词的首字母大写 Aaa
(3)变量名，方法名：多单词组成时，第一个单词首字母小写，别的单词首字母大写 tankShotGame
(4)常量名：所有字母都大写，用下划线连接 TAX_RATE
14.进制
- 二进制：0，1 以0b或者0B开头
- 十进制
- 八进制：以数字0开头，01010
- 十六进制：0-9，A(10)-F(15),以0x或或者0X开头，a-f不区分大小写
15. 原码 反码 补码
- 二进制的最高位是符号位，0表示正数，1表示负数
- 正数的原码，反码，补码都一样
- 负数的反码=它的原码符号位不变，其他位取反
- 负数的补码=它的反码+1，负数的反码=负数的补码-1
- 0的反码补码都是0
- Java中的数都是有符号的
- 在计算机运行的时候，都是以补码的方式来运算的
- 当我们看运算结果的时候，要看它的原码
###16.位运算符
Java中有7个位运算( & | ^ ~ >> << >>>)
- 按位与&： 两位全为1，结果为1，否则为0
10111000
11111001
10111000
- 按位或|：两位有一个1，结果为1，否则为0
- 按位异或^:两位不一样为1，一样为0
- 按位取反~：0 → \rightarrow → 1,1 → \rightarrow → 0
位运算练习
####1.2&3=?
首先计算机中都是补码在进行运算，第一步是要得到它们的补码
要得到补码，先得到原码，正数的原码补码一样
2的原码 00000000 00000000 00000000 00000010
2的补码 00000000 00000000 00000000 00000010
3的原码 00000000 00000000 00000000 00000011
3的补码 00000000 00000000 00000000 00000011
按位与&：两位都都为1，结果为1
00000000 00000000 00000000 00000010
00000000 00000000 00000000 00000011
00000000 00000000 00000000 00000010 （运算后的补码）
但是符号位为0，原码也是这个
再转换为十进制为2
所以2&3=2
System.out.println(2&3); //2
2.~-2=?
先得到-2的原码 10000000 00000000 00000000 00000010
运算的时候以补码进行
-2的补码是 它的反码+1
-2的反码是它的原码符号位不变，其他位取反
11111111 11111111 11111111 11111101（-2的反码）
11111111 11111111 11111111 11111110 （-2的补码）
~-2，按位取反
00000000 00000000 00000000 00000001
运算后的原码为00000000 00000000 00000000 00000001
转化为十进制为1
3. int a=1>>2 1/2/2
结果为 0
00000010 → \rightarrow → 00000000
int c=1<<2
00000001 → \rightarrow → 00000100
结果为 4
4<<3 32
00000100 → \rightarrow → 00100000
17.
####1. -10.5%3=？
a%b，当a是小数时，公式=a-(int)a/b*b
-10.5%3=-10.5-int(-10.5)/3*3=-10.5-(-9)=-1.5
有小数参与的运算，得到的结果是近似值
2.
int i = 66;
System.out.println(++i+i);
先自增，i=i+1=67.i=i+i=67+67=134
18.switch 细节
18.1
表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，常量是int
18.2
switch中的表达式的返回值必须是byte，short，int，char，enum（枚举），
string
switch练习
对于学生成绩大于60分的，输出合格。低于六十分的，输出不合格(注：输出的成绩不能大于100)
思路分析：
(1) 这里我们需要一个转换，编程思路：
如果成绩在[60,100],(int)(成绩/60)=1
如果成绩在[0,60],(int)(成绩/60)=0
(2)用if-else控制成绩在0-100
import java.util.Scanner;
public class a {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩：");
double score = scan.nextDouble();
if(score>=0&&score<=100) {
switch((int)(score/60)) {
case 0 :
System.out.println("不合格");
break;
case 1 :
System.out.println("合格");
}}
else {
System.out.println("输入的成绩不在0-100");
}
}
}
switch中的穿透
3，4，5是春季
case 3：
case 4：
case 5：
System.out.println(“是春季”);
break；
19.for循环
19.1 for循环细节
（1）for( ; 循环判断条件 ；) 中的初始化变量变量迭代可以写到别的地方，但是两边的分号不能省略
int i = 1;
for(; i <= 10 ;){
System.out.println("hello"+i)
i++;
}
(2) 这是一个无限循坏，死循环 +break
CTRL+c退出
for(;;){
System.out.println("hello");
}
(3)循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，
循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
int count = 3;
for(int i = 0,j = 0;i<count ;i++,j+=2){
System.out.println("i="+i+"j="+j);
}
结果：i=0 j=0
i=1 j=2
i=2 j=4
19.2 for循环练习
1.打印1~100之间所有是9的倍数的整数，统计个数及总和
编程思想：
(1)化繁为简：即将复杂的需求，拆解成简单的需求，逐步完成
(2)先死后活：先考虑固定的值，然后转化成可以灵活变化的值
思路分析：
化繁为简
(1)完成输出1-100的值
(2)在输出的过程中进行过滤，只输出9的倍数 i%9==0
(3)统计个数 定义一个变量 int count = 0；当条件满足时count++
(4)总和，定义一个变量int sum = 0； 当条件满足时累计 sum+=0
int count = 0;
int sum = 0;
for(int i = 1; i<=100 ;i++) {
if(i%9==0) {
System.out.println("i="+i);
count++;
sum+=i;
}
}
System.out.println("count="+count);
System.out.println("sum="+sum);
i=9
i=18
i=27
i=36
i=45
i=54
i=63
i=72
i=81
i=90
i=99
count=11
sum=594
定义变量 int start； int end 代替 1 和 100 ，也可以定义变量替代9的倍数
这就是先死后活
2. 完成下列的表达式输出
0+5=5
1+4=5
2+3=5
3+2=5
5+0=5
for(int i = 0 ,j = 5; i<=5; i++,j-- ) {
System.out.println(i+"+"+j+"="+(i+j));
}
结果：
0+5=5
1+4=5
2+3=5
3+2=5
4+1=5
5+0=5
缺点：复杂度高，不灵活
int n=5;
for(int i = 0;i <= n; i++){
System.out.println(i+"+"+(n-i)+"="+n);
}
化繁为简：
(1)先输出第一列，
(2)5-i是第二列
先死后活
20.whlie循环
while（循环条件）{
循环体（语句）；
循环变量迭代；
}
while练习
1.打印1-100之间所有能被3整除的数
化繁为简：
（1）定义变量int i ，先输出1-100
（2）在输出结果中进行筛选，能被三整除的输出 i%3==0
int i = 40;
while(i<=200) {
if(i%2==0) {
System.out.println(i);}
i++;
}
与do while的区别
do whlie 一定会执行一次，先执行再判断
要账
多重循环控制
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.println("i="+i+"j="+j)
}
}
第一层循环 i=0, 判断i<2,true 继续执行
来到循环 j=0，判断j<3,true 继续执行
输出i=0 j=0
然后执行 j++，j=1，判断j<3，true，继续执行
输出i=0 j=1
继续执行 j++，j=2，判断j<3，true，继续执行
输出i=0 j=2
继续执行 j++，j=3，判断j<3，flase，退出内循环，继续执行外循环
执行i++，i=1，判断i<2,true 继续执行
又来到内循环，执行int j = 0，判断j<3，true，继续执行
输出i=1 j=0
重复内循环两次，输出i=1 j=1，i=1 j=2
然后不满足j<3,退出内循环，来到外循环
在执行i++，这是不满足条件i<2,退出外循环。
多重循环控制练习
1.统计三个班成绩情况，每个班有五名同学，求出各个班的平均分和所有班级的平均分，学生的成绩由键盘输入
// 思路分析：
// 化繁为简：
// (1)先输出出一个班的五个学生的成绩 创建scanner对象
// (2) 定义int sum 累计求出一个班级的总分 sum/5 求出平均分
// (3) 把1改成变量，计算三个班级各自的平均分，
// (4) 定义一个新变量 totalscore 累计三个班的平均分总和，然后 totalscore/15.算出所有班级的平均分
import java.util.Scanner;
public class a {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int totalscore = 0 ;
for(int i = 1; i<=3; i++) {
int sum = 0;
for(int j = 1; j<=5 ;j++) {
System.out.println("请输入第 "+i+"个班的第"+j+"个学生的成绩：");
double score = scan.nextDouble();
sum+=score;
}
totalscore+= sum;
System.out.println("第"+i+"个班的平均分为"+(sum/5));
}
System.out.println("所有班的平均分为"+(totalscore/15));
}
}
21. 字符串比较方法equals
String name = "林黛玉"
System.out.println(name.equals("林黛玉"));
//输出true
System.out.println("林黛玉".equals(name));
//更推荐，因为这种写法能避免空指针
22. return使用在方法，表示跳出所在方法，如果return写在main方法，退出程序
23.数组
23.1 初始化 第一种 动态初始化
int a[] = new int[5];
23.2 初始化第二种
double scores[];//先声明，还没有分配空间
scores = new double [5];//分配内存空间，可以存放数据了
scores.length 数组长度
23.3 初始化第三种 静态初始化
int a[] = {2,3,5,6,67,89};
####23.4 数组创建后，如果没有赋值，有默认值，int ，short ， long ， byte 0 ，float double 0.0 char \u0000, boolean false, string null.
23.5
int a[5]; 非法数组，java语言声明数组的时候不能指定其长度（元素的个数）
24 二维数组
其实就是一个一维数组，它的每一个元素又是一个一维数组，在数组中再存放数组，外层数组看做是行，内层数组看做是列
24.1 初始化
定义一个二维数组，其中有三个一维数组，每个一维数组中有两个元素
int [] [] a = new int [3] [2]; // 动态初始化
int [] [] a = new int [] [] {{1,2},{3,4},{5,6}}; // 静态初始化
int [] [] a = {{1,2},{3,4},{5,6}}; // 静态初始化
24.2 使用
int [] [] arr = {{3,1,5},{2,6},{8}};
元素值5的表达方式为 ：arr[0] [2] = 5;
第二个一维数组的长度表示方式为 int len = arr [1].length;
对二维数组的遍历使用for的嵌套循环，二维就用两层for嵌套
常见操作：
1.给数组元素赋值
2.数组名[索引] = 数组类型的值 ;
3.访问数组元素
4.数组类型 变量 = 数组名[索引];
5.得到数组的长度
6.int len = 数组名.length; //length是数组的属性
7.遍历数组
数组操作常见问题
（ArrayIndexOutOfBoundsException）表示数组脚标越界异常
（NullPointerException）表示空引用异常
,67,89};
####23.4 数组创建后，如果没有赋值，有默认值，int ，short ， long ， byte 0 ，float double 0.0 char \u0000, boolean false, string null.
#### 23.5
int a[5]; 非法数组，java语言声明数组的时候不能指定其长度（元素的个数）
### 24 二维数组
其实就是一个一维数组，它的每一个元素又是一个一维数组，在数组中再存放数组，==外层数组看做是行，内层数组看做是列==
#### 24.1 初始化
定义一个二维数组，其中有三个一维数组，每个一维数组中有两个元素
```java
int [] [] a = new int [3] [2]; // 动态初始化
int [] [] a = new int [] [] {{1,2},{3,4},{5,6}}; // 静态初始化
int [] [] a = {{1,2},{3,4},{5,6}}; // 静态初始化
24.2 使用
int [] [] arr = {{3,1,5},{2,6},{8}};
元素值5的表达方式为 ：arr[0] [2] = 5;
第二个一维数组的长度表示方式为 int len = arr [1].length;
对二维数组的遍历使用for的嵌套循环，二维就用两层for嵌套
常见操作：
1.给数组元素赋值
2.数组名[索引] = 数组类型的值 ;
3.访问数组元素
4.数组类型 变量 = 数组名[索引];
5.得到数组的长度
6.int len = 数组名.length; //length是数组的属性
7.遍历数组
数组操作常见问题
（ArrayIndexOutOfBoundsException）表示数组脚标越界异常
（NullPointerException）表示空引用异常
852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
