朝花夕拾-Java-入门基础-学习笔记1（已完结）

朝花夕拾,一个老年人的学习笔记,不妥请指,感谢
学习《Java零基础实战》宁楠/著

---

1.Java编码

1.1 强制编码规范

(1) java程序的文件名和类名必须保持一致,若不一致,java源文件将无法编译通过
(2)main()方法是程序的入口,方法的定义必须严格按照格式书写,public static void main(String[] args),缺一不可,否则java程序无法运行,只有参数列表的形参名称可以自定义
(3)类是组织java代码结构的,类中的方法是具体执行业务逻辑的,无论是类还是方法,都必须使用花括号{}来组织其结构,必须成对出现,

1.2 建议编码规范

(1)通常情况下,一行只写一条语句,程序结构清晰,方便阅读
(2)遵守一行只写一条语句的同时,还要注意代码缩进,不要每一行代码从左边写,注意缩进控制格式

1.3 注释规范

(1)单行注释: //注释内容
(2)多行注释: /* 注释内容 注释内容 注释内容 /
(3)文档注释: /** 注释内容 注释内容 注释内容 ***/
文档注释使用JDK的javadoc工具生成信息,并输出到HTML文件中,可以更加方便记录程序信息
@author 标识作者
@deprecated 过期的类或成员
@exception 抛出的异常
@param 方法的参数
@return 方法的返回
@see 指定参考的内容
@serial 序列化属性
@serialDate 通过writeObject()和writeExternal()方法写的数据
@serialField ObjectStreamField组件
@since 引入一个特定的变化
@throws 抛出的异常
@version 版本信息
{@docRoot} 标识当前文档根目录的路径
{@inheritDoc} 标识从直接父类继承的注释
{@link} 标识插入的主题链接
{@linkplain} 标识插入的主题链接,但该链接显示纯文本字体
{@value} 标识常量的值,必须是static属性

1.4 关键字

java关键字是java语言预先定义好的,有指定意义的标识符,是程序的核心组成,不是有开发者来定义的,java程序由"关键字+java类库+开发者自定义的标识符",关键字来创建程序的核心骨架,java类库提供程序要调用的方法,开发者自定义的标识符来指定程序完成相关工作.

abstract						标识类或方法为抽象
assert							断言,用于调试程序
boolean							基本数据类型
break							跳出整个循环体
byte							基本数据类型
case   							与switch搭配使用,标识变量符合某个条件
catch							与try搭配使用,捕获某个异常
char							基本数据类型,一个16位的Unicode字符
class							标识一个类
const							保留字
continue						跳出当前循环,执行下一次循环
default							与switch搭配使用,表示默认值
do 								与while搭配使用,标识循环体的开始
double							基本数据类型类型,表示双精度浮点数
else							与if搭配使用,标识不成立
enum							枚举类型
extends							标识类的继承
final							修饰常量,表示类不能被继承,方法不能被覆盖,变量值不能被修改
finally							与try,catch搭配使用,表示无论如何都会执行
float							基本数据类型
for								标识循环
goto							保留字
if								条件判断
implements						标识类实现某个接口
import							在类中引入某个包中的类
instanceof						判断变量的数据类型
int								基本数据类型
interface						接口
long							基本数据类型
native							修饰本地方法,表示该方法不是由java实现
new								创建实例对象
package							表示包,是一种组织java类的结构
private							访问权限修饰符,表示私有
protected						访问权限修饰符,表示保护
public							访问权限修饰符,表示共有
return							在方法中返回一个值
short							基本数据类型
static							静态修饰符
strictfp						表示FP-strict,精确浮点
super							标识调用父类的方法
switch							流程控制语句
synchronized					线程同步
this							表示嗲用当前实例对象的成员
throw							抛出异常
throws							标识在方法中可能会抛出的异常
transient						标识不可序列化状态
try								标识可能会抛出异常的代码块
void							标识当前方法没有返回值
volatile						修饰变量,线程在访问该变量时,读取的是该变量被修改之后的值,保证每个线程读取到的最新值
while							标识循环

1.5 变量

 public class hello {
    public static void main(String[] args){
        int principal;
        principal = 100;
        System.out.println(principal);
    }
}

1.6 基本数据类型

byte    1个字节(8位)    数据的最小单位,一字节为8位二进制,所以byte的取值范围是-128~127
int     4个字节(32位)   整数常用单位,取值范围-2147483648~2147483647
short   2个字节(16位)   短整型,特定情况下使用short比int节省内存,取值范围-32768~32767
long    8个字节(64位)   长整形,描述int无法正在的海量数据
float   4个字节(32位)   单精度浮点型,float类型的结尾必须添加"f"用以区分double
double  8个字节(64位)   双精度浮点型,比float存储范围更大,精度更高
char    2字节(16位)	   表示单个字符,可以是字母\汉字\数字\符号,ansic码
boolean 1/8字节(1位)	   判定逻辑条件,只有两个值true和false

String是jdk提供给开发者调用的一个类,其本质也是char类型数组

public class hello {
    public static void main(String[] args){
        int num = 10;
        double num2 = num;
        System.out.println(num2);
    }
}
10.0

byte->short->int->long->float->double

public class hello {
    public static void main(String[] args){
        byte num1 = 10;
        short num2 = num1;
        int num3 = num2;
        long num4 = num3;
        float num5 = num4;
        double num6 = num5;
        System.out.println(num1);
        System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);
        System.out.println(num5);
        System.out.println(num6);
    }
}
10
10
10
10
10.0
10.0

1.7 强制转换

public class hello {
    public static void main(String[] args){
        int num1 = 10;
        double num2 = num1;
        System.out.println(num1);
        System.out.println(num2);
    }
}
10
10.0

2.java运算符

2.1 运算符

赋值运算符

public class hello {
    public static void main(String[] args){
    double weight1 = 70.5;
    double weight2 = 60.5;
    System.out.println("交换之前张三的体重为:"+weight1+",李四的体重为:"+weight2);
    double weight3 = weight1;
    weight1 = weight2;
    weight2 = weight3;
    System.out.println("交换之后张三的体重为:"+weight1+",李四的体重为:"+weight2);    }
}
交换之前张三的体重为:70.5,李四的体重为:60.5
交换之后张三的体重为:60.5,李四的体重为:70.5

基本算数运算符

public class hello {
    public static void main(String[] args){
    int num = 326;
    int ones = num/100;
    System.out.println("分解326:");
    System.out.println("百位数是"+ones);
    int tens = num%100/10;
    System.out.println("十位数是"+tens);
    int hundreds = num%10;
    System.out.println("个位数是"+hundreds);
    int sum = ones+tens+hundreds;
    System.out.println("326各位数字之和是"+sum);
    }
}
分解326:
百位数是3
十位数是2
个位数是6
326各位数字之和是11

2.2 复合算数运算符

a += b
a  -= b
a  /= b
a %= b
public class hello {
    public static void main(String[] args){
    int num1 = 9;
    int num2 =10;
    num1 += num2;
    System.out.println(num1);
    num1 -= num2;
    System.out.println(num1);
    num1 /= num2;
    System.out.println(num1);
    num1 %= num2;
    System.out.println(num1);
    }
}
19
9
0
0

2.3 关系运算符

a == b
a != b
a > b
a < b
a >= b
a <= b
其中><<=>=只能用作数值比较

public class hello {
    public static void main(String[] args){
    int num1 = 10;
    int num2 = 11;
    boolean result = num1 == num2;
    System.out.println(result);
    }
}
false

2.4 逻辑运算符

变量A & 变量B
变量A | 变量B
变量A && 变量B
变量A || 变量B
!变量A

public class hello {
    public static void main(String[] args){
    int num1 = 10;
    int num2 = 11;
    System.out.println((num1++==num2)&(++num1==num2));
    System.out.println(num1);
    }
}
false
12

2.5 条件运算符

变量A = 条件?值1:值2,
如果条件成立,值1赋值给变量A,不成立,值2赋值给变量A
public class hello {
    public static void main(String[] args){
    String str1 = 11>10? "11>10成立":"11>10不成立";
    System.out.println(str1);
    String str2 = 11<10? "11<10成立":"11<10不成立";
    System.out.println(str2);
    }
}
11>10成立
11<10不成立

2.6 位运算符

变量A&变量B :每一位的数字一一对应,若都为1,则该位记作1.否则为0
变量A|变量B:每一位的数字一一对应,只要有一个是1,则该位记作1.否则为0
变量A^变量B:每一位的数字一一对应,相同记为0,不同记为1
变量A<<变量B:变量A乘以2的B次方,如2<<3,结果为2*8
变量A>>变量B:变量A除以2的B次方,如2>>3,结果2/8

public class hello {
    public static void main(String[] args){
    System.out.println(10&5);
    System.out.println(10|5);
    System.out.println(10^5);
    System.out.println(2<<3);
    System.out.println(2>>3);
    }
}
0
15
15
16
0

3.java流程控制

3.1 流程控制

3.1.1 if-else

public class HelloWorld {
    public static void main(String[] args){
    int score = 100;
    System.out.println("本次答题得分："+score);
    if(score>80){
        System.out.println("恭喜你，获得满100减20元优惠卷一张！");

    }else{
        System.out.println("很遗憾，没有中奖");
    }
    }
本次答题得分：100
恭喜你，获得满100减20元优惠卷一张！

3.1.2 多重if

public class HelloWorld {
    public static void main(String[] args){
    int height = 176;
    if(height > 178){
        System.out.println("XL码");
    }
    if(height>=173&&height<=178){
        System.out.println("L码");
    }
    if(height<173){
        System.out.println("M码");
    }
    }
}
L码

3.1.3 嵌套

public class HelloWorld {
    public static void main(String[] args) {
    int score = 90;
    int age = 22;
    if(score > 80){
        if(age >= 20){
            System.out.println("成功晋级A组");
        }else if(age >= 18){
            System.out.println("成功晋级B组");
        }
    }
    }
}
成功晋级A组

3.1.4 switch-case

public class HelloWorld {
    public static void main(String[] args) {
    int placing = 1;
    switch(placing){
        case 1:
            System.out.println("奖励2000元");
            break;
        case 2:
            System.out.println("奖励1000元");
            break;
        case 3:
            System.out.println("奖励500元");
            break;
        default:
            System.out.println("没有奖励");
            break;
    }
    }
    奖励2000元

3.2 循环

3.2.1 while循环

public class HelloWorld {
    public static void main(String[] args) {
        int num = 0;
        while (num < 10) {
            System.out.println("hello world");
            num++;
        }
    }
}
hello world
hello world
hello world
hello world
hello world
hello world
hello world
hello world
hello world
hello world

import java.util.Scanner;
public class HelloWorld{
    public static void main(String[] args){
        System.out.println("学生成绩查询系统");
        Scanner scanner = new Scanner(System.in);
        int num;
        String str = "yes";
        while(str.equals("yes")){
            System.out.println("请输入学生编号：");
            num = scanner.nextInt();
            switch (num){
                case 1 :
                    System.out.println("张三的成绩为90");
                    break;
                case 2 :
                    System.out.println("李四的成绩为90");
                    break;
                case 3 :
                    System.out.println("王五的成绩为90");
                    break;
            }
            System.out.println("是否继续？yes/no: ");
            str = scanner.next();
        }
        System.out.println("查询结束");
    }
}
学生成绩查询系统
请输入学生编号：
1
张三的成绩为90
是否继续？yes/no: 
yes
请输入学生编号：
3
王五的成绩为90
是否继续？yes/no: 
no
查询结束

3.2.2 do-while循环

public class HelloWorld{
    public static void main(String[] args){
        int num = 0;
        do{
            System.out.println("Hello World");
            num++;
        }while(num < 10);
    }
}
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World

3.2.3 for循环

public class HelloWorld{
    public static void main(String[] args){
        for(int i = 0;i<10;i++){
            System.out.println("Hello World");
        }
    }
}
Hello World
Hello World
Hello World
Hello World

3.2.4 while、do-while和for循环的区别

相同点：都遵循循环四要素，初始化循环变量，循环条件，循环体，更新循环变量
不同点：
1.while和do-while适用于循环次数不确定的场景；for适用于循环次数确定的场景
2.while和for循环是先判断循环条件，再执行循环体；do-while是先执行循环体，在判断循环条件

3.2.5 双重循环

public class HelloWorld{
    public static void main(String[] args){
        for(int i=0;i<3;i++){
            for(int j=1;j<=6;j++){
                System.out.print(i+" ");
            }
        System.out.println("");
        }
    }
}
0 0 0 0 0 0 
1 1 1 1 1 1 
2 2 2 2 2 2 

public class HelloWorld{
    public static void main(String[] args){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
        System.out.println("");
        }

    }
}
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	

3.2.6 终止循环

public class HelloWorld{
    public static void main(String[] args){
        int sum = 0;
        for(int i =1;i<=100;i++){
            sum += i;
            if(sum>50){
                break;
            }
        }
        System.out.println("总和是"+sum);
    }
}
总和是55

3.3 数组

3.3.1 数组的概念

数组是一种可以存放大量数据类型的数据集合,数组中的数据必须是同一种数据类型.

3.3.2 数组的要素

一个数组分为4种基本要素,1.数组名称、2.数组元素、3.数组下标、4.数据类型
一个数组的数据类型必须是一致的

3.3.3 使用数组

1、声明数组：数据类型[]数据组，int[] array1 、string[] array2
2、分配内存空间：创建数组必须要指定数组的长度，根据指定长度在内存中开辟一串连续的空间，长度不能修改，数组名=new 数据类型[数组长度] 例如 array1 = new int[6] 表示array的长度为6
3、给数组赋值：分配完内存空间就可以像数组中存值了，通过下标找到数组中对应的内存空间，完成赋值，例如 array1[0]=1.
4，使用数组

public class HelloWorld{
    public static void main(String[] args){
        int[] array;
        array = new int[5];
        array[0] = 179;
        array[1] = 182;
        array[2] = 167;
        array[3] = 176;
        array[4] = 158;
        double sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        double avg = sum / array.length;
        System.out.println("平均身高是：" + avg);
    }
}

常见错误信息：
1、数组声明时数据类型不匹配；
2、边声明边赋值必须写在同一行；
3、数组长度越界。

3.3.4 数组的常用操作及方法

（1）数组中的最大值
（2）数组中的最小值
（3）在数组的指定位置插入一个数据
（4）数组排序

public class HelloWorld{
    public static void main(String[] args)
    {
     int[] array = {73,80,62,93,96,87};
     int max = array[0];
        for (int i = 0; i < array.length; i++)
        {
            if (array[i] > max)
            {
                max = array[i];
            }
        }
        System.out.println("最大值是：" + max);
        int min = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }
        System.out.println("最小值是"+min);
    }
}

import java.util.Arrays;
public class HelloWorld{
    public static void main(String[] args)
    {
        // 在数组下标3的位置添加83
        int[] arr = {96, 93, 87, 80, 73, 62};
        int score = 83;
        int[] arr2 = new int[arr.length+1];
        for (int i = 0; i < 3; i++) {
            arr2[i] = arr[i];
        }
        arr2[3] = 83;
        for (int i = 4; i < arr2.length; i++) {
            arr2[i] = arr[i - 1];
        }
        // Arrays工具类的tostring方法可以将数组的元素依次取出拼接成一个字符串
        System.out.println("添加新元素之前的数组" + Arrays.toString(arr));
        System.out.println("添加新元素之后的数组" + Arrays.toString(arr2));
    }
}
添加新元素之前的数组[96, 93, 87, 80, 73, 62]
添加新元素之后的数组[96, 93, 87, 83, 80, 73, 62]

java提供了一个工具类,通过调用该工具类的方法即可完成对数组的操作,保存在java.util包中

import java.util.Arrays;
public class hello {
    public static void main(String[] args)
    {
        int[] array = {73, 80, 62, 93, 96, 87};
        int[] array2 = {73, 80, 62, 93, 96, 87};
        int[] array3 = {66, 55, 44, 33, 22};
        System.out.println(Arrays.equals(array, array2));
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
        Arrays.fill(array2, 66);
        System.out.println(Arrays.toString(array2));
        int[] copyArray = Arrays.copyOf(array3, 10);
        System.out.println(Arrays.toString(copyArray));
        int index = Arrays.binarySearch(array, 87);
        System.out.println(index);
    }
}
[62, 73, 80, 87, 93, 96]
[66, 66, 66, 66, 66, 66]
[66, 55, 44, 33, 22, 0, 0, 0, 0, 0]
3

3.3.5 二维数组

public class hello {
    public static void main(String[] args)
    {
        int[][] array;
        array = new int[2][3];
        array[0][0] = 11;
        array[0][1] = 22;
        array[0][2] = 33;
        array[1][0] = 44;
        array[1][1] = 55;
        array[1][2] = 66;
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println(array[i][j]);
            }

        }

    }
}
11
22
33
44
55
66

public class hello {
    public static void main(String[] args)
    {
        int[][] array = new int[3][6];
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            System.out.println("--------------第" + (i + 1) + "货架层----------------");
            for (int j = 0; j < array[i].length; j++) {
                int num = (i + 1) * (j + 1);
                System.out.println("第" + (j + 1) + "个格挡的鸡蛋个数:" + num);
                sum += num;
            }
        }
        System.out.println("鸡蛋的总数是:"+sum);
            }

        }
        --------------第1货架层----------------
第1个格挡的鸡蛋个数:1
第2个格挡的鸡蛋个数:2
第3个格挡的鸡蛋个数:3
第4个格挡的鸡蛋个数:4
第5个格挡的鸡蛋个数:5
第6个格挡的鸡蛋个数:6
--------------第2货架层----------------
第1个格挡的鸡蛋个数:2
第2个格挡的鸡蛋个数:4
第3个格挡的鸡蛋个数:6
第4个格挡的鸡蛋个数:8
第5个格挡的鸡蛋个数:10
第6个格挡的鸡蛋个数:12
--------------第3货架层----------------
第1个格挡的鸡蛋个数:3
第2个格挡的鸡蛋个数:6
第3个格挡的鸡蛋个数:9
第4个格挡的鸡蛋个数:12
第5个格挡的鸡蛋个数:15
第6个格挡的鸡蛋个数:18
鸡蛋的总数是:126

import java.util.Scanner;
public class Test {
    String[] nameArray = {"张三", "李四", "王五", "小明"};
    int[] ageArray = {22, 33, 44, 55};
    String[] stateArray = {"正常", "正常", "正常", "正常"};
    Scanner scanner = new Scanner(System.in);
    int num;
    do
    {
        System.out.println("欢迎使用用户管理系统");
        System.out.println("1.查询用户");
        System.out.println("2.添加用户");
        System.out.println("3.删除用户");
        System.out.println("4.账号冻结");
        System.out.println("5.账号解封");
        System.out.println("6.退出系统");
        System.out.println("请选择:");
        num = scanner.nextInt();
        switch (num) {
            case 1:
                System.out.println("----------查询用户----------");
                System.out.println("编号\t\t名称\t\t年龄\t\t状态");
                for (int i = 0; i < nameArray.length; i++) {
                    if (nameArray[i] != null) {
                        System.out.println((i + 1) + "\t\t" + nameArray[i] + "\t\t" + ageArray[i] + "\t\t" + stateArray[i]);
                    }
                }
                System.out.println("输入0返回:");
                num = scanner.nextInt();
                break;
            case 2:
                System.out.println("-------添加用户--------");
                if (nameArray[nameArray.length - 1] != null) {
                    String[] newNameArray = new String[nameArray.length + 1];
                    String[] newstateArray = new String[stateArray.length + 1];
                    int[] newAgeArray = new int[ageArray.length + 1];
                    for (int i = 0; i < nameArray.length; i++) {
                        newNameArray[i] = nameArray[i];
                        newstateArray[i] = stateArray[i];
                        newAgeArray[i] = ageArray[i];
                    }
                    nameArray = newNameArray;
                    stateArray = newstateArray;
                    ageArray = newAgeArray;
                }
                System.out.println("请输入用户名称:");
                String name = scanner.next();
                boolean flag = false;
                for (int i = 0; i < nameArray.length; i++) {
                    if (nameArray[i] != null && nameArray[i].equals(name)) {
                        System.out.println(name + "已存在");
                        flag = true;
                        break;
                    }
                }
                if (!flag) {
                    System.out.println("请输入用户年龄：");
                    int age = scanner.nextInt();
                    nameArray[nameArray.length - 1] = name;
                    stateArray[stateArray.length - 1] = "正常";
                    ageArray[ageArray.length - 1] = age;
                    System.out.println(name + "添加成功");
                }
                System.out.println("输入0返回：");
                num = scanner.nextInt();
                break;
            case 3:
                System.out.println("---------删除用户----------");
                System.out.println("请输入用户名称：");
                name = scanner.next();
                boolean flag2 = false;
                for (int i = 0; i < nameArray.length; i++) {
                    if (nameArray[i] != null && nameArray[i].equals(name)) {
                        flag2 = true;
                        if (i == nameArray.length - 1) {
                            nameArray[i] = null;
                            stateArray[i] = null;
                        } else {
                            for (int j = i; j < nameArray.length - 1; j++) {
                                nameArray[j] = nameArray[j + 1];
                                stateArray[j] = stateArray[j + 1];
                                nameArray[j + 1] = null;
                                stateArray[j + 1] = null;
                            }
                        }
                    }
                }
                if (!flag2) {
                    System.out.println(name + "不存在，请重新输入：");
                } else {
                    System.out.println(name + "删除成功");
                }
                System.out.println("输入0返回：");
                num = scanner.nextInt();
                break;
            case 4:
                System.out.println("------------账号冻结-----------");
                System.out.println("请输入用户名称:");
                name = scanner.next();
                boolean flag3 = false;
                for (int i = 0; i < nameArray.length; i++) {
                    if (nameArray[i] != null && nameArray[i].equals(name)) {
                        flag3 = true;
                        if (stateArray[i].equals("冻结")) {
                            System.out.println(name + "已冻结");
                        } else {
                            stateArray[i] = "冻结";
                            System.out.println(name + "冻结成功");
                        }
                        break;
                    }
                }
                if (!flag3) {
                    System.out.println(name + "不存在，请重新输入");
                }
                System.out.println("输入0返回：");
                num = scanner.nextInt();
                break;
            case 5:
                System.out.println("---------账号解封----------");
                System.out.println("请输入用户名称：");
                name = scanner.next();
                boolean flag4 = false;
                for (int i = 0; i < nameArray.length; i++) {
                    if (nameArray[i] != null && nameArray[i].equals(name)) {
                        flag4 = true;
                        if (stateArray[i].equals("正常")) {
                            System.out.println(name + "状态正常");
                        } else {
                            stateArray[i] = "正常";
                            System.out.println(name + "解封成功！");
                        }
                        break;
                    }
                }
                if (!flag4) {
                    System.out.println(name + "不存在,请重新输入!");
                }
                System.out.println("输入0返回:");
                num = scanner.nextInt();
                break;
            case 6:
                System.out.println("感谢使用用户管理系统！");
                return;
        }
    }while(num==0);
        
}