【笔记】Java学习笔记

发表于 更新于 分类于 阅读次数：

前言

Java学习笔记

变量

  • 存数的

变量的声明

  • 声明一个整形的变量，名为a
1
int a;
  • 声明三个整形的变量，名为b c d
1
int b,c,d;

变量的初始化

第一次赋值

  • 声明整形变量a并赋值为250
1
int a = 250;

变量的使用

对变量的操作就是对它所存的那个数的操作

1
2
3
4
int a = 5;
int b = a+10;
System.out.println(b);
System.out.println("b");

变量的操作必须与数据类型匹配

  • 编译错误，数据类型不匹配
1
int a = 3.14;

变量在用之前必须声明并初始化

  • 编译错误，m未声明
1
System.out.println(m);
  • 编译错误，m未初始化
1
2
int m;
System.out.println(m);

变量的命名

只能包含字母、数字、_、$，并且不能以数字开头
严格区分大小写
不能使用关键字
可以中文命名，但不建议

建议英文的见名知意、驼峰命名法

基本数据类型

int

  • 整型，4个字节，只能装整数，-21个多亿到21个多亿

整数直接量默认为int类型，但不能超范围，超范围则编译错误
两个整数相除，结果还是整数，小数位无条件舍弃（不会四舍五入）
整数运算时若超出范围，则发生溢出（溢出不是错误，但是是需要避免的）

long

  • 长整形，8个字节，只能装整数，很大很大

长整形直接量需在数字后加L或l
运算时若有可能溢出，建议在第一个数字后加L
System.currentTimeMillis()用于获取自1970年1月1日零时到此时此刻的毫秒数

double

  • 浮点型，8个字节，只能装小数，很大很大

浮点数直接量默认为double型，表示float需在数字后加F或f
double和float型数据参与运算时，有可能出现舍入误差

boolean

  • 布尔型，1个字节，只能装true和false

只能取值为true和false

char

  • 字符型，2个字节

采用Unicode字符集编码，每个字符对应一个码，表现的形式是字符char，本质上是码int（0～65535）
字符型直接量需放在单引号中，只能有一个
特殊符号需要通过\来转义

基本数据类型间的转换

  • 数据类型从小到大依次为

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

两种方式

  • 自动类型转换

    小类型到大类型

  • 强制类型转换

    大类型到小类型

两点规则

整数直接量可以赋值给byte short char，但不能超出范围
byte short char型数据参与运算时，先一律转换为int再运算

Scanner 的用法

  • 在package下
1
import java.util.Scanner;
  • 在main中
1
Scanner sc = new Scanner(System.in);
  • 在第2步之后
1
2
3
4
Scanner.out.println("请输入年龄：");
int age = sc.nextInt();
Scanner.out.println("请输入价格：");
double price = dsc.nextDouble;

运算符

算术运算符

  • + - * / % ++ --

关系运算符

  • > < >= <= == !=

逻辑运算符

  • && || ! boolean

赋值运算符

  • = += -= *= /= %=

字符串连接运算符

  • +

三目/条件 运算符

  • boolean?num1:num2

分支

  • 有条件的执行某语句，并非每句必走

if结构

  • 1条路

if…else结构

  • 2条路

if…else if结构

  • 多条路

switch…case结构

  • 多条路

优点：效率高、结构清晰
缺点：整数、相等
break：跳出switch

循环

  • 反复执行一段相同或相似的代码

循环三要素

循环变量的初始化
循环的条件（以循环变量为基础）
循环变量的改变（向着循环的结束变）

循环结构

while结构

  • 先判断后执行

do…while结构

  • 先执行后判断，至少执行一次

for结构

  • 应用率最高，固定次数循环

跳出循环

break跳出循环
continue跳出循环体中剩余语句而进入下一次循环

三种循环的更佳使用情况

while：当…
do...while：直到…
for：固定次数循环

嵌套循环

循环中套循环，一般多行多列时使用，外层控制行，内层控制列
执行过程：外层循环走一次，内层循环走所有次
建议：循环层次越少越好，能用一层就不用两层，能用两层就不用三层
break只能跳出一层循环

程序

  • 程序 = 算法 + 数据结构

算法：解决问题的流程/步骤（顺序、分支、循环）
数据结构：将数据按照某种特定的结构来保存，设计良好的/合理的数据结构会导致好的算法

数组

是一种数据类型（引用类型）
相同数据类型元素的集合

数组的定义

1
int[] arr = new int[10];

数组的初始化

1
2
3
4
5
6
int[] arr = new int[4];
int[] arr = {1, 4, 5, 8};
int[] arr = new int[]{1, 4, 5, 8};
int[] arr
arr = {1, 4, 5, 8};//编译错误
arr = new int[]{1, 4, 5, 8};//正确

数组的访问

  • 通过（数组名.length）可以获取数组的长度（元素的个数）
1
2
int[] arr = new int[4];
System.out.println(arr.length);
  • 通过下标/索引来访问数组中的元素

下标从0开始，最大到(数组长度-1)

1
2
3
4
5
6
int[] arr = new int[3];
arr[0] = 100;//给第1个元素赋值为100
arr[1] = 200;//给第1个元素赋值为200
arr[2] = 300;//给第1个元素赋值为300
arr[3] = 400;//数组下标越界异常
System.out.println(arr[arr.length-1]);//输出最后一个元素的值

数组的遍历

1
2
3
4
5
6
7
8
9
10
int[] arr = new int[10];
for(int i = 0; i < arr.length; i++){
    arr[i] = (int)(Math.random()*100);
}
for(int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}
for(int i = arr.length; i >= 0; i--){
    System.out.println(arr[i]);
}

数组的复制

1
2
3
System.out.println(a, 1, a1, 0, 4);
int[] a1 = Arrays.copyOf(a, 6);
a = Arrays.copyOf(a, a.length+1);//扩容

数组的排序

1
Arrays.sort(arr);//升序
  • 冒泡排序

5个数冒4轮
每一轮都是葱花第1个元素开始冒，每一次都是和它的下一个元素比
冒出来的就不再参与比较了

方法

  • 函数、过程

封装一段特定的业务逻辑功能
方法尽可能独立，只干一件事
方法可以被反复调用多次
减少代码重复，有利于代码维护，有利于团队协作

方法的定义

1
2
3
修饰词 返回值类型 方法名(参数类型 参数名){
    方法体
}

可变参数

1
2
3
修饰词 返回值类型 方法名(参数类型... 参数名){
    方法体
}

方法的调用

  • 无返回值：
1
方法名(有参传参);
  • 有返回值：
1
数据类型 变量 = 方法名(有参传参);

return

  • 有返回值的方法中
1
return 值;

结束方法的执行
返回结果给调用方

  • 无返回值的方法中
1
return;

结束方法的执行

完成