JAVA基础阶段个人总结

L7651

已于 2023-04-27 11:09:53 修改

阅读量638

点赞数 1

文章标签： java

于 2022-11-14 17:43:21 首次发布

本文链接：https://blog.csdn.net/L7651/article/details/127850859

版权

Java基础知识

概述

Java是1995年SUN公司发布，如今被Oracle收购。
下载安装Java时从Oracle官网下载，最好下载LTS长期维护版本。Java8、Java11、Java17是LTS版。
Java是一门半编译半解释的面向对象语言。
Java由于虚拟机JVM的存在，所以可以跨平台运行。
Java程序运行过程

public class Test{
    //主方法，是程序的入口，有且只有一个
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

编辑的是.java文件，称为源文件。通过javac命令进行编译，生成同名的.class字节码文件，在虚拟机上解释该字节码文件运行。

编程语言的命名规则

驼峰命名方法：

如果多个单词描述一个内容，除首字母外，其他单词首字母大写。例如：studentClass

帕斯卡命名法：

所有单词首字母全部大写。例如：StudentName

Java中的标识符及命名规则

Java中的类名、方法名和变量名统称为标识符

类名使用帕斯卡命名法。方法名、变量名使用驼峰命名法。命名时要做到见名知意

命名规则：

1、标识符使用字母、数字、下划线和$组成
2、不能以数字开头
3、不能使用Java中的关键字（保留字）

数据类型

原始类型

整型 byte short int long

浮点型 float double

字符型 char

布尔型 boolean

注意

原始类型的取值范围如 byte 型取值范围-128~127 byte=129时,数据越界这是计算机自动从-128开始取值.

引用类型

数组
类
接口

类型转换

自动类型转换

小字节类型数据可以直接保存到大字节类型的变量中。
整型数据可以直接保存到浮点型变量中。

short s=123;
int i=s;

long num=123;
float f=num;

强制类型转换
同类型下，如果大字节类型的数据强制保存到小字节类型的变量中，需要强制类型转换

int i=123;
byte b=(int) i;

变量

保存数据的内存区域，其中的数据可以变化。

定义变量

数据类型变量名;

变量名规则

变量可以由字母数字下划线组成
不能以数字开头
不能使用Java中的关键字（保留字）
不能含有空格

变量赋值

变量名=值；
=右边的值有默认的数据类型。
整数默认为int，小数默认double类型。

变量初始化

数据类型变量名 = 值;
变量需要定义、赋值后才能使用。

int i;
System.out.println(i);

运算符

算术运算符

需要两个操作数参与，如果有浮点数参与运算，结果为浮点型。

符号	作用	说明
+	加	如果两个操作数都是数值型的数据，+用于计算。如果两个操作数有一端是字符串，+用于拼接字符串。
-	减	只能用于数值型数据。
*	乘	只能用于数值型数据。
/	除	只能用于数值型数据。如果两个整数相除，结果只保留整数部分(商)。
%	取余	只能用于数值型数据。商一定是整数。

注意

如果同时多个符号一起使用，遵循数学中的四则运算规则，先乘除，后加减
运算时最终结果的数据类型，以所有参与运算的操作数中所占字节最大的类型为准
```
System.out.println(8/3+3*5%2.0);//2+15%2.0 =>  2+1.0 => 3.0
```

关系运算符

需要两个操作数参与，计算结果为布尔型boolean

符号	作用
>	大于
<	小于
>=	大于等于
<=	小于等于
!=	不等于
==	等于
注意

==用于判断相等，=用于赋值
==用于比较两个原始类型的值或引用类型的内存地址
关系运算的结果为true/false

逻辑运算符

符号	作用	说明
&&	and与	符号两端需要两个表达式，判断如果都为true，整体结果则为true，如果有一端结果为false，整体结果为false。
\|\|	or或	符号两端需要两个表达式，判断如果都为false，整体结果则为false，如果有一端结果为true，整体结果为true。
!	not非	是一个单目运算符，只有一个表达式参与运算。"!表达式"表示对原表达式的结果取相反值。

位运算符

符号	作用
&	按位与。计算的结果与&&相同，但过程不同。符号两端的表示都会执行判断。
\|	按位或。计算的结果与\|\|相同，但过程不同。符号两端的表示都会执行判断。
^	按位异或。将操作数转换为二进制后，按位比较，如果相同结果为0，不同结果为1，最终二进制结果转换为十进制。
>>	按位右移。将第一个操作数转换为二进制后，向右移动第二个操作数对应的位数，再将结果转换为十进制。
<<	按位左移。将第一个操作数转换为二进制后，在后边补充第二个操作数对应数量的0，再将结果转换为十进制。

//按位异或。将操作数转换为二进制后，按位比较，如果相同结果为0，不同结果为1，最终二进制结果转换为十进制。
//2   010
//4   100
//    110  --- 6
System.out.println(2 ^ 4);//6
//按位右移。将第一个操作数转换为二进制后，向右移动第二个操作数对应的位数，再将结果转换为十进制。
//6  110 向右移动1位   //011--3
System.out.println(6>>1);//3
//按位左移。将第一个操作数转换为二进制后，在后边补充第二个操作数对应数量的0，再将结果转换为十进制。
//5 101   //10100--20
System.out.println(5<<2);//20

注意

&&和||也称为短路运算。如果能通过第一个表达式决定最终的结果，则不用判断第二个表达式。
通常情况下，使用&&和||提高代码执行效率。

赋值和复合赋值运算符

符号	作用
=	赋值运算符。将符号右侧的内容赋值给符号左侧的变量。
+=	复合赋值运算符。a+=3相当于a=a+3;
-=	复合赋值运算符。
*=	复合赋值运算符。`a=b+c相当于a=a(b+c)`
/=	复合赋值运算符。
%=	复合赋值运算符。

注意
复合赋值运算的流程是
将符号两端的整体进行对应的算术运算后，将结果赋值给符号左侧的变量中。

int a=3;
a*=a+2;//相当于a=a*(a+2)//3*5，最终a的值为15

自增自减运算符

只有一个操作数参与运算，称为单目运算符

符号	作用
++	将结果+1
–	将结果-1

注意

a++或++a相当于a+=1或a=a+1。–同理
如果++或–独立成行使用，无论符号在前在后，都将结果+1或-1
```
int num=10;
// num++;
++num;
System.out.println(num);//11
```

如果++或–不是单独成行

符号在前，先+1或-1计算后再使用值
符号在后，先使用值后再+1或-1计算

int a=3;
if(a++>3){//符号在后，先使用，即3>3不成立

}
System.out.println(a);//a最终会+1,4

int b=4;
if(--b==3){//符号在前，先计算，即3==3成立

}
System.out.println(b);//3

int num=10;
System.out.println(num++ + ++num);//10 + ++11  => 22
int num2=10;
System.out.println(num-- - --num);//10 - --9   => 2

条件运算符

三目运算符，有三个操作数参与。是一个简化版的双分支条件语句。

表达式1?表达式2:表达式3

首先运算表达式1，如果结果为true，执行问号后的表达式2;

如果结果为false，执行冒号后的表达式3。

整个表达式的最终结果为表达式2或表达3。

三目运算符易忽略点

y=(x>4) ? 99.9 :9
如上表达式y=9.0. 三目运算符自动强转最大的数据类型 ,因为99.9时double数据类型,所以表达书y=9,自动强转double,故y=9.0

运算符的优先级

小括号>>单目运算符>>算术运算符>>关系运算符>>逻辑运算符>>条件运算符>>赋值/复合赋值运算符

使用条件运算符判断闰年

//四年一闰，百年不闰，四百年再闰
//year是“4的倍数但不是100的倍数，或者是400的倍数”
int year = 2022;
String res = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? "是闰年" : "不是闰年";
System.out.println(year + res);

条件语句

if语句

单分支if语句

如果一件事情满足则执行，不满足什么都执行。

if(判断条件){//判断条件的结果为布尔值
    条件满足时执行的代码
}

双分支if语句

如果一件事情有两种情况，满足执行某些内容，不满足则执行另一些内容

if(判断条件){
    条件满足时执行的代码
}else{
    条件不满足时执行的代码
}

多分支if语句

if(判断条件1){
    如果判断条件1满足时执行
}else if(判断条件2){
    如果判断条件2满足时执行
}else if(判断条件3){
    如果判断条件3满足时执行
}else{
    如果所有条件都不满足时执行
}

依次判断条件是否成立，如果有一个分支成立，后续分支不再判断

if嵌套

if(){
    if(){

    }
}else{
    if(){

    }
}

if嵌套不要嵌套太多层，会导致代码可读性变低。

if嵌套可以改造成if(){return}形式，让程序满足条件时，不再执行后续内容

/*
 * 定义3个变量表示三角形的三条边
 * 判断
 * 1.能否组成三角形(任意两边之和大于第三边)
 * 2.如果能，判断是什么三角形(等腰、等边、普通)
 * */

int a = 3, b = 4, c = 5;

//判断能否组成三角形
if (a + b > c && a + c > b && b + c > a) {//任意两边之和大于第三边
    //判断是什么三角形
    if (a == b && b == c) {//等边
        System.out.println("是等边三角形");
    } else if (a == b || a == c || b == c) {//等腰
        System.out.println("是等腰三角形");
    } else {
        System.out.println("是普通三角形");
    }
} else {
    System.out.println(a + "、" + b + "、" + c + "不能组成三角形");
}

注意

if或else后的大括号可以不写，但只能让后边紧邻的第一句话成为满足时执行的语句。

int num=10;
if(num==10)
    System.out.println("xxxx");//这句话是if满足时执行的内容
else 
    System.out.println("yyyy");//这句话是if不满足时执行的内容

int a = 10;
if (a < 0)
    a++;//这行属于if的满足时执行的内容，此时条件不成立，不执行
a++;//这行不属于if的内容，是一句独立的代码，要执行
System.out.println(a);//11

switch语句

开关语句

如果一个变量的值能够例举出时，使用switch语句更为简洁。

switch(变量){//要判断的变量，只能是非long整型、字符型char和字符串String和枚举类型
    case 值:
        //如果变量的值与当前case的值匹配，执行这里的代码
        break;
    case 值:
        //如果变量的值与当前case的值匹配，执行这里的代码
        break;
    ...
    default:
        //如果没有任何值与变量的值匹配，执行这里的代码
        break;
}

使用注意事项

swtich小括号中的变量只能是非long的整型、字符型char、字符串String和枚举类型
小括号中的变量类型要与case后的值的类型相匹配
如果有某个case后的内容和变量值匹配，执行case后的代码，如果没有任何case匹配，执行default后的代码
break和default可以省略。如果不写break，在某个case匹配时，执行玩相应的代码后继续执行后续case后的代码，直到遇到break或没有代码为止
如果多个case后执行的内容一致，可以省略break，将统一要做的代码放在最后的case后
if语句与switch语句的选择
如果条件能够一一例举出来时，使用switch语句更为简洁
如果条件是一个范围时，只能使用if语句，如大于100
switch语句可以改写为if语句，if语句不一定能改为switch语句

if语句和switch语句中的return关键字

if语句中可以使用return关键字不再执行后续的代码。可以使用这一点将原本的嵌套改造成if-return的形式。

int a=3,b=4,c=5;
if(a+b<=c || a+c<=b || b+c<=a){
       System.out.println("不能组成三角形");
    return;
}
if(a==b && b==c){
    System.out.println("等边");
}else if(a==b || a ==c || b==c){
    System.out.println("等腰");
}else{
    System.out.println("普通");
}

switch语句中，也可以使用return，但会造成switch语句之后的代码不执行，所以一般不在switch语句中使用return;

int num = 2;
switch (num) {
    case 1:
        System.out.println("a");
        break;
    case 2:
        System.out.println("b");
        return;
    case 3:
        System.out.println("c");
        break;
}
System.out.println("程序结束");//这句话不会打印

循环

如果要重复执行某些代码时，使用循环语句。

while

while(循环条件){//小括号中的条件结果为boolean值
    满足循环条件时重复执行的代码
}

执行流程

先执行小括号中的内容，如果结果为true，执行大括号中的内容，再循环执行小括号中的内容，判断如果为false则停止循环。

while循环有可能一次都不执行。

do-while

do{
    满足循环条件时重复执行的代码
}while(循环条件);

执行流程

先执行一次do大括号中的内容，再判断while小括号中的内容，如果成立，再次执行do大括号中的内容，如果不成立，停止循环。

do-while循环至少执行一次

while和do-while的区别

while循环可能一次都不执行，do-while循环至少会执行一次

for

//表达式1为定义循环变量
//表达式2为判断循环条件
//表达式3为更新循环变量
for(表达式1;表达式2;表达式3){
    循环体
}

执行流程

首先执行表达式1，再执行表达式2，如果表达式2的结果为true，执行循环体，再执行表达式3，再执行表达式2判断，如果表达式2的结果为false，结束循环

for循环特殊情况

//for循环特殊情况
//可以使用外部定义的循环变量
int i = 0;
for (;i<=10;i += 2) {
    System.out.println(i);
}
//可以在循环体重更新循环变量
int i = 0;
for (;i<=10;) {
    System.out.println(i);
    i += 2;
}
//两个分号必不可少，如果都不写表达式，是一个死循环
int i = 0;
for (; ; ) {
    if (i > 10) {
        break;
    }
    System.out.println(i);
    i += 2;
}

循环控制

break和return

所有的循环都可以使用break和return停止循环。

break是停止循环后，继续执行循环之外的内容。

return是结束方法，不再执行return之后的内容。

public static void main(String[] args) {
    int i = 1;
    while (true) {//死循环
        System.out.println("xxxxx");
        if (i++ == 10) {
            break;//退出整个循环，程序继续执行循环之外的内容
            // return;//退出整个方法，程序不再执行之后的代码
        }
    }
    System.out.println("结束");//如果循环中有return，不会执行这句话
}

continue

在循环语句中，使用continue，可以停止本次循环，不再执行continue之后的代码，直接进行下一次循环。

int i = 1;
while (i < 10) {
    if (i++ % 2 == 0) {
        continue;//如果遇到continue,结束本次循环(不再执行continue之后的代码),直接进入下一次循环
    }
    System.out.println(i);
}
//最终打印2 4 6 8 10

循环总结

如果已知循环次数，推荐使用for循环。如遍历数组、集合等。
如果未知循环次数，推荐使用while循环。
while循环和for循环可以相互转换
do-while循环至少执行一次，for循环和while循环有可能一次都不执行

循环嵌套

如果一个重复的过程还需要将其整体重复执行时，可以使用循环嵌套。

如循环判断密码是否输入正确，正确后循环打印功能菜单。

循环嵌套就是循环一个循环。

//用*打印矩形
//将循环一行这件事再循环5次
for (int n = 1; n <= 5; n++) {
    //循环打印一行
    for (int i = 1; i <= 10; i++) {
        System.out.print("*");
    }
    System.out.println();
}

循环练习

穷举法

将所有可能的情况一一例举出来。

//鸡兔同笼      笼子里有若干鸡和兔，头一共35，腿一共94，鸡兔各几只？
for (int ji = 0; ji <= 35; ji++) {
    for (int tu = 0; tu <= 35; tu++) {
        if (ji + tu == 35 && 2 * ji + 4 * tu == 94) {
            System.out.println("鸡：" + ji + "兔：" + tu);
        }
    }
}
//百元买百蛋  花够100元买够100个蛋     鸡蛋3个1元 鸭蛋1个3元 鹅蛋1个5元
for (int jd = 0; jd <= 100; jd++) {
    for (int yd = 0; yd <= 100; yd++) {
        for (int ed = 0; ed <= 100; ed++) {
            //整数间相除为整数，这里鸡蛋的价格需要用浮点数表示
            if (jd + ed + yd == 100 && 3 * yd + 5 * ed + jd / 3.0 == 100) {
                System.out.println("鸡蛋：" + jd + "鸭蛋：" + yd + "鹅蛋：" + ed);
            }
        }
    }
}

打印三角形

/*
         * *
         * ***
         * *****
         * *******
         * *********
         * */
/*
         * 行数i       每行*个数j
         * 1          1
         * 2          3
         * 3          5
         * i          j=2*i-1        an=a1+(n-1)d
         * */
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= 2 * i - 1; j++) {
        System.out.print("*");
    }
    System.out.println();
}

打印99乘法表

//打印99乘法表
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();
}

打印菱形

/*
         *
        ***
       *****
      *******
     *********
      *******
       *****
        ***
         *
*/
//菱形上半部分
for (int i = 1; i <= 5; i++) {
    //空白三角形 4+(i-1)*-1
    for (int j = 1; j <= 5 - i; j++) {
        System.out.print("-");
    }
    //*三角形   1+(i-1)*2
    for (int k = 1; k <= 2 * i - 1; k++) {
        System.out.print("*");
    }
    System.out.println();
}

//菱形下半部分
for (int i = 1; i <= 4; i++) {
    //空白三角形 1+(i-1)*1
    for (int j = 1; j <= i; j++) {
        System.out.print("-");
    }
    //*三角形  7+(i-1)*-2
    for (int k = 1; k <= 9 - 2 * i; k++) {
        System.out.print("*");
    }
    System.out.println();
}

数组(一维数组)

概念

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

关于数组

实际在内存中是一块连续的空间。是保存数据的区域。

数组定义时需要确定大小和数据类型，不可改变。

定义数组时的变量保存的是实际内存空间的地址。

数据中保存的数据称为元素，每个元素有一个唯一的位置，称为索引(下标)，这个索引从0计数。

可以通过数组的索引给数组赋值或读取数组中某个索引上的值。

定义数组

语法：数据类型[] 数组名； 或 数据类型数组名[]；。建议使用前者。

定义数组后，如果不初始化数组，数组无法使用。

//定义数组，如果数组未初始化，不能使用
int[] score;
//也可以这样写，但是不建议
//int score[];

数组初始化

语法：数组名=new 数据类型[数组大小];

//定义一个保存数组的变量nameList
String[] nameList;
//在内存中申请一块连续空间，将这个空间的地址保存到变量nameList中
nameList=new String[10];

定义数组的同时初始化

语法：数据类型[] 数组名 = new 数据类型[数组大小];

double[] salary = new double[30];

给数组赋值

动态赋值

通过**数组名[索引]**给数组中某个位置赋值

int[] list = new int[10];
list[0]=123;//索引从0开始
list[9]=22;//最大索引为数组大小-1
list[22]=5;//能通过编译，但是在运行时会抛出数组越界异常

静态赋值

在定义数组的同时赋值

数据类型 [] 数组名 = new 数据类型[]{元素1，元素2,…}
```
String[] nameList = new String[]{"小明","王海","刘希"};
```

数据类型 [] 数组名 = {元素1，元素2,…}

String[] nameList = {"小明","王海","刘希"};

注意

数组一旦初始化后，数组大小不能改变，其中的元素类型要统一
数组的索引范围是[0,数组大小-1]，使用时不能超出范围。在编译时无法识别是否超出数组索引，但运行时会抛出"数组索引溢出"异常
数组一旦初始化后，如果没有赋值，默认有初始值

数组数据类型默认值
整型 0
浮点型 0.0
引用类型(如String等) null
布尔型 false
字符型空白字符

数组数据类型	默认值
整型	0
浮点型	0.0
引用类型(如String等)	null
布尔型	false
字符型	空白字符

读取数组中的元素

通过**“数组名[索引]”**读取某个索引对应的元素

String[] nameList={"王海","刘涛","赵敏"};
System.out.println(nameList[0]);
System.out.println(nameList[1]);
System.out.println(nameList[2]);

可以通过循环给数组赋值和读取元素

//定义一个数组保存同学的姓名，循环接收后打印所有。
Scanner sc = new Scanner(System.in);

//定义数组
String[] stuName = new String[3];

//循环赋值
for (int i = 0; i < 3; i++) {
    System.out.println("请输入第"+(i+1)+"位同学的姓名");
    stuName[i] = sc.next();
}

//循环读取
System.out.println("当前学生列表");
for (int i = 0; i < stuName.length; i++) {//通过“数组名.length”获取数组的长度
    System.out.print(stuName[i]+"\t");
}
//增强for循环   for(数据类型 变量名 : 数组或集合){}
for (String name : stuName) {
    System.out.print(name + "\t");
}
System.out.println();

增强for循环

专门用于遍历数组或集合元素的一种循环

语法：for(数据类型变量名 : 数组名){}

String[] list = {"admin","qwe","aaa"};
//使用增强for循环遍历
for(String name : list){
    System.out.println(name);
}

冒泡排序

数组中每相邻的两个元素进行比较，如果不满足排序的规则，交换位置。

//冒泡排序
//每相邻的两个元素进行比较，如果不满足排序的要求，则交换位置


//如要将 9 7 5 2 1  这组数据进行升序排序
//第一轮比较：7 5 2 1 9        比较了4次 97 95 92 91
//第二轮比较：5 2 1 7 9        比较了3次 75 72 71
//第三轮比较：2 1 5 7 9        比较了2次 52 51
//第四轮比较：1 2 5 7 9        比较了1次 21
//比较轮数i             每轮比较次数j
//1                     4
//2                     3
//3                     2
//4                     1
//i=数组长度-1            j=数组长度-i

冒泡排序核心代码

//外层循环控制比较的轮数
for(int i=1;i<=数组.length-1;i++){
    //内层循环控制每轮比较的次数
    for(int j=1;j<=数组.length-i;j++){
        //判断是否要交换位置
        if(数组[j-1] < 数组[j]){//如果不满足降序的条件(小于)则交换位置
            //借助第三个变量交换数组中元素的位置
            int temp = 数组[j];
            数组[j]=数组[j-1];
            数组[j-1]=temp;
        }
    }
}

举例

public class ArrayTest5 {

    public static void main(String[] args) {
        //定义一个整型数组，将其中的元素进行升序排序
        int[] list = {17, 22, 13, 20, 32};

        //外层循环表示比较的轮数
        for (int i = 1; i <= list.length - 1; i++) {
            //内存循环表示每轮比较的次数
            for (int j = 1; j <= list.length - i; j++) {
                //每次比较时，判断是否满足排序要求，如果不满足则交换位置
                if (list[j - 1] > list[j]) {//这里需要升序，所以如果第一个元素大于第二个元素，就要交换位置
                    //交换位置
                    int temp = list[j - 1];//先将其中任意一个索引上的元素取出来
                    list[j - 1] = list[j];//再将另一个元素放过去
                    list[j] = temp;//再将第一个元素放回来
                }
            }
        }

        //打印排序后的元素
        for (int i : list) {
            System.out.println(i);
        }
    }
}

数组工具类Arrays

Arrays是jdk提供的用于处理数组的工具类。包含了如排序、复制、填充等方法，这些方法都是静态方法，直接通过Arrays调用。

常用方法	作用
sort(数组)	将输入中的元素升序排序。
sort(数组,起始位置,结束位置)	对数组中[起始位置,结束位置)区间的元素升序排序。
fill(数组,值)	使用指定值对数组中的所有元素进行填充。
fill(数组,起始位置,结束位置,值)	使用指定值对数组中[起始位置,结束位置)区间的元素进行填充。
copyOf(数组,新数组长度)	复制数组并指定复制后的数组的长度。得到复制后的新数组。
asList(一组数据)	将一组数据转换为List集合。
equals(数组1,数组2)	判断两个数组是否相同，得到判断的布尔值。只有两个数组一模一样时得到true。

生成随机数的方法

Random rd = new random(); 
//生成[0,num)范围内的随机int数
int res=rd.nextInt(int num);

L7651

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
JAVA基础阶段个人总结

Java基础
复制链接

扫一扫