自学Java记录

2301_80923659

已于 2024-06-02 09:41:57 修改

阅读量937

点赞数 27

文章标签： java

于 2024-05-17 23:12:16 首次发布

本文链接：https://blog.csdn.net/2301_80923659/article/details/139014201

版权

1.1 什么是CMD

CMD是就是在windows操作系统中，利用命令行的方式去操作计算机。

可以利用cmd命令去操作计算机，比如：打开文件，打开文件夹，创建文件夹等。

1.2 如何打开CMD

1.按下win+R键

2.输入cmd并按下回车

1.3 常见CMD命令

盘符名称：	盘符切换
dir	查看当前路径下的内容
cd 目录	进入单级目录
cd..	返回到上一级目录
cd 目录1\目录2\...	进入多级目录
cd\	回退到盘符目录
cls	清屏
exit	退出命令提示符窗口

1.4 使用CMD编译、运行HelloWorld

源码

cmd界面

第一步，切换盘符

第二步，找到对应盘符下的.java文件

第三步，使用JDK自带的编译工具javac编译成.class文件

第四步，运行该文件，不加后缀名

成功输出“Helloworld”

2 Path环境变量

2.1 为什么要配置Path环境变量

如果我们想在cmd任意目录下打开指定的软件，就可以把软件路径配置到环境变量中。

在启动软件的时候，操作系统会先在当前路径下找，如果在当前目录里没有找到，再去环境变量的路径中去找。如果都找不到就提示无法启动。

Java17在安装时已经配置好了部分环境变量。

其中有上次helloworld使用的java和javac

2.2 如何配置Path环境变量

Win11系统，在“此电脑”-右键打开“属性”-“高级系统设置”-“环境变量”即可进入到环境变量的界面。

点击“新建”

输入变量名和变量值（即jdk所在路径），点击“确定”

选中Path，点击“编辑”，新建环境变量，需要用百分号引用JAVA_HOME环境变量路径，并上移至最上方。

3 注释

class helloworld{
	//叫做main方法，表示程序的主入口
	public static void main(String[] args){
		/*叫做输出语句（打印语句）
		会把小括里面的内容进行输出打印*/
		System.out.println("你好");
	}
}

注释是对代码的解释和说明文字。

注释分为三种：单行注释//，多行注释/* */，文档注释/** */

注释使用细节：

1 注释的内容不会参与编译和运行的，仅仅是对代码的解释说明而已。

2 无论单行注释还是多行注释，书写时都不要嵌套。

4 关键字

关键字是被java赋予特定含义的英文单词

关键字的特点：

1 关键字的字母全部小写

2 常用的代码编辑器，对关键词有特殊颜色标识

5 字面量

字面量的作用是：告诉程序员，数据在程序中的书写格式。

字面量的种类
字面量类型	说明	举例写法
整数	不带小数的数字	-233
小数	带小数的数字	5.20
字符	必须使用单引号，有且仅能一个字符	'6'
字符串	用双引号括起来的内容	"丁真爱抽电子烟"
布尔值	布尔值，表示真假，只有两个值：true，false	true，false
空值	一个特殊的值，空值	null

一些特殊字面量的书写：

制表符：\t

在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多8个

空类型：null

打印时不能直接打印，只能通过字符串来打印

6 变量

6.1 什么是变量

变量就在程序中临时存储数据的容器，只能存一个值。

6.2 定义

定义格式：

数据类型变量名 = 数据值；

6.3 格式详解

数据类型：限定了变量当中能存储什么类型的数据。

变量名：其实就是这个容器的名字。

当以后想要使用变量里面的数据时，直接使用变量名就可以了。

数据值：真正存储在容器中的数据。

分号：表示语句的结束

6.4 常用数据类型

常用数据类型：int（整数），double（浮点数）等

7 数据类型

7.1 数据类型分类

有两种，分别是基本数据类型和引用数据类型

7.2 基本数据类型的四类八种

四类八种
数据类型	关键字	内存占用	取值范围
整数	byte	1	-128~127
	short	2
	int	4
	long	8
浮点数	float	4
	double	8
字符	char	2
布尔	boolean	1	true,false

整数类型和小数类型的取值范围大小关系：

double > float > long > int > short > byte

测试各种数据类型的变量

public class variabledemo{
	public static void main(String[] args){
	long n=999999999L;
	System.out.println(n);
	float f=6.66F;
	System.out.println(f);
	double d=8.888;
	System.out.println(d);
	char c='乐';
	System.out.println(c);
	boolean b=false;
	System.out.println(b);
	}
}

7.3 注意点

如果要定义一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。

如果要定义一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。

如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）

如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀。（大小写都可以）

8 标识符

标识符：就是给类，方法，变量等起的名字。

业内大多数程序员都在遵守阿里巴巴的命名规则。

8.1 硬性要求：

必须要这么做，否则代码会报错。

必须由数字、字母、下划线_、美元符号$组成。
数字不能开头
不能是关键字
区分大小写的。

8.2 软性建议：

如果不这么做，代码不会报错，但是会让代码可读性下降，难以理解

8.2.1 小驼峰命名法

适用于变量名和方法名

如果是一个单词，那么全部小写，比如：name
如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge

8.2.2 大驼峰命名法

适用于类名

如果是一个单词，那么首字母大写。比如：Demo、Test。
如果是多个单词，那么每一个单词首字母都需要大写。比如：HelloWorld

不管起什么名字，都要做到见名知意。

8.2.3 阿里巴巴命名规范细节：

尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。

正确：alibaba、hangzhou、nanjing

错误：jiage、dazhe
平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。

错误：_name

正确：name

9 键盘录入

Java已经写好了一个类叫Scanner，这个类可以接受键盘录入的数字。

9.1 步骤

1. 导包找到Scanner这个类在哪

import java.util.Scanner;

导包必须出现在类定义的上边

2. 创建对象表示要开始使用Scanner这个类了

Scanner sc=new Scanner(System.in);

上面这个格式里面，只有sc是变量名，可以变，其他的都不允许变。

3. 接收数据

int i=sc.nextInt();

上面这个格式里面，只有i是变量名，可以变，其他的都不允许变。

测试实例如下

//第一步，导包。找到Scanner这个类在哪
//书写要注意：要写在类定义的上面
import java.util.Scanner;
public class ScannerDemo{
	public static void main(String[] args){
		//第二步，创建对象。表示现在准备要用Scanner这个类
		Scanner sc=new Scanner(System.in);
		//第三步，接收数据
		//变量i记录了键盘录入的数据
		int i=sc.nextInt();
		System.out.println(i);
	}
}

10 使用IDEA进行编程

快速生成main方法，只需输入：psvm

编译器就会自动生成如下代码

public static void main(String[] args) {
        
    }

快速生成输出语句，只需输入：sout

编译器就会自动生成如下代码

    System.out.println();

11 算术运算符和表达式

运算符：

就是对常量或者变量进行操作的符号。

比如： + - * / %

表达式：

用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。

比如：a + b 这个整体就是表达式。

而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。

除号注意点 /：

1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。

2.小数直接参与运算，得到的结果有可能是不精确的。例子如下：

System.out.println( 10 / 3);//3

System.out.println(10.0 / 3);//3.3333333333333335

取模、取余注意点 %：

他做的也是除法运算，只不过获取的是余数而已。

System.out.println(10 % 3);//1

12 类型转换

12.1 隐式转换（自动类型提升）

12.1.1 概念

就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。

12.1.2 两种提升规则

取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。
取值范围从小到大：byte<short<int<long<float<double

12.2 强制转换

12.2.1 概念

如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量，是不允许直接操作的。

如果一定要这么干，就需要加入强制转换。

12.2.2 书写格式

目标数据类型变量名 = （目标数据类型）被强转的数据；

double a = 12.3;
int b = (int) a;

注意点：

强制转换有可能会导致数据发生错误。（数据的精度丢失）

13 字符串的+操作

当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
当连续进行+操作时，从左到右逐个执行的。

测试代码及结果

public class Test{
    public static void main(String[] args) {
        int age=18;
        System.out.println("我的年龄是"+age+"岁");
        System.out.println("我的年龄是"+"age"+"岁");
        System.out.println(1+2+"java"+1+2);
    }
}

我的年龄是18岁
我的年龄是age岁
3java12

14 字符的+操作

当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

测试代码及结果

public class Test{
    public static void main(String[] args) {
        char c='A';
        int number=c+32;
        System.out.println(number);
    }
}

在ASKII码中，'A'对应65

15 自增自减运算符

++：自增运算符把变量里面的值+1

--：自减运算符把变量里面的值-1

放在变量前面叫先加（减），在代码里的作用是：先加（减）后用
放在变量后面叫后加（减），在代码里的作用是：先用后加（减）

测试代码及结果

public class Test{
    public static void main(String[] args) {
        int x=5;
        int y=x++;
        int z=++x;
        System.out.println("x:"+x);
        System.out.println("y:"+y);
        System.out.println("z:"+z);
    }
}

x:7
y:5
z:7

16 赋值运算符

赋值运算符
符号	作用
=	赋值
+=	加后赋值
-=	减后赋值
*=	乘后赋值
/=	除后赋值
%=	取余后赋值

注意：除=赋值外的赋值运算符隐含了强制类型转换

17 关系运算符（比较运算符）

符号	说明
==	判断a和b的值是否相等，成立为true，不成立为false
!=	判断a和b的值是否不相等，成立为true，不成立为false
>	判断a是否大于b，成立为true，不成立为false
>=	判断a是否大于等于b，成立为true，不成立为false
<	判断a是否小于b，成立为true，不成立为false
<=	判断a是否小于等于b，成立为true，不成立为false

注意事项：关系运算符最终的结果一定是布尔类型的。要么是true，要么是false

18 逻辑运算符

符号	作用	说明
&	逻辑与（且）	并且，两边都为真，结果才是真
\|	逻辑或	或者，两边都为假，结果才是假
^	逻辑异或	相同为false，不同为true
!	逻辑非	取反

19 短路逻辑运算符

符号	作用	说明
&&	短路与	和&相同，但是有短路效果
\|\|	短路或	和\|相同，但是有短路效果

运算逻辑：

当左边不能确定整个表达式的结果，右边才会执行。

当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率

20 三元运算符（三元表达式）

格式：关系表达式？表达式1 ：表达式2 ；

计算规则：

计算关系表达式的值。
如果关系表达式的值为真，那么执行表达式1。
如果关系表达式的值为假，那么执行表达式2。

注意：三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。

例子如下：

public static void main(String[] args) {
        //求两个数的较大值
        int a = 10;
        int b = 20;
        //格式：关系表达式 ？ 表达式1 ： 表达式2 ；
        //三元运算符的最终结果一定要被使用。
        //要么赋值给一个变量，要么直接输出。
       int max =  a > b ? a : b ;
        System.out.println(max);
        System.out.println(a > b ? a : b);
    }

21 if的使用及三种格式

21.1 第一种

if (关系表达式) {
语句体;
}

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

注意：

如果我们要对一个布尔类型的变量进行判断，不要写==，直接把变量写在小括号中即可。

例子如下：

public static void main(String[] args) {
        boolean test=true;
        if(test){
            System.out.println("test的值为true");
        }
    }

2.如果大括号中的语句体只有一条，那么大括号可以省略不写。如果大括号省略了，那么if只能控制距离他最近的那一条语句。

21.2 第二种

if (关系表达式) {
语句体1;
} else {
语句体2;
}

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体1

③如果关系表达式的值为false就执行语句体2

④继续执行后面的语句内容

21.3 第三种

if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}

执行流程：

①首先计算关系表达式1的值

②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值

③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值

④…

⑤如果没有任何关系表达式为true，就执行语句体n+1。

22 switch语句

22.1 格式及其执行流程

格式如下：

switch (表达式) {
   case 1:
       语句体1;
       break;
   case 2:
       语句体2;
       break;
   ...
   default:
       语句体n+1;
       break;
}

执行流程：

首先计算出表达式的值

其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。

最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

22.2 switch拓展知识

default的位置和省略情况

default可以放在任意位置，也可以省略。
case穿透

不写break会引发case穿透现象。

即在对应语句体中，如果发现了break，就会结束整个switch语句。如果没有，就会继续执行下一个case语句（default也是一种特殊的case），直到遇见break或右大括号。

3.switch在JDK12以上版本的新特性

int number = 1;
switch (number) {
    case 1 -> {
    System.out.println("一");
}
    case 2 -> System.out.println("二");
    case 3 -> System.out.println("三");
    default -> System.out.println("其他");
}

这种写法可以简化代码，省略break。大括号也可以省略（case 1没有省略）。

23 循环结构

23.1 for循环

格式：

for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}

初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样

条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

23.2 while循环

格式：

初始化语句;
while(条件判断语句){
循环体;
条件控制语句;
}

24 数组

24.1 概念

指的是一种容器，可以同来存储同种数据类型的多个值。

但是数组容器在存储数据的时候，需要结合隐式转换考虑。

定义了一个int类型的数组。那么boolean、double类型的数据是不能存到这个数组中的，但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。

建议容器的类，和存储的数据类型保持一致。

24.2 数组的定义

格式一：

数据类型 [] 数组名

比如：int [] array

格式二：

数据类型数组名 []

比如： double array []

注意：

方法括号跟数组名，谁写在前面，谁写在后面都是一样的。

平时习惯性使用第一种方式。

24.3 数组静态初始化

24.3.1 完整格式：

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};

比如：

int[] arr = new int[]{11,22,33};

double[] arr = new double[]{1.1,1.2,1.3};

注意：

等号前后的数据类型必须保持一致。
数组一旦创建之后，长度不能发生变化。

24.3.2 简化格式：

数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};

比如：

int[] array = {1,2,3,4,5};

double[] array = {1.1,1.2,1.3};

24.4 数组元素访问

格式：

数组名[索引];

作用:

获取数组中对应索引上的值
修改数组中对应索引上的值

一旦修改之后，原来的值就会被覆盖了。

注意：索引是从0开始的

24.5 数组的遍历

遍历：就是把数组里面所有的内容一个一个全部取出来。

使用循环来遍历数组，例子如下：

int[] arr={5,6,7,8,9,10};
        for(int i=0;i<6;i++){
            System.out.println(arr[i]);
        }

在Java中有一个关于数组的长度属性，length

调用方式：数组名.length

比如 System.out.println(arr.lengrh);

因此上述循环遍历可以写为

int[] arr={5,6,7,8,9,10};
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

IDEA提供了一个自动快速生成数组遍历方式：数组名.fori

输入之后自动生成下列代码

for (int i = 0; i < arr.length; i++) {
            
        }

24.6 数组动态初始化

概念：初始化时只指定数组长度，由系统为数组分配初始值。
格式：

数据类型[] 数组名 = new 数据类型[数组的长度];

int[] arr=new int[3];

数组的默认初始化值：

整数类型：0

小数类型：0.0

布尔类型：false

字符类型：'\u0000'

引用类型：null

使用场景：

只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。

已经明确了要操作的所有数据，推荐使用静态初始化。

25 方法

方法是程序中最小的执行单元

25.1 无参数方法定义和调用

定义格式：

public static void 方法名 ( ) {
// 方法体;
}

调用格式：

方法名();

注意：方法必须先定义，后调用，否则报错。

public class MethodDemo{
    public static void main(String[] args) {
        test();
    }

    public static void test() {
        System.out.println("测试方法");
    }
}

25.2 带参数方法定义和调用

定义格式：

public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

调用格式：

方法名(参数)；

方法名(参数1,参数2...);

25.3 带返回值方法定义和调用

定义格式：

public static 数据类型方法名 ( 参数 ) {
return 数据 ;
}

注意：方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

调用格式：

方法名 ( 参数 ) ;
数据类型变量名 = 方法名 ( 参数 ) ;

测试代码例子如下：

public static void main(String[] args) {
        getSum(114,514);

        int sum=getSum(114,514);
        System.out.println(sum);

        System.out.println(getSum(114,514));
    }

    public static int getSum(int num1,int num2) {
        int result=num1+num2;
        return result;
    }

25.4 方法注意事项

方法不能嵌套定义

void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

25.5 方法重载

方法重载概念:

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

注意：

重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

25.6 基本数据类型和引用数据类型

26 面向对象

26.1 类的定义

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}

注意：

类名首字母建议大写，用英文，有意义，满足驼峰模式，不能用关键字，满足标志符规定
一个代码文件可以定义多个类，但只能一个类是public修饰的，public修饰的类名必须是Java代码的文件名称。

26.2 类的使用

创建对象的格式：
类名对象名 = new 类名();
调用成员的格式：
对象名.成员变量

对象名.成员方法();

26.3 封装和private

26.3.1 封装

是面向对象三大特征之一（封装，继承，多态）

对象代表什么，就得封装对应的数据，并提供数据对应的行为

26.3.2 private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
1. 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
2. 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

26.4 成员变量和局部变量

两者区别在于：

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

26.5 this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
1. 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
2. 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

例子如下：

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

26.6 构造方法

构造方法是一种特殊的方法

作用：创建对象

格式：

public class 类名{

修饰符 类名( 参数 ) {

}

}

功能：主要是完成对象数据的初始化

注意事项：

构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

推荐的使用方式

无论是否使用，都手工书写无参数构造方法

重要功能

可以使用带参构造，为成员变量进行初始化

26.7 标准JavaBean类

1. 类名需要见名知意

2. 成员变量使用private修饰

3. 提供至少两个构造方法

无参构造方法
带全部参数的构造方法

4. get和set方法

提供每一个成员变量对应的setXxx()/getXxx()

5. 如果还有其他行为，也需要写上

2301_80923659

关注

27
点赞
踩
24

收藏

觉得还不错? 一键收藏
1
评论
自学Java记录

CMD是就是在windows操作系统中，利用命令行的方式去操作计算机。可以利用cmd命令去操作计算机，比如：打开文件，打开文件夹，创建文件夹等。
复制链接

扫一扫