个人的学习记录
第一日 简单的DOS命令
主界面按windows+R进入运行界面，输入cmd进入命令提提示符
- cd=choose directory=进入某个文件夹
- md=make directory=创建新文件夹
- del 删除文件-----------通配符*用例：del *.txt（删除所有txt结尾的文件）
- rd=remove =删除目录（只能删除空目录）
学习进度：P25
第二日 java环境搭建
了解了JDK配置 、了解了环境变量的配置
在cmd中，先用javac+文件名.java编译，再输入java+文件名.java 运行
注释：多行注释快捷键：shift+ctrl+/
class HelloJava{
/*main方法：程序的入口*/
public static void main（String[] args）{
/*println=printline*/
System.out.println("Hellojava")
}
}
java特有的文档注释： 可以被javadoc所解析
/**
啊啊啊啊文档注释内容
*/
API：
一些基本编程接口，类库
一个java源文件中，可有很多class，但是只能有一个public class，而且只能加到和文件名同名的类上
输出语句：
System.out.print();输出数据
System.out.println();输出数据，然后换行，如果无数据，那就直接换行
标识符：自己给变量起的名字,Java中区分大小写严格，所以Static可作为标识符，static不可以
变量：
class
//变量的定义
int myAge=12；
//变量的使用
System.out.print(myAge);
int number;
nubmer=12;
注意区分全局变量和局部变量
\n:换行符
\t:制表符
ASCII码值：
a:97 A:65
变量的分类：
-
基本数据类型
-
整形：byte(1字节) / short(2字节) / int(4字节) / long(8字节) 默认int
-
浮点型：float/double(float比double大，所以float定义的时候，数据后要加F，不然会默认为double）
-
字符型：char（1字符=2字节），定义char通常使用单引号''，内部只能写一个字符，所以通常使用string字符串
-
布尔形: boolean （ 通常在循环和判断中使用
-
-
引用数据类型
- 类：class
- 接口：interface
- 数组：array
UTF-8：一种Unicode的编码方式
自动类型提升运算法则：
容量小的变量和容量大的变量做运算的时候，结果为大的那个
byte b1=2;
int i1=3;
int i2=b1+i1；
System.out.println(i2)；
(byte/short/char)->int->long->float->double
↑这三种类型做运算时，结果都为int类型
强制转化运算法则：
class VariableTset{
public static void main(String[] args){
double x=12.4;
//加上(int)强转符
int y=(int)x;
System.out.println(y);
}
}
输出的值是12.强转可能会损失精度
String
属于引用数据类型，翻译为字符串，声明String变量时，使用双引号
String s1="hello World"；
String s2="a"；
String s3=" "；//编译通过
char c=""; //编译不通过
int number =1001;
String numberStr ="学号："；
String info=number + numberStr;
System.out.print(info);
得到："学号：1001"
练习：进行下列计算
char c= 'a';
int num =10;
String str="hello";
System.out.pringln(c + num + str); //107hello
System.out.pringln(c + str + num); //ahello10
System.out.pringln(c + (num + str)); //a10hello
System.out.pringln((c + num) + str); //107hello
System.out.pringln(str + num + c); //hello10a
练习：下列代码会生成什么？
System.out.pringln("* *"); // 结果为* *
System.out.pringln('*' + '\t' + '*'); //结果为93，char型的相加
System.out.pringln('*' + "\t" + '*'); //结果为 * *，char+String
System.out.pringln('*' + '\t' + "*"); //结果为51*
System.out.pringln('*' + ( '\t' + "*") ); //结果为* *
String str1=123; //编译不通过
String str1=123+""; //编译通过,输出的是字符串形式的123
运算符
- 算术运算符
- 加（+）减（-）乘（*）除（/）除法注意int型和double型的转换
- ++/--
前++，先自增1，再运算
后++，先运算，再自增1
int a=10;
int b=a++; //a=11,b=10
int c=++a; //a=11,c=11
但是如果是int a=10;
a++; 或者 ++a;
int b=a; //此时b都等于11
前后--同理
```
- %：取模，即为取余数 7%5 =2 187%10=7；187%100=87； 187%100/10=8
## 第二日进度：P75
- 赋值运算符 =
int i=10,y=13;
-------------------------------------
int num1=10;
num1+=2; //意思是num1=num1+2;
System.out.print(num1); //结果是12
---------------------------------------------
int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);
-----------------------------------------------
short s1 = 10;
s1 = s1 + 2; //编译失败，因为改变数据类型了
s1 += 2; //编译成功 结论：这种写法不会改变变量本身的数据类型
System.out.println(s1);
① 开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 2; 方式二：num += 2; (推荐)
② 开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 1; 方式二：num += 1; 方式三：num++; (推荐)
例题：
int n=10;
n+=(n++)+(++n);
System.out.println(n);
----------------------------------------
解： n+=(n++)+(++n);可看做n=n+(n++)+(++n)
第一个n=10
第二个(n++),先赋值10,再++，所以虽然值变成了11，但是输出还是10
第三个(++n),因为前一个是11，再++，是12
所以是10+10+12=32
答： n=32；
- 比较运算符== 、 ！= 、 < 、> 、 <= 、 >=
比较运算符结果都是bool类型，注意==不能写成= 例：
int i=10,j=20;
System.out.print(i==j); //输出false
System.out.print(i=j); //输出20
==比较的是内存地址，是不是同一个对象
- 逻辑运算符
与：&& 指两个都需要满足
区分& 与 &&
//相同点1：& 与 && 的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
//开发中，推荐使用&&
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num1 = " + num1);
输出的是南京和11
--------------------------------------------
boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num2 = " + num2);
输出的是南京和10，因为南京已经是false了，所有不进行后面的num2++计算
或：|| 两者只要有一个是true，那即是true
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num3 = " + num3);
输出是北京和11
-------------------------------------------
boolean b4 = false;
b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num4 = " + num4);
同理，输出是北京和10
- 位运算符(较少）
在二进制层面进行计算 例：
8<<1 意思是二进制上，8向左移一位，后面补0，被移除的高位丢弃
0000 1000 变为
0001 0000
所以8<<1=16
- 三元运算符
结构:（条件表达式）？表达式1：表达式2
说明：条件表达式的结果为bool类型，根据条件表达式的真或假，决定执行1还是2，true为1，false为2
例：
比较大小
int m=12,n=5;
int max= (m>n)? m : n ;
System.out.println(max); //输出为12
--------------------------------------
String maxstr=(m>n) ? "m大" ："n大"
关于流程控制
if-else结构
Scanner：从键盘获取变量
具体步骤：
1导包 import java.util.Scanner;基本写在最上面
2实例化
Scanner scan= new Scanner(System.in);
3调用Scanner类的相关方法，获取指定类型的变量
int num=scan.nextInt();
总结：
如何从键盘获取不同类型的变量
import java.util.Scanner;
class ScannerTset{
public static void mian (String[] args){
Scanner scan =new Scanner(System.in);
System.out.println("请输入你的编号");
int num= scan.nextInt(); //获取int类型，想要获取别的类型，要另外添加.
System.out.println(num);
System.out.println("请输入你的姓名");
String name=scan.next(); //获取Str类型数据
System.out.println(name);
System.out.println("请输入你的体重");
double weight = scan.nextDouble(); //获取double类型数据
System.out.println(weight);
System.out.println("你是否单身?")
boolean choose= scan.nextBoolean(); //bool类型
System.out.println(choose);
}
}
然后在键盘输入对应类型数据，就可输出此数据
小练习： 爸爸准备按照小明的期末成绩给与小明奖励，满分给宝马，(80,99]给iPhone，[60,80]给本子，不及格什么都不给，要求从键盘输入数据，请设计代码。
import java.util.Scanner;
class Tset{
public static void mian (String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入学生的考试成绩0~100");
int score =scan.nextInt();
if (score==100){
System.out.println("宝马");
}
else if(score > 80 && score<= 99){
System.out.println("iphone");
}
else if(score >= 60 && score<= 80){
System.out.println("本子");
}
else
System.out.println("什么都没有");
}
}
随机数获取：
int vlaue=Math.random() //范围是[0,1)
Math.random()*100 //范围是[0,100)
Math.random()*90+10 //范围[0,90)再+10--->[10,100)
公式：[a,b]: (int)( Math.random() *(b-a+1) +a )
switch-case结构
根据switch表达式中的值，依次匹配各个case中的常量，匹配成功后进入该case，再调用case中的执行语句，调用完后，必须用break跳出，不然会一直向下执行其他case语句
表达式中只有六种类型：byte、short、char、int、枚举、String
switch(表达式){
case 常量1:
语句1；
break；
case 常量2：
语句2；
break；
case 常量N：
语句N；
break；
default：
语句；
break；
}
String类型：
例题：从键盘输入2019年的月份和日期，自动得出这一天是2019年的第几天
if-else写法：
import java.util.Scanner;
class Switch{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年月份");
int month = scan.nextInt();
System.out.println("请输入2019年日期");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumdays=0;
if(month==1){
sumday=day;
}
else if(month==2){
sumday=31+day;
}
else if(month==3){
sumday=31+28+day;
}
else if(month==4){
sumday=31+28+30+day;
}
......
System.out.printin(sumday);
}
}
比较冗余
switch-case写法：
import java.util.Scanner;
class Switch{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年月份");
int month = scan.nextInt();
System.out.println("请输入2019年日期");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumday=0;
switch(month){
case 1:
sumday=day;
break;
case 2:
sumday=31+day;
break;
.....
}
System.out.println(sumday);
}
}
也有冗余
最佳写法：
import java.util.Scanner;
class Switch{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年月份");
int month = scan.nextInt();
System.out.println("请输入2019年日期");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumdays=0;
switch(month){
case 12:
sumday +=30;
case 11:
sumday +=31;
case 10:
sumday +=30;
......
case 3:
sumday +=28;
case 2:
sumday +=31;
case 1:
sumday +=day;
}
System.out.println(sumday);
}
}
解析：不写break，让case自动向下叠加，如果是2月，那就是1月份的天数31天加上2月的day,同理3月就是day（自己月份的天数）+28（二月份）+31（一月份）
循环结构 for/while/do-while
循环四要素：初始化条件、循坏条件、循环体、迭代条件
for循环
for(初始化条件;循环条件;迭代条件){
循环体；
}
例：
for(int i=0;i<10;i++){
System.out.println(i);
}
分析：先定义一个int类型的i作为初始值，为0，然后判断是否<10，满足后输出，输出后进行i++，此为一个循环。
++后为1，然后1再次判断<10，是就输出1，这个时候输出为0、1..以此类推...
注意当到10的时候，因为10并不大于10，所以10不算在内
最终结果：0 1 2 3 4 5 6 7 8 9
练习：
int num=1;
for(System.out.println('a');num<=3; System.out.println('c'),num++){
System.out.println('b'); //abcbcbc
结果：abcbcbc,初始化为a，当num<3时，输出b，然后输出c的同时num++，循环3次
练习：输出1~10之间所有偶数的和，并且写出所有偶数的个数和
int sum=0; //总和
int count=0; //个数和
for(int i=1;i<=10;i++){
if(i%2==0){
System.out.println(i);
sum+=i;
count++;
}
}
System.out.println("总和为："+sum);
System.out.println("个数为："+count);//注意输出要写在循环的外面
输出为：
2
4
6
8
10
总和为：30
个数为：5
练习：输出1~150，在3的倍数后面加上“3的倍数”，5倍数的后面加上“5的倍数”，7的倍数后面加上“7的倍数”
for(int i=1;i<=150;i++){
System.out.print(i+"");//关键在于不要用println，最后再换行
if(i%3==0){
System.out.print(" 3的倍数");
} //不要加else
if(i%5==0){
System.out.print(" 5的倍数");
}
if(i%7==0){
System.out.print(" 7的倍数");
}
System.out.println();
}
结果：
1
2
3 3的倍数
4
5 5的倍数
6 3的倍数
7 7的倍数
8
9 3的倍数
10 5的倍数
11
12 3的倍数
13
14 7的倍数
15 3的倍数 5的倍数
16
17
18 3的倍数
19
20 5的倍数
21 3的倍数 7的倍数
....
break在for循环中的作用：
练习：输入两个正整数，求这两个数的最大公约数和最小公倍数
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);//实例化
System.out.println("输入第一个数");
int m=scan.nextInt();
System.out.println("输入第二个数");
int n=scan.nextInt();
int min=(m<n)? m:n; //获取两个数中的较小的那个
int max=(m>n)? m:n; //获取两个数中的较大的那个
System.out.println("公约数为");
for(int i=min;i>=1;i--) {
if (n % i == 0 && m % i == 0) {
System.out.println(i);
}
} //这个循环求的是所有的公约数
for(int i=min;i<=n*m;i--) {
if (n % i == 0 && m % i == 0) {
System.out.println("最大公约数为"+i);
break;
}
} //加上break，只输出第一个找到的，就是最大公约数
for(int i=max;i>=1;i++) {
if (i % n == 0 && i % m == 0) {
System.out.println("最小公倍数为"+i);
break;
}
} //这里必须加break，不然会一直算下去
}
输入12和20
结果：
输入第一个数
20
输入第二个数
12
公约数为
4
2
1
最大公约数为4
最小公倍数为60
例题：经典水仙花数：水仙花数是指一个三位数，各个位数上的立方和相加等于本身，如153=1×1×1+5×5×5+3×3×3，请输出所有水仙花数。
System.out.println("水仙花数");
for(int i=99;i<1000;i++){
int a,b,c=0;
a=i/100; //取百位
b=(i/10)%10; //取十位
c=i%10; //取个位
if(i==(a*a*a)+(b*b*b)+(c*c*c)){
System.out.println(i);
}
}
结果：
水仙花数
153
370
371
407
while循环 注意：for循环和while循环可相互转化
while的循环结构:
初始化条件
while(循环条件bool类型){
循环体；
迭代条件;
}
例子：遍历10内的所有偶数
int i=1;
while (i<=10){
if(i%2==0){
System.out.println(i);
}
i++; //注意这个迭代条件的位置，不然可能会死循环
}
结果：
2
4
6
8
10
逻辑：先1进去，当满足<=10的时候，进行语句的执行，输出数，然后迭代一下，++，
成为2，再次判断<=10....
while循环基本等同于for循环，唯一不同的可能就是条件域的区别
do-while循环
初始化条件
do{
循环体；
迭代条件
}
while(循环条件);
例：遍历10以内偶数
int a=1;
do {
if(a%2==0){
System.out.println(a);
}
a++;
}while (a<=10);
说明： 至少会执行一次循环
无限循环综合例题(while(ture))：从键盘输入个数不确定的整数，并判断正数和负数的个数，当输入为0时结束程序
Scanner scan=new Scanner(System.in);//实例化
System.out.println("请输入数据");
int zhengshu=0;//定义正负数个数类型
int fushu=0;
//写true表示不限制次数，如果是for，就是for(;;)
while (true) {
int number=scan.nextInt(); //先获取输入的值
if(number>0){ zhengshu++;} //判断正数，正数++
else if(number<0){ fushu++; } //判断负数，负数++
else {break;} //不是正负，就break，跳出循环
}
System.out.println("正数个数"+zhengshu);
System.out.println("负数个数"+fushu);
结果：
请输入数据
5
1
7
-8
0
正数个数3
负数个数1
嵌套循环（三层以内）
定义：将一个循环结构A声明在另一个循环结构B的循环体中，就是嵌套循环
for (int i = 1; i <= 6; i++) { //这一行是****的循环，循环6次，换行
for(int j=1;j<=4;j++) { //这一行是*的循环，循环4次，因为没有换行，所以是****
System.out.print('*'); //注意是print
}
System.out.println();
}
结果：
****
****
****
****
****
****
分析：从内部循环先开始看，先循环*的四次变成****，在循环6次得到结果
进阶：写出这种图形： ****
***
**
*
for (int i = 1; i <= 4; i++) {
for(int j=4;j>=i;j--) {
System.out.print('*');
}
System.out.println();
}
解析：第一次j=4循环，从4个*开始，此时的i是1，j>=i循环4次，输入****，此时i开始循环，第一行输出完成
第二轮j=4开始，此时第二轮i=2，只循环3次，输出3个*** 这是第二行
以此类推
--------------------------------------------
同理写出 *
**
***
****
for (int i = 1; i <= 4; i++) {
for(int j=1;j<=i;j++) {
System.out.print('*');
}
System.out.println();
}
解析：j从1开始，第一行i=1，所以只有一个*
第二行i=2，j能取到1、2，所以循环了2次，输出2个*
以此类推
例：
for (int i = 1; i <= 6; i++) {
for(int k=7;k>=i;k--){
System.out.print("-");
} //这个是前面的“-”数
for(int j=1;j<=i;j++) {
System.out.print(" *");
} //这个是空格+*
System.out.println();
}
for (int i = 1; i <= 7; i++) {
for(int k=1;k<=i;k++) {
System.out.print("-");
} //同上，注意不要和上半部分最后一行重叠
for(int j=7;j>=i;j--) {
System.out.print(" *");
}
System.out.println();
}
解析：一个循环里面嵌套两个for循环，一起输出
结果：
------- *
------ * *
----- * * *
---- * * * *
--- * * * * *
-- * * * * * *
- * * * * * * *
-- * * * * * *
--- * * * * *
---- * * * *
----- * * *
------ * *
------- *
例：
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"×"+i+"="+i*j+"\t");
}
System.out.println();
}
解析：典中典之乘法表，结合代码更容易理解i与j的关系
结果：
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
1×4=4 2×4=8 3×4=12 4×4=16
1×5=5 2×5=10 3×5=15 4×5=20 5×5=25
1×6=6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36
1×7=7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49
1×8=8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64
1×9=9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81
例：输出100以内所有的质数
//质数，就是从2开始，到这个数-1为止，都不能被这个数整除
写法1：
for(int i=2;i<=100;i++){ //遍历100以内自然数
boolean isFlag=true; //标志i是否被j除尽，除尽就修改变成false
for(int j=2;j<=i-1;j++){ //遍历一遍i-1的数，被i去除
if(i%j==0){ //i被j除尽，说明这个数不是质数
isFlag =false;
}
}
if(isFlag==true){ //输出除不尽的，就是质数
System.out.println(i);
}
}
优化写法2：
for(int i=2;i<=100;i++){ //遍历100以内自然数
boolean isFlag=true; //标志i是否被j除尽，除尽就修改其值
for(int j=2;j<=Math.sqrt(i);j++){ //被i去除 优化1，变成根号i
if(i%j==0){ //i被j除尽，说明这个数不是质数
isFlag =false;
break; //优化2 只对本身非质数的自然数是有效的
}
}
if(isFlag==true){ //输出除不尽的
System.out.println(i);
}
}
速度更快
break 和continue关键字的使用
break: 使用在switch-case和循环结构中；作用：结束当前循环
continue：使用在循环结构中 作用：结束当次循环
对比：
for(int i=1;i<=10;i++){
if(i%4==0){
break;
/*System.out.println(“啊啊啊”); 这个地方的语句无法输出，无论是break还是continue，后面都不能跟输出语句，会报错*/
}
System.out.println(i);
}
结果：1 2 3 到4之后就跳出循环
----------------------------------------------------
for(int i=1;i<=10;i++){
if(i%4==0){
continue;
}
System.out.println(i);
}
结果： 1 2 3 5 6 7 9 10 到4和8的时候，结束当次循环，开始下一次
break和continue默认跳出包裹此关键字的最近一层循环
找完数：
一个数等于它的因子之和，这个数就是完数，比如6=1+2+3，求1000以内的所有完数
int sum=0;
for(int i=1;i<=1000;i++){
for(int j=1;j<=i-1;j++){
if(i%j==0){
sum+=j;
}
}
if(i==sum){
System.out.println(i);
}
sum=0; //sum要清零
}
