java基础笔记

413丶路西法

已于 2022-02-18 22:06:41 修改

阅读量446

点赞数

文章标签： java 开发语言后端

于 2021-11-22 23:01:56 首次发布

本文链接：https://blog.csdn.net/qq_53290615/article/details/121478488

版权

//---默认/缺省/友好/包（friendly）----没有关键字

异常处理的五个关键字：try，catch，finally，throw，throws

注释

1.//注释--仅用于描述，不影响代码. 快捷键Ctrl+/ ctrl+shuft+c

2. /*a
   * b
   * c多行注释
   */
3./**
   * 文档注释javadoc. 快捷键alt+shift+j
   *
   *
   */

标识符和关键字

包名、类名、变量名以及方法名都被称为标识符。注意：

1、以字母（包括中文等文字）、美元符$、下划线_、数字组成

2、数字不能开头

3、不能是关键字

PS：标识符是大小写敏感的。（见名识意）

命名规范

1、包名：习惯使用小写字母拼写。

2、文件名（类、接口、枚举）：首字母大写，若干单词组成则每个单词的首字母大写，如MyFirstJavaClass

3、成员名（方法、变量）：首字母小写，若干单词组成则之后每个单词的首字母大写，如getName

4、常量名：单词字母均大写，若干单词组成则使用下划线_连接单词，如HOUR_OF_DAY

关键字大全

修饰符不存在先后顺序

import

import引入：在当前文件中使用其他包下的文件时，除了Java.lang包
格式规则：import 全文件名；
全文件名=全包名.文件名

class

格式规则：class 类名{类体}

equals

equals和==的区别

continue

跳过本次循环之后的代码。continue的功能和break有点类似，区别是continue只是中止本次循环，接着开始下一次循环。而break则是完全中止循环。

break

中止结束所在的这一循环。break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统将完全结束循环，开始执行循环之后的代码。 break不仅可以结束其所在的循环，还可结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标识一个外层循环。Java中的标签就是一个紧跟着英文冒号（:）的标识符。且它必须放在循环语句之前才有作用。

return

结束方法，返回结果。return关键字并不是专门用于跳出循环的，return的功能是结束一个方法。一旦在循环体内执行到一个return语句，return语句将会结束该方法，循环自然也随之结束。与continue和break不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

static

表明具有静态属性

1. 静态方法，通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法

2，静态变量，声明为static的变量实质上就是全局变量。

this

当前对象的引用，用来访问当前对象中的成员
ps：this代指=调用this所在的方法的对象

final

访问修饰符--访问控制权限（4个）

public---公有的

作用：对所有类可见，可以在当前当前工程的任意文件进行访问使用
主要使用位置：类（文件）成员（变量、方法）、接口
public修饰的外部类必须与文件同名，且该文件中仅有一个public修饰的外部类

private---私有的

作用：在当前类（文件）内可见即可在当前类体中访问使用
主要使用位置：成员（方法+变量）
ps:不能修饰外部类

protected---保护的

作用：对同包内的所有子类可见
主要使用位置：成员（变量+方法）
ps：不能修饰外部类

//---默认/缺省/友好/包（friendly）----没有关键字

作用：在同一包内可见，不使用任何修饰符
主要使用对象：类、接口、成员（变量+方法）

修饰符访问高低排序：public > protected > 不写 > private

ps：接口里的变量都隐式声明为public static final，而接口里的方法默认情况下访问权限为public

数据类型

格式：变量名=值；（可以用逗号隔开来声明多个同类型变量）

java是强类型语言，要求变量的使用严格符合规定，所有变量必须先定义后使用(可以是基本类型，也可以是引用类型)

布尔类型：布尔类型只有两个值，true或者false。
boolean 1字节或者4个字节
如果使用boolean声明一个基本类型的变量时，那么该变量占4个字节，
如果使用boolean声明一个数组类型的时候，那么每个数组的元素占一个字节

类型转换

小数的优先级大于整数

大转小强制转换，小转大自动转换（这里的大小指的是二进制位数）

强制转换-----》（类型）变量名高变低

自动转换------》低变高

1、不能对布尔值进行转换

2、不能把对象类型转换成不相干的类型

3、高容量转到低容量时，强制转换

4、转换的时候可能存在内存溢出，或者精度问题（操作比较大的数注意溢出问题，数字间可用下划线分割）

溢出问题解决方法------》先把能够保存的数值范围少的类型转换为多的类型，再进行运算。PS(数值保存范围小的类型与数值保存范围大的数据类型进行数学计算时，得到的结果是数值保存范围大的数据类型)

精度丢失问题及解决方法------》

如果两个操作数中有一个是double类型的，另外一个自动转换为double类型。
如果其中一个操作数是float类型的，另外一个操作数也将自动转换为float类型。
如果其中一个操作数是long类型的，另外一个操作数也将自动转换为long类型。
否则，两个操作数都会被转换为int类型。

方法

方法=c语言的函数

格式：

修饰符返回值类型方法名（参数类型参数名）{

方法体

return 返回值；（存在返回值时）

}

修饰符：可选，定义该方法的访问类型，修饰符不存在先后顺序

返回值类型：没有返回值用viod，代表空

方法名：方法的实际名称，遵循驼峰原则

参数类型：可选，参数像是一个占位符，当方法被调用时，传递值给参数。（形参：在方法调用时用于接收外界输入的数据 / 实参：调用方法时实际传给方法的数据）

方法体：具体的语句，定义该方法的功能

如：System.out.println();---System系统类、 out标准输出对象、 println()方法

方法调用

格式：对象名.方法名（实参列表）

1、当方法返回一个值的时候，方法调用通常被当做一个值

2、当方法返回值是void时,方法调用一定是一条语句

方法重载

重载就是在一个类中，有相同的函数名称，但是形参不同的函数

规则：

1、方法名称必须相同

2、参数列表必须不同（个数、类型、参数排列顺序）

3、方法返回类型可以相同也可以不同

4、仅仅返回类型不同不是方法重载

递归

方法调用：A方法调用B方法，如main方法里调用add方法

递归：A方法调用A方法，就是自己调用自己

结构、

1、递归头：什么时候不调用自身方法。如果没有头将陷入死循环

2、递归尾：什么时候需要调用自身方法

图示：

类和对象

类：是一个模板，是一个类别，类之中定义的是这一类对象具有的属性和行为（方法）；如一条狗是一个对象，状态有颜色、名字、品种，行为有摇尾巴、叫

对象：是类的一个实例（现实中的一个具体例子），有状态和行为。；如一条狗是一个对象，状态有颜色、名字、品种，行为有摇尾巴、叫

一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。如：月饼的模具与月饼的关系

认识论角度（运行上）考虑：先有对象后有类

代码运行角度（编码上）考虑：先有类后有对象

数组

数组是相同类型数据的有序集合

数组声明创建

1、数组必须声明数组变量，才能在程序中使用，如 int[] array;

2、java语言使用new操作符来创建数组，如int[] array=new array[]；

3、数组的元素通过索引来访问，数组索引号从0开始

4、获取数组长度：arrays.length

补充：内存分析

数组三种初始化

1、静态初始化：创建+赋值

int[] a={1,2,3,4,5,6}；//基本数据类型

Man[] man={new Man（）,new Man()}; //引用类型

2、动态初始化：包含默认初始化

int[] b=new int[10];

b[0]=10;

3、默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

整型：0

浮点型：0.0

char型：0或'\u0000' (而非'0')

boolean型：false

运用数据类型：null

数组的四个基本特点

1、长度确定，创建后大小不可改变

2、数组元素必须是相同类型，不允许混合类型

3、数组的元素可以是任意数据类型，包括基本类型和引用类型

4、数组变量属于引用类型，数组也可以看作是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的（new出来的都在堆中），因此数组无论保存原始类型还是其他对象类型，数组对象本身就是在堆中的

数组遍历

1、for循环

for(int a=0;a<=aarray.length;a++){

system.out.println(array[a]);

}

2、增强型for循环

for(int a:array) //没有下标，一般用于打印结果

system.out.println(a);

}

Arrays类

1-数组的工具类java.util.Arrays

2-Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，二不用使用对象进行调用（也能使用对象）

3-常用功能：

*打印数组：Arrays.toString(a)

int[] a= {1,3,5,6,34,775,2};
System.out.println(Arrays.toString(a));//打印数组

*数组排列： Arrays.parallelSort(a)

Arrays.parallelSort(a);//数组排序
System.out.println(Arrays.toString(a));

*数组赋值：Arrays.fill(a, 3)

Arrays.fill(a, 3);
System.out.println(Arrays.toString(a));

*比较数组:Arrays.equals(a,a2)

int[] a2= {3,3,3,3,3,3,3};
System.out.println(Arrays.equals(a, a2));

冒泡排序

外层循环：判断要比对多少次

内层循环：比对两个数，不符合条件交换位置

最后遍历

代码块（代码片段、代码域、匿名方法）

实例代码块：每次实例化对象时在调用结构方法前自动执行一次
静态代码块：仅在该类被第一次使用时自动执行一次

异常(Exception)

三种异常类型：
1-检查性异常：最具代表性的检查性异常时用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件。这种异常在编译时不能被简单的忽略
2-运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略
3-错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中常常被忽略。例如，当栈溢出时，一个错误就发生了，他们在编译也检查不到

java把异常当做对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的超类

Throwable又分为Error和Exception
Error：Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
Exception:Exception分支中有一个重要的子类RuntimeException（运行时错误），如：
ArrayIndexOfOutBoundException （数组下标越界）
NullPointerException （空指针异常）
ArithmeticException （算数异常）
ClassNotFoundException （找不到类）等异常，这些异常是不检查异常，程序中可以选择性的捕获处理，也可以不处理

异常处理机制

编译时异常：必须进行异常处理
运行时异常：可以进行异常处理，也可以不处理

异常处理主要有捕获异常和抛出异常

异常处理的五个关键字：try，catch，finally，throw，throws

捕获异常

try

监控区域（异常处理的范围，捕获异常的范围）

catch

捕获异常，可以使用多个catch捕获多个异常
格式：catch（想要捕获的异常类型）｛｝

finally

异常处理中的最后的代码，处理善后工作

ps：

1-try范围内的代码一旦发生异常，范围内之后的代码不在执行
2-catch可以没有，也可以有多个（处理运行时异常是可以不写）
3-如果try中存在编译异常，那么在catch中必须对该编译异常进行处理
4-存在多个catch时，异常类型必须子类在前父类在后
5-finally无论try范围内是否发生异常，该finally内代码都会执行

异常抛出

throw

throw是语句抛出一个异常。
语法：throw (异常对象);
throw e;
ps：

如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出即需要加上 throws 语句或者在方法体内 try catch 处理该异常，否则编译报错
执行到 throw 语句则后面的语句块不再执行

throws

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
public void doA(int a) throws Exception1,Exception3{......}

方法的定义上使用 throws 表示这个方法可能抛出某种异常
需要由方法的调用者进行异常处理

throw和throws的区别

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。

throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。

throws说明你有那个可能，倾向。
throw的话，那就是你把那个倾向变成真实的了。

自定义异常

用户可以自定义异常，自定义异常类只需继承Exception类即可

步骤：
1-创建自定义异常类
2-在方法中通过throw关键字抛出异常
3-如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获进行处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
4-在方法异常的调用者中进行捕获并处理异常

异常在实际应用中的总结经验

1-处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
2-在多重catch块后面，可以加上一个catch（Exception）来处理可能被遗漏的异常
3-对于不确定的代码，切记只是简单地调用printStackTrace（）去打印输出
4-具体如何处理异常，要根据不同的业务需求和异常类型去决定
5-尽量添加finally语句去释放占用的资源

单元测试

添加Junit

1-在我们所要进行测试的项目上右击，选择Build Path:
2-之后选择最后一项Configure Build Path
3-我们点击上方的LIbraries，选择Add Libraries:
4-在随后出现的这个对话框中选择JUnit，点击Next:
5-在此对话框中选择JUnit的版本，建议选择高版本的JUnit5，点击Finish，返回到最开始的Build Path对话框，点击OK，之后在我们的项目中进行测试：