Java基础笔记

最新推荐文章于 2023-12-30 22:08:53 发布

置顶 hmwck

最新推荐文章于 2023-12-30 22:08:53 发布

阅读量154

点赞数

分类专栏： java 文章标签：方便理解和学习Java基础

本文链接：https://blog.csdn.net/hmwck0215/article/details/84037959

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

快速学习Java语言基础笔记

本篇笔记介绍基本很全面,也希望大家在评论区回复我所缺少的
这篇笔记介绍了标识符运算符与表达式流程控制语句(选择控制语句和循环控制语句) 以及数组(一维和多维数组,以及冒泡和选择排序) 等

*(一)标识符

(变量)与数据类型**

Java所有的组成部分都需要名字，如类名、变量名以及方法名，所有这些名称所使用的字符串序列即被称为标识符。
JAVA规定标识符必须由以下部分组成:
 任意顺序字母;
 下划线”-“.
 美元符号” $KaTeX parse error: Unexpected character: '' at position 3: ” ̲ 数字关于JAVA标识符，有\dots$ ）、或者下划线（_）开始;
 标识符是严格区分大小写的;如:good和Good是不同的标识符;
 标识符不能是Java中保留关键字;

标识符写法
 包名所有字母小写
 类名每个单词首字母大写，其它小写，如：TarenaStudent
 变量和方法：第一个单词小写，从第二个单词开始首字母大写，如：tarenaStudent
 变量通常为名词或名词性短语，方法名通常为动词或动宾短语
 常量：所有字母大写，每个单词之间用 _ 连接
JAVA的关键字
关键字含义

abstract 表明类或者成员方法具有抽象属性
assert 用来进行程序调试
boolean 基本数据类型之一，布尔类型
break 提前跳出一个块
byte 基本数据类型之一，字节类型
case 用在switch语句之中，表是其中的一个分支
catch 用在异常处理中，用来捕捉异常
char 基本数据类型之一，字符类型
class 类
const 保留关键字，没有具体含义
continue 回到一个块的开始处
default 默认，例如，用在switch语句中，表明一个默认的分支
do 用在do-while循环结构中
double 基本数据类型之一，双精度浮点数类型
else 用在条件语句中，表明当条件不成立时的分支
enum 枚举
extends 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
finally 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float 基本数据类型之一，单精度浮点数类型
for 一种循环结构的引导词
goto 保留关键字，没有具体含义
if 条件语句的引导词
short 基本数据类型之一,短整数类型
static 表明具有静态属性
strictfp 用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super 表明当前对象的父类型的引用或者父类型的构造方法
switch 分支语句结构的引导词
synchronized 表明一段代码需要同步执行
this 指向当前实例对象的引用
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
transient 声明不用序列化的成员域
try 尝试一个可能抛出异常的程序块
void 声明当前成员方法没有返回值
volatile 表明两个或者多个变量必须同步地发生变化
while 用在循环结构中
implements 表明一个类实现了给定的接口
import 表明要访问指定的类或包
instanceof 用来测试一个对象是否是指定类型的实例对象
int 基本数据类型之一，整数类型
interface 接口
long 基本数据类型之一，长整数类型
native 用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new 用来创建新实例对象
package 包
private 一种访问控制方式：私用模式
protected 一种访问控制方式：保护模式
public 一种访问控制方式：共用模式
return 从成员方法中返回数据

注释(可以有效的增强代码的可读性与可维护性)
单行注释://开头到本行结束
多行注释以/开头,回车,以/结束.跨列多行
文档注释:以/*开以/结束

(二)运算符和表达式

运算符
运算符分类
1.赋值运算符
操作符描述例子
= 简单的赋值运算符，将右操作数的值赋给左侧操作数 C = A + B将把A + B得到的值赋给C

= 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 C + = A等价于C = C + A

= 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 C - = A等价于C = C -
A

= 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 C * = A等价于C = C * A
/ = 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 C / = A等价于C = C / A
（％）= 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 C％= A等价于C = C％A
<< = 左移位赋值运算符 C << = 2等价于C = C << 2

= 右移位赋值运算符 C >> = 2等价于C = C >> 2
＆= 按位与赋值运算符 C＆= 2等价于C = C＆2
^ = 按位异或赋值操作符 C ^ = 2等价于C = C ^ 2
| = 按位或赋值操作符 C | = 2等价于C = C | 2

2.算术运算符

操作符描述例子

加法 - 相加运算符两侧的值 A + B 等于 30

减法 - 左操作数减去右操作数 A – B 等于 -10

乘法 - 相乘操作符两侧的值 A * B等于200
/ 除法 - 左操作数除以右操作数 B / A等于2
％取余 - 左操作数除以右操作数的余数 B%A等于0
++ 自增: 操作数的值增加1 B++ 或 ++B 等于 21
– 自减: 操作数的值减少1 B-- 或 --B 等于 19

3.自增自减运算符
操作符描述
自增运算符为++ 自增: 操作数的值增加1
自减运算符为–，自减: 操作数的值减少1

4.关系运算符
运算符描述例子
== 检查如果两个操作数的值是否相等，如果相等则条件为真。（A == B）为假(非真)。
!= 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 (A != B) 为真。

检查左操作数的值是否大于右操作数的值，如果是那么条件为真。（A> B）非真。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。（A <B）为真。
= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。（A> = B）为假。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真（A <= B）为真。
运算符描述例子
== 检查如果两个操作数的值是否相等，如果相等则条件为真。（A == B）为假(非真)。
!= 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 (A != B) 为真。
检查左操作数的值是否大于右操作数的值，如果是那么条件为真。（A> B）非真。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。（A <B）为真。
= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。（A> = B）为假。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。（A <= B）为真。

5.逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假
操作符描述例子
&& 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。（A && B）为假。
| | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。（A | | B）为真。
！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。！（A && B）为真。

6.三元运算符
运算符语法
?: 布尔表达式?表达式1:表达式

运算符优先级
优先级描述运算符
1 括号 ()
2 正负号 + -
3 一元运算符 ++ – !
4 乘除 */
5 加减 + -
6 比较大小 >,<, >=, <=
7 比较是否相等 == .!=
8 按位与 &
9 按位或 |
10 逻辑与 &&
11 逻辑或 ||
12 三元运算 ?:
13 赋值运算 =, +=, -=, /=, *=

(三)流程控制语句

**
选择控制语句
if
IF条件句有三种形式
1.if条件语句：
if(条件1) {
代码块;
}
执行流程：先计算比较表达式的值，看其返回值是true还是false。如果是true，就执行语句体；如果是false，就不执行语句体；

2.If……else条件语句
if(条件1) {
代码块1;
}else{
代码块2;
}
执行流程：
首先计算比较表达式的值，看其返回值是true还是false。如果是true，就执行语句体1；如果是false，就执行语句体2；

3.嵌套if ……else 条件语句
if(条件1){
if(条件2){
代码块1;
}else {
代码块2;
}
}else{
代码块3;
}

(多重if条件语句)
if(条件1)
代码块1;
}else if(条件2) {
代码块2;
}else if(条件3) {
代码块3
}
else{
代码块n+1;
}
执行流程：
首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
如果都是false，就执行语句体n+1。

Switch
switch语句格式：
switch(表达式){
case 1:
代码块1;
break;
case 2:
代码块1;
break;
case 3:
代码块1;
break;

         ......
  default:
          代码块n+1;
         break;

执行流程：
1.计算表达式的值；
2.将得到的值依次与case后的值进行匹配，一旦匹配成功则执行相应的语句体，遇到break则结束；
3.若是都不匹配，则执行语句体n+1,遇到break则结束；
注意:

switch中case的参数类型只能是int byte，short，char, string(jdk1.7开始支持string) enmu(举)(jdk1.5支持)类型。
2.case可以多个,并且case后选择必须是直接值。
3.break是用来跳出整个switch语句的，如果没有，将执行下一分支。
default不一定写在最后,可以放在switch分支语句的任意位置
循环控制语句
循环语句是流程控制中最复杂，也是最有用、最难掌握的语句，在最初接触时，首先要熟悉基本的语法，然后需要能够快速观察出流程的规律，这个观察能力需要依靠大量的阅读和编写程序进行培养，这就是基本的逻辑思维，然后将该规律描述出来即可。所以在学习循环语句时，学习语法只是基本的内容，更多的是培养自己观察规律的能力
While
while关键字的中文意思是“当……的时候”，也就是当条件成立时循环执行对应的代码。while语句是循环语句中基本的结构
while语句语法格式：
while（循环条件）{
循环体；
}
执行流程：
在执行while语句时，首先判断循环条件，如果循环条件为false，则直接执行while语句后续的代码，如果循环条件为true，则执行循环体代码，然后再判断循环条件，一直到循环条件不成立为止。
例:
while（true）{
System.out.println（‘a’）；
}

do……while

解释：
在do-while语句中，循环体部分是重复执行的代码部分，循环条件指循环成立的条件，要求循环条件是boolean类型，值为true时循环执行，否则循环结束，最后整个语句以分号结束。
do{
循环体；
}while（循环条件）；
执行流程：当执行到do-while语句时，首先执行循环体，然后再判断循环条件，如果循环条件不成立，则循环结束，如果循环条件成立，则继续执行循环体，循环体执行完成以后再判断循环条件，依次类推。
例: int i = 1；
int result = 1；
do{
result *= i；
i++；
}while（i <= 5）；
System.out.println（result）

for
for关键字的意思是“当…的时候”，是实际开发中比较常用的循环语句
解释:
 和其它流程控制语句一样，语句中的大括号不是语法必须的，但是为了结构清楚以及在循环体部分可以书写多行代码，一般使用大括号。
 初始化语句作用是在循环开始以前执行，一般书写变量初始化的代码，例如循环变量的声明、赋值等。该语句可以为空。
 循环条件是循环成立的条件，要求必须为boolean类型，如果该条件为空，则默认为true，即条件成立。
 迭代语句是指循环变量变化的语句，一般书写i++、i—这样的结构，当然，该语句也可以为空5、循环体指循环重复执行的功能代码。

for（初始化语句；循环条件；迭代语句）{
循环体；
}
执行流程：

执行初始化语句
判断循环条件，如果循环条件为false，则结束循环，否则执行下一步
执行循环体
执行迭代语句
跳转到步骤2重复执行需要注意的是：for语句中的各个语句都可以为空，初始化语句在for语句执行时执行且只执行一次。

循环控制进阶及流程跳转语句
嵌套循环是把一个循环放入另一个循环中去,任何类型的循环之间都可以相互嵌套,比如
Do….while循环齐奥淘套for循环,for循环嵌套for循环,while循环嵌套for循环.
写个for循环乘法口诀
for(int i;i<=9;i++){//外层控制行数,也就是控制乘数
for(int j;j=1;j++){ 内层循环控制列,控制被乘数
system.out.print(j+””+i+”=”+jI+”\t”);//输出信息
}
//换行
Sytem.out.println();

跳转语句:
用于实现循环执行过程中程序流程跳转,在Java循环中提供两种跳转语句,分别是break语句和continue语句
Break:
循环体一旦遇到break,整个循环就就结束了
实例
public class xxx{
public static void main(String[] args) {
For(int i;i<10;I++){
If(I5){//结束所有循环(当i5时,整个循环结束)
Break;
}
Sytem.out.println(I+”,”);
}
}
}
Continue
再循环语句中,它的作用是终止本次循环,执行下一个循环体.
例:1~100之间奇数求和
public class xxx{
public static void main(String[] args) {
Int sun=0;
For(int i=1;i<=100;i++){
If(i%2==0){
Continue;//结束本次循环
}
Sum+=I;//实现sun和i的累加
}
System.out.printlin(“1~100奇数和为:”+sum);
}
}

(四)数组

一维数组

数组概述
数组是编程语言中最常见的数据结构,用来储存多个数据,是具有相同数据类型的一组数据集合.
组分为:一维数组和多维数组(多维数组又分为二维数组和三维数组等).简单来说,一维数组中存放的元素是基本数据类型,二维数组中存放的是一维数组.

语法:1
数组类型[ ] 数组名;
例:声明INT类型,元素都是INT类型
INT[ ] A

语法2:
数组元素类型数组名[ ];
L
例:声明DOUBLE类型,
DOUBLE[ ] B;

数组初始化

静态初始化:由程序员先指定数组元素的初始值,数组长度由元素决定
语法:
声明数组:
数组元素类型[] 数组名;
第二:静态初始化
数组名=new 数组元素类型[]{元素1,元素2,……}
例:
Int[] a;
a = new int[]{1,2,3,4,};
动态初始化: 由程序员先指定长度,根据数组的数据类型元素分配初始值
语法:
数组元素名 [] 数组名= new 数组元素类型[数组长度]
注意:动态和静态不能一起用,也就是说给数组长度的时候,不能给数组值
例:
声明数组和初始化数组放在一起
初始化数组长度5的double的一维数组,数组默认元素为0.0;
Double[] arr=new double[5]
Arr[0]=10.2;
Arr[0]=15.4
Arr[0]=20.5
Arr[0]=24.5
Arr[0]=30.4

数组的使用

数组长度:
通过length可以获取数组长度
语法: 数组名.length;
访问数组
通过数组下标,快捷访问数组中的元素
语法:数组名[下标]
例:
public class xxx{
public static void main(String[] args) {
Double[ ] d={10.1,10.2,10.3,10.4};
System.out printlin (d[0]); //访问数组d的第一个元素
注意:
访问数组是,下标不能超过下标范围,虽然编译不会报错,但是运行会异常
遍历数组
public class xxx{
public static void main(String[] args) {
Int [] a={1,2,3,4,5};
Int sun=0;//数组元素之和;
//遍历数组
System.out printlin (”数组元素”);
For (int i=0;i<a.length;i++){
System.out printlin (a[i]+”.”);
}
//换行
System.out printlin;
For (int i=0;i<a.length;i++){
Sum=sun+a[i];
}
System.out printlin (”数组元素之和:”+sum);
二维数组
定义和使用
二维数组是一种特殊的形式的一位数组,二维数组的每个元素都是一个一维数组’

二维数组初始化:
静态初始化:由程序员指定二维数组中的元素初始值,数组长度由系统决定
语法
数组元素类型[][] 数组名;//声明二维数组
数组名= new 数组元素类型[][]{{元素1,元素2….},{元素1,元素2….} …}

例:
    Int [] []  a;
   A=new int [][]{{1,2,3},{4,5,6},{7,8,9}};

第二种静态语法,必须要把声明数组和初始化放在一起,否则报错
Int[][] arr={{1,2,3},{4,5,6}};

动态初始化: 由程序员指定二维数组的长度,系统根据数组数据类型给数组元素分配初始值
解释:不需要程序员指定二维数组中一维数组元素的值,秩序要指定长度即可
语法:
例:
Double[][] arr=new double[2][2];// 声明数组
// 2.数组元素类型[][] 数组名=new 数组元素类型[数组长度][数组长度];
Arr[0][0]=10.2;//
Arr[0][1]=15.4;
Arr[1][0]=20.5;
Arr[1][1]=24.5;
使用二维数组
1访问数组;
数组名[行下标m] [列下标n] //m/n下标都是从零开始
public class xxx{
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5,6},{1,2},{0}};
//对数组元素进行访问
System.out.println(arr[0][1]);
System.out.println(arr[1][1])
}
}
数组输出:
2,
5
2.遍历数组:
public class xxx{
public static void main(String[] args) {
//首先定义一个二维数组
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//其次我们依次遍历二维数组中的一维数组元素
//遍历第一个一维数组
System.out.println(“普通输出：”);
for(int i=0;i<arr[0].length;i++){
System.out.print(arr[0][i]+" “);
}
System.out.println();//每执行完一个一维数组换行
//遍历第二个一维数组
for(int i=0;i< arr [1]. Length ;i++){
System.out.print(arr[1][i]+” “);
}
System.out.println();//每执行完一个一维数组换行
//遍历第三个一维数组
for(int i=0;i<arr[2].length;i++){
System.out.print(arr[2][i]+” “);
}
System.out.println();
System.out.println(“改进后：”);
//上面三式子可视代码相似，所以我们对其进行改进化简
for(int a=0;a<arr.length;a++){//控制每个一维数组
for(int i=0;i<arr[a].length;i++){//控制每个一维数组中的元素
System.out.print(arr[a][i]+” “);//输出每个元素的值
}
System.out.println();//每执行完一个一维数组换行
}
}
}
数组输出：
1 ,2, 3,
4 ,5 ,6,
7, 8, 9,
冒泡排序
排序方式:
总是将小数往前放,大的数往后放,类似水中的气泡上升的过程,
基本思想:
对比相邻元素,如果满足条件就交换元素,把较小的元素放在前面,较大的元素放后面.
运算过程:
冒泡排序算法的运作如下：
1、比较相邻的元素。如果第1个比第2个大（小），就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。
3、除去最后一个元素外,其他元素重复以上步骤
4、持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。
分析
以数组 arr = [5, 1, 4, 2, 8] 为例说明，加粗的数字表示每次循环要比较的两个数字：
第一次外循环
( 5 1 4 2 8 ) → ( 1 5 4 2 8 )， 5 > 1 交换位置
( 1 5 4 2 8 ) → ( 1 4 5 2 8 )， 5 > 4 交换位置
( 1 4 5 2 8 ) → ( 1 4 2 5 8 )， 5 > 2 交换位置
( 1 4 2 5 8 ) → ( 1 4 2 5 8 )， 5 < 8 位置不变
第二次外循环（除开最后一个元素8，对剩余的序列）
( 1 4 2 5 8 ) → ( 1 4 2 5 8 )， 1 < 4 位置不变
( 1 4 2 5 8 ) → ( 1 2 4 5 8 )， 4 > 2 交换位置
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )， 4 < 5 位置不变
第三次外循环）
( 1 2 4 5 8 ) → ( 1 2 4 5 8 )
例:
public class xxx {
public static void main(String[] args) {
int [] a={6,4,7,2,8,1};//定义数组
//控制数组中元素排序的趟数
for(int i=0;i<a.length-1;i++){
//将指定元素依次与数组中其他元素对比
for(int j = 0; j < a.length-1-i; j++) {
if (a[j]>a[j+1]){
//保存较大元素
int temp=a[j];
//较小往前移
a[j]=a[j+1];
//较大的往后移
a[j+1]=temp;
}
}
}
//将排序后的元素循环
for (int z = 0; z < a.length; z++) {
System.out.println(a[z]+” ");

}
}
运行结果:
1
2
4
6
7
8
选择排序
基本思想:
将指定的排序位置与其他数组元素分别对比,满足条件就交换,
注意:和冒泡排序区别,不是交换相邻元素,而是把满足条件的元素交换到指定位置,
选择排序速度比冒泡排序快一些,和冒泡排序差不多,只是冒牌排序发现较小数据的时候就交换,而选择排序只有在确定了最小的数据之后猜会发生交换
算法实例
原始数组: 5 2 8 4 9 1
第一次:将最小的数据1放在首位,也就是1和5换;
结果:1 2 8 4 9 5;
第二次:将除1以外的数据(2 8 4 9 5)比较,2最小
结果1 2 8 4 95
第三次:将除1 2 以外的数据(8 4 9 5)比较,4小,8和4换位;
结果1 2 4 8 9 5
第四次:将除1 2 4以外的数据(8 9 5)比较,8和5换位
结果1 2 4 5 9 8
第五次:将1 2 4 5 以外的数据(9 ,8 )进行比较,8小,8和9换位置
结果1 2 4 5 8 9

例:
public class xxx {
public static void main(String[] args) {
int [] arr={1,3,2,45,65,33,12};//定义数组
System.out.println(“交换前”);
//遍历数组
for(int z=0;z<arr.length;z++){
System.out.println(arr[z]+" “);
}
//使用选择排序进行排序
//控制趟数
for(int i=0;i<a.length-1;i++){
//比较数组元素
for(int j=j+1; j < a.length; j++) {
if (arr[i]>arr[j]){
//保存较大元素
int temp=arr[i];
//较小往前移
arr[i]=arr[j];
//较大的往后移
arr[j]=temp;
}
}
}
System.out.println(“交换后”);
//遍历数组元素
for (int z = 0; z < arr.length; z++) {
System.out.println(arr[z]+” ");
}
}
}
运行结果:
交换前:
1 3 2 45 65 33 12
交换后:
1 2 3 12 33 45 65