java自学笔记

贰y.

已于 2023-04-09 23:07:01 修改

阅读量67

点赞数

文章标签： java idea

于 2023-02-24 14:53:14 首次发布

本文链接：https://blog.csdn.net/m0_64992875/article/details/129200578

版权

java

注释

//单行注释：对下面的代码进行解释说明。

/*多行注释：不可以嵌套使用
对整个程序或者方法进行解释说明。
*/
单行和多行注释可以调试代码

文档注释：注释的内容可以被jdk提供的工具解析，形成以网页的形式体现文档说明。
/**
@author  代码作者
@version  源文件版本
*/

基本语法

1.1 标识符

凡是自己可以起名字的，都叫标识符。
规则：1、可以包含数字，但数字不可以开头；2、不能使用关键字和保留字，但可以包含关键字和保留字；3、严格区分大小写；4、不能包含空格

1.2 Java命名规范

包名：多单词组成，所有字母都小写
类名、接口名：多单词组成时，所有单词的首字母大写
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写
常量名：所有字母都大写，多单词时每个单词用下下划线连接

2 变量

2.1变量分类-按数据类型

数据类型分为基本数据类型和引用数据类型
基本数据类型分为数值型、字符型（char）、布尔型（boolean）
数值型分为整数型（byte、short、int、long）、浮点型（float、double）
引用数据类型分为类（class）、接口（interface）、数组（[]）

2.2基本数据类型

注意：long要以“l"或者"L"结尾
整数型：byte（1字节=8bit）、short（2字节）、int（4字节）、long（8字节）

声明单精度时，结尾要加"f"or"F"，单精度小数点后七位，双精度是单精度的两倍
浮点型：单精度float（4字节）、双精度（8字节）

字符型表现形式：1、声明一个字符，2、转义字符，3、直接使用Unicode值来表示字符型常量
字符类型：char（1字符=2字节）

只能取true或者false两者之一
布尔型：boolean

2.3基本数据类型之间的运算规则

2.3.1自动类型提升

byte、char、short->int->long->float->double
特别：当byte、char、short三种类型做运算时，结果为int

2.3.2强制类型转换

自动类型提升的逆运算（将容量大的转换为容量小的）
1、需要使用强转符"()"；2、强制类型转换可能会导致精度缺失

2.4 String类型

1、String属于引用数据类型，翻译为：字符串
2、声明String类型时用"“来表示
3、String可以和8中基本数据类型做运算，且运算只能时连接运算用”+"来连接，运行的结果仍然为String类型

2.5 运算符

2.5.1算术运算符

++：自增，前：先运算后取值；后：先取值后运算（不改变本身变量的数据类型）
%：取模（取余）结果符号与被取模数的符号相同

2.5.2 赋值运算符

符号：“=、+=、-=、%=…”，支持连续赋值，不会改变变量本身的数据类型

2.5.3比较运算符

符号：“、!=、<、>、…“，注意：”“不能写成”=”，结果都是boolean类型
特殊："instanceof"检查是否是类的对象

2.5.4逻辑运算符

&-逻辑与；|-逻辑或；！-逻辑非；&&短路与；||-短路或；^-短路异或
与：同真为真，其他为假；或：同假为假，其他为真；非：取反；异或：相同为假，相异为真
短路与不满足左边为true的，后面的不看直接跳过；短路或左边不满足为false的，后面不看直接跳过
开发中推荐使用短路
只适用于布尔类型的变量

2.5.5位运算符

符号：“<<(左移)、>>(右移)、>>>(无符号右移)、&与运算、|或运算、^异或运算、~取反运算”
位运算是直接对整数的二进制进行的运算，左移*2、右移/2

2.5.6三元运算符

格式：(条件表达式)?表达式1：表达式2;
条件表达式为true，运算后的结果为表达式1；条件表达式为false，运算后的结果为表达式2
表达式1和表达式2为同种类型
三元运算符与if-else的联系与区别：
1.三元运算符可简化为if-else语句
2.三元运算符要求必须返回一个结果
3.if后的代码块可有多个语句
4.三元运算符可以嵌套使用

2.6 程序流程控制

2.6.1 分支结构

2.6.1.1 if-else(条件判断结构)

if(){
}else if(){
}else{}

说明：
1、条件表达式必须是布尔表达式、布尔变量
2、语句块只有一条执行语句时，一对{}可以省略，但建议保留
3、if-else语句结构可以嵌套使用
4、当if-else结构是"多选一"时，最后的else是可选的，根据需要可以省略
5、当多个条件是"互斥"关系时，条件判断语句及执行语句间顺序无所谓；当多个条件是"包含"关系时，“小上大下/子上父下”

2.6.1.2 switch-case结构

switch(表达式){
        case:
        执行语句;
        break;
    default:
        执行语句;
        break;
}

说明：1、根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相对应case结构中，调用其执行语句。当调用完执行语句以后，仍然继续向下执行其他case结构中的执行语句，直到遇到break关键词或此switch-case结构末尾结束为止。
2、break可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
3、switch结构中的表达式，只能是一下6种数据类型之一：byte、short、char、int、枚举类型、string类型。
4、case之后只能声明常量，不能声明范围。
5、break可以选。
6、default相当于if-else的else，也是可选并且位置是灵活的。

2.6.2循环结构

循环语句四个组成部分：①初始化部分、②循环条件部分(boolean类型)、③循环体部分、④迭代部分

2.6.2.1 for循环结构

for(①；②；④){
	③
}

break：直接跳出循环执行过程：①->②->③->④->②->③->④

2.6.2.2 while循环结构

①
while(②){
③
④
}

提醒：1、写while循环小心不要丢了迭代条件，丢了迭代条件将是一个死循环。
2、for循环和while循环可以相互转换。区别：for循环和while循环的初始条件部分的作用范围不一样。
3、先判断后执行

2.6.2.3 do-while循环结构

①
do{
③
④
}while(②)

执行过程：①->③->④->②->③->④->②
声明：1、do-while循环至少会执行一次循环体。
2、开发中常使用for和while循环。
3、先执行后判断

2.6.2.4 循环总结

1、不在循环条件部分限制次数的结构：for( ; ; )或while(true)
2、结束循环的方式
方式一：循环条件部分返回false；
方式二：在循环体中，执行break。

2.6.2.5 嵌套循环的使用

1、嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
2、外层循环：循环结构B
内层循环：循环结构A
3、说明：①、内层循环结构遍历一次，只相当于外层循环循环体执行了一次
②、假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m*n次。
4、外层控制行数，内层控制列数

2.6.3 break和continue关键字的使用

break：使用范围：switch-case、循环结构中；作用：结束当前循环
continue：适用范围：循环结构中；作用：结束当次循环
相同点：关键词后面不能声明执行语句
特别：return，用在方法中，结束当前方法。

3 数组

3.1数组概述

1、数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2、数组特点：1)数组是有序排序的。
2)数组属于引用数据类型的变量。数组的元素，可以是基本数据类型，也可以是引用数据类型。
3)数组的相关概念：数组名；元素；角标、下标、索引；数组的长度：元素的个数
4)数组的长度一旦确定，就不能改变。
5)创建数组对象会在内存中开辟一整块连续的空间。

3.2数组初始化的方法

3.2.1 静态初始化

数组的初始化和数组元素的赋值操作同时进行。

//一维数组
int[] ids = new int[]{100,101,102};
//二维数组
int[][] ids = new int[][]{{1,2,3},{4,5},{6,7,8}};

3.2.2 动态初始化

数组的初始化和数组元素的赋值操作分开进行。

//一维数组
String[] names = new String[数字];
//二维数组
String[][] arr = new String[数字][数字];
String[][] arr2 = new String[数字][];

3.3 数字长度的获取和数组的遍历

长度获取方法：length方法

names.length

数组遍历：for

//一维数组
for(int i = 0;i<names.length;i++){
    System.out.println(names[i]);
}
//二维数组
for(int i = 0;i<arr.length;i++){
    for j = 0;j<arr[i].length;j++{
        System.out.print(arr[i][j]+"  ");
    }
    System.out.println();
}

3.4数组元素的初始化值

一维数组：整型：0
浮点型：0.0
char型：0或’\u0000’，而非’0’
boolean型：false
引用数据类型：null

二维数组：规定：二维数组分为外层数组的元素，内层数组的元素
外层元素：arr[0],arr[1]
内层元素：arr[0][0],arr[1][2]
①针对于初始化为int[] [] arr = new int [4] [3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况一样
②针对于初始化为int[] [] arr = new int [4] [];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错

3.5 数组中涉及到的常见算法

3.5.1、数组元素的赋值(杨辉三角、回形数)

3.5.2、求数值型数值中元素的最大值、最小值、平均数、总和

3.5.3、数组的复制、反转、查找(线性查找、二分法查找)

①数组的复制需要用到for循环；否则arr2=arr1，arr2得到的是地址值，arr2里的值改变，arr1跟着改变。
②数组的反转

//方法一
for(int i =0;i < arr.length / 2;i++){
    String temp = arr[i];
    arr[i] = arr[arr.length - i -1];
    arr[arr.length - i - 1] = temp;
}
//方法二
for(int i = 0,j = arr.length - 1;i < j;i++,j--){
    String temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

③数组的查找(搜索)：
线性查找：

String dest = "要查找的内容";
//判断
boolean isFlag = true;
for(int i = 0;i < arr.length;i++){
    if(dest.equals(arr[i])){
        System.out.println("找到了,元素位置为：" + i);
        isFlag = false;
        break;
    }
}
if(isFlag){
    System.out.println("没有找到");
}

二分法查找(折半查找)：前提必须是查找的数组必须有序

int[] arr = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest = -34;
int head = 0;//初始首索引
int end = arr.length - 1;//初始末索引
boolean isFlag = true;
while(head <= end){
    int middle = (head + end)/2;
    if(dest == arr[middle]){
        System.out.println("找到指定的元素，位置为："+middle);
        isFlag = false;
        break;
    }else if(arr[middle] > dest){
        end = middle - 1;
    }else{
        head = middle + 1;
    }
}
if(isFlag){
    System.out.println("没有找到");
}

3.5.4、数组元素的排序算法

衡量排序算法的优劣：
1、时间复杂度：分析关键字的比较次数和记录的移动次数
2、空间复杂度：分析排序算法中需要多少辅助内存
3、稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。

3.5.4.1 冒泡排序

基本思想：通过对待排序序列从前向后，依次比较相邻元素的排序码，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部。

for(int i = 0;i < arr.length - 1;i++){
    for(int j = 0;j < arr.length - 1 -i;j++){
        if(arr[j] > arr[j+1]){
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}

3.6 Arrays工具类的使用

java.util.Ayyays包
boolean equals(int[] a,int[] b)：//判断两个数组是否相等
String toString(int[] a)：//输出数组信息
void fill(int[] a,int val)：//将指定值填充数组
int binarySearch(int[] a,int key)：//对排序后的数组进行二分法索引指定的值
void sort(int[] a)：//对数组进行排序

面向对象

面向对象的三大特征：封装、多态、继承

4.1 类和对象(两个要素)

类：是对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也成为实例。“万物皆对象”
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员;属性=成员变量，方法=成员方法=函数

4.1.1 类和对象的使用

1、创建类，设计类的成员
2、创建类的对象
3、通过"对象.属性"或"对象.方法"调用对象的结构

4.1.2 类中属性的使用

属性(成员变量) vs 局部变量
1、相同点：
1)定义变量的格式：数据类型变量名 = 变量值
2)先声明后使用
3)变量都有其对应的作用域
2、不同点：
1)属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2)关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected
局部变量：不可以使用权限修饰符
3)默认初始化值的情况
属性：类的属性，根据其类型，都有默认初始化值。
局部变量：没有默认初始化值，在调用前要显示赋值。形参在调用时，赋值即可。
4)在内存中加载的位置
属性：加载到堆空间(非static)；局部变量：加载到栈空间

4.1.3 类中方法的声明和使用

1、方法的声明：权限修饰符返回值类型方法名(形参列表){方法体}
2、返回值类型：有返回值 vs 没有返回值
如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
return关键字来返回指定类型的变量或常量：“return 数据”。
如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
使用return。但是，如果使用的话，只能“return;”表示结束此方法的意思。
3、方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
4、return关键字的使用
1.使用范围：使用在方法体中
2.作用：① 结束方法
② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
3.注意点：return关键字后面不可以声明执行语句。
5、方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A:递归方法。方法中，不可以定义方法。

4.2 方法

4.2.1 方法的重载

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
重载的特点：与返回值无关，只看参数列表，且参数列表必须不同。调用时，根据方法参数列表的不同来区别。
“两同一不同”：同一个类、相同方法名，参数列表不同：参数个数不同，参数类型不同

4.2.2 可变个数形参的方法

1 可变个数形参的格式：数据类型 … 变量名
2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个,…
3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
5 可变个数形参在方法的形参中，必须声明在末尾
6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

4.2.3 方法参数的值传递机制

1、形参：方法定义时，声明的小括号内的参数；
实参：方法调用时，实际传递给形参的数据
2、值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实储存的数据值
如果参数是引用数据类型，此时实参赋给形参的是实参储存数据

4.2.4 方法递归的分类

分类：分为直接递归、间接递归

5 面向对象的特征

5.1 封装性

定义：所谓封装，就是把客观事物封装成抽象概念的类，并且类可以把自己的数据和方法只向可信的类或者对象开放，向没必要开放的类或者对象隐藏信息。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

5.1.1 权限修饰符

权限修饰符：public、protected、缺省、private

修饰符	本类内部	本包内	其他包的子类	其他包非子类
private	√	×	×	×
缺省	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

具体修饰的结构：

外部类：public、缺省
成员变量、成员方法、构造器、成员内部类：public、protected、缺省、private

5.1.2 成员变量封装的好处：

让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
便于修改，提高代码的可维护性。主要说的是隐藏的部分，在内部修改了，如果其对外可以的访问方式不变的话，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，我们使用者根本感觉不到它内部的修改。

5.2 构造器(Constructor)

5.2.1 构造器的作用

new对象，并在new对象的时候为实例变量赋值。

举例：Person p = new Person(“Peter”,15);

解释：如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

5.2.2 语法

[修饰符] class 类名{
    [修饰符] 构造器名(){
    	// 实例初始化代码
    }
    [修饰符] 构造器名(参数列表){
        // 实例初始化代码
    }
}

注意：

构造器名必须与它所在的类名必须相同。
它没有返回值，所以不需要返回值类型，也不需要void。
构造器的修饰符只能是权限修饰符，不能被其他任何修饰。比如，不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值。
当我们没有显式的声明类中的构造器时，系统会默认提供一个无参的构造器并且该构造器的修饰符默认与类的修饰符相同
当我们显式的定义类的构造器以后，系统就不再提供默认的无参的构造器了。
在类中，至少会存在一个构造器。
构造器是可以重载的。

5.3 JavaBean

JavaBean是一种Java语言写成的可重用组件。
- 好比你做了一个扳手，这个扳手会在很多地方被拿去用。这个扳手也提供多种功能(你可以拿这个扳手扳、锤、撬等等)，而这个扳手就是一个组件。
所谓JavaBean，是指符合如下标准的Java类：
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

public class JavaBean {
    private String name; // 属性一般定义为private
    private int age;
    public JavaBean() {
    }
    public int getAge() {
        return age;
    }
    public void setAge(int a) {
        age = a;
    }
    public String getName() {
        return name;
    }
    public void setName(String n) {
        name = n;
    }
}

5.4 UML类图

UML（Unified Modeling Language，统一建模语言），用来描述软件模型和架构的图形化语言。
常用的UML工具软件有PowerDesinger、Rose和Enterprise Architect。
UML工具软件不仅可以绘制软件开发中所需的各种图表，还可以生成对应的源代码。
在软件开发中，使用UML类图可以更加直观地描述类内部结构（类的属性和操作）以及类之间的关系（如关联、依赖、聚合等）。
- +表示 public 类型， - 表示 private 类型，#表示protected类型
- 方法的写法:
  方法的类型(+、-) 方法名(参数名：参数类型)：返回值类型
- 斜体表示抽象方法或类。