前端开发Java学习

前端大灰狼

已于 2024-04-16 11:10:26 修改

阅读量945

点赞数 19

文章标签：学习 java

于 2023-11-24 08:56:05 首次发布

本文链接：https://blog.csdn.net/a9874561328/article/details/134547229

版权

注释：单行注释 //

多行注释 /* */

文件注释 /** */

1 关键字

（关键字一定是小写）

2 常量

字符串常量	"HelloWord","你好世界"
整数常量	12，-33
小数常量	3.14，22.1
字符常量	'A'，'a' （字符常量只能是一个字母）
布尔常量	true,false
空常量	null（空常量不能直接输出）

⚠️ 单引号代表字符也就是char，双引号代表字符串String,

单引号只能放一个字符或是字母，所以字符可以直接转换成字符串。字符串需要使用charAt（n) 来获取第几个字符

并且char是基本数据类型，无法直接调方法，但是String是一个类就可以直接 .方法（）

3 数据类型

和js一样也是分为基本数据类型和引用数据类型

（一）基本数据类型

数据类型	关键字	内存占用	取值范围
整数	byte	1	-128～127
	short	2	-32768～32767
	int(默认)	4	-2的31次方～2的31次方-1
	long	8	-2的63次方～2的63次方-1
浮点数	float	4	负数：-3.402823E+38～-1.401298E-45 正数：1.401298E-45～3.402823E+38 -2^128~+2^127
浮点数	double (默认)	8	负数:-1.797693E+308～-4.9000000E-324 正书:4.9000000E-324～1.797693E+308
字符	char	2	0~65535，带单引号的字符'中','a'
布尔	boolean	1	true,false

⚠️ 定义整数时默认为int类型，如 long num = 100000000000，这个num肯定小于2的31次方，但是编译时默认视为int类型就会报错，这时候就要在后边加个'L'， long num = 100000000000L,同样的定义float时防止类型不兼容也要加'F'

4 标识符

由数字、字母、_、$组成
不能以数字开头
不能是关键字
区分大小写
标识符就是变量、常量、方法等的命名标识。

5 类型转换

（一）自动类型转换

由小范围类型转到大范围类型

byte => short => int => long => float => double

char => int => long => float => double

（二）强制类型转换

由大范围类型转到小范围类型

int a = (int)88.88
System.out.println(a) // 88

会造成数据丢失，不建议使用

6 运算符

int类型 + 字符时是能计算的，但是跟js不同，js是做拼串，java是拿字符在计算机底层代表到数值进行计算

int a = 10
System.out.println(a + 'a') // 107
// 这里'a'代表97

算式中包含多个类型的值时，整个算式表达式的类型会自动提升

byte类型、short类型、char类型会被提升到int类型
整个表达式的类型会自动提升到当前表达式中最高的等级同样的类型
等级顺序：byte、short、char => int => long => float => double

其他运算符跟js没区别

7 数据输入

import java.util.Scanner; // 导入Scanner工具包

public class HelloWord {
    public static void main(String[] args) {
        Scanner value = new Scanner(System.in); // 创建对象
        int x = value.nextInt(); // 获取输入的数据
        System.out.println("x:" + x);
    }
}
// 编译运行之后在控制台输入的值就会作为x打印出来

8 Random（随机数）

import java.util.Random; // 导入Random工具包

public class HelloWord {
    public static void main(String[] args) {
        Random num = new Random(); // 创建对象
        int x = num.nextInt(10); // 获取[0, 10)的随机数
        System.out.println("x:" + x);
    }
}

9 数组

（一）定义数组

两种方式：

1. 动态初始化

// 第一种：
int[] arr1 = new int[3];
// 第二种：
int arr2[] = new int[4];
// new代表为数组申请内存空间，数据类型后的数字代表数组长度
// 另外System.out.println(arr1) 打印出的内容是指这个数组的存储地址

2. 静态初始化

// 格式
int arr[] = new int{1, 2, 3}
// 简写
int arr[] = {1, 2, 3}
int[] arr = {1, 2, 3}

10 方法

（一）格式

public static void 方法名(数据类型 形参名, 数据类型 形参名...) {
}
// void 代表方法没有返回值，如果要有返回值这个位置就要写返回值的数据类型
// 另外如果void虽然没有返回值但是可以写return，但是return后不能有东西
// 例
public static int fun(int a, int b) {
    return a + b;
}

（二）方法重载

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

在js中同一作用域无论如何都不能同名，但是java就支持甚至推荐可以同名，调用的时候传入不同的参数就会调用不同的方法，作用是可以节省变量名？

public class LiZi{
    public static void main(String[] args) {
        fun(); // "结果1"
        fun(1, 2); // "结果2: 3"
    }
    public static void fun() {
        System.out.println("结果1");
    }
    public static void fun(int a, int b) {
        System.out.println("结果2: " + （a + b）)
    }
}

11 类和对象

类是对象的抽象

对象是类的实体

（一）类的定义

public class 类名 {
    // 成员变量
    数据类型 变量名;
    ...
    // 成员方法
    方法1;
    ...
}

（二）对象

// 格式
// 类名 对象名 = new 类名()
Lei fun = new Lei()

（三）封装

1. private

权限修饰符
可以修饰成员变量或是成员方法
作用是保护成员不被别的类使用或访问，被private修饰的成员只能被本类访问
使用getter或setter获取或修改

2. 封装

1. 封装概述：

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

是面向对象编程语言对客观世界的模拟，客观世界里的成员变量都是隐藏在对象内部的，外界是无法直接操作的

2. 封装原则：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对象隐藏信息的操作和访问

成员隐藏变量private，提供对应的getter和setter方法

3. 封装好处：

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

（四）构造方法

1. 构造方法名就是类名

2. 如果构造类没有定义构造方法，系统会使用默认的无参构造方法

3. 如果定义了构造方法，就不会使用默认的无参方法

4. 构造方法可以重载，new 一个构造类时传入重载方法的参数就是运行指定的构造方法

12 String 字符串

（一）简介

String类在java.lang包下，使用时不需要导包

String类代表字符串，java程序中所有字符串文字都被视为String类的实例

字符串的底层原理是字节数组

（二）String构造对象

// 1. public String() 创建一个空白字符串对象
String str1 = new String();
// 2. public String(char[] chs) 根据字符数组创建字符串对象
char[] str2 = {'1', '2', '3'};
System.out.println(str2); // 123
// 3. public String(byte[] bys) 根据字节数组创建字符串对象
byte[] str3 = {97, 98, 99};
System.out.println(str3); // abc 自动转成字符了
// 4. 直接赋值
String str4 = "123"

（三）String特点

1. 通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同但是地址值不同。

2.以直接赋值方式创建的字符串，只要字符串相同，无论创建几次JVM都只会创建一个String对象，并在字符串池中维护。（我寻思这不是理所当然吗。。。）

3.另外一点跟js不一样的，因为在java中String是个类，所以要获取length实际是调用length方法，例如 xxx.length()

（四）equals

== 比较运算符，比较基本数据类型时比较的是值，比较引用数据类型时比较的是内存地址

equals与 == 一样，但是String类覆写了Object的equals类，比较两个地址不一样但是值一样的String时会显示true

String str1 = new String("abc");
String str2 = new String("abc");

System.out.println(str1 == str2); // 打印false
System.out.println(str1.equals(str2)); // 打印true

（五）StringBuilder

因为java的字符串是引用数据类型，而java对字符串的存储是将所有字符串放到堆内存的常量池中，变量代表的是这个字符串的内存地址。字符串做拼接操作时，会吧操作前后和拼接完成的字符串全部创建一个String类并存储到常量池中，耗时又浪费存储空间。java提供了StringBuilder类来解决这个问题。

StringBuilder是一个可变的字符串类，String是不可变的，这里StringBuilder跟js的字符串比较像了。

1）append方法（追加）

添加数据并返回数据本身（自身会被改变）

StringBuilder sb = new StringBuilder();
System.out.println(sb); // 打印空
sb.append("java");
System.out.println(sb); // 打印java
sb.append(" learn ");
System.out.println(sb); // 打印java learn 
sb.append(6);
System.out.println(sb); // 打印java learn 6
StringBuilder sb2 = sb.append('s');
System.out.println(sb); // 打印java learn 6s
System.out.println(sb2); // 打印java learn 6s
System.out.println(sb == sb2); // true

append可以追加任意类型，不需要赋值，直接改变原数据。

返回的是对象本身，所以赋值前后对比为true

StringBuilder sb = new StringBuilder();
sb.append("java").append("learn").append(66);
System.out.println(sb); // javalearn66

跟jQuery一样，因为返回的是对象，所以返回值也可以调用方法。

2）reverse方法（翻转）

跟js一样

（六）String和StringBuilder相互转换

1）StringBuilder => String

通过toString()方法

StringBuilder sb = new StringBuilder();
sb.append("abc")
String = sb.toString();

2）String => StringBuilder

使用构造方法

String s = "abc";
StringBuilder sb = new StringBuilder(s);

String类没有append和reverse方法，转换的目的可能是为了用append和reverse？

13 集合

ArrayList<E>

可调整大小的数组实现
<E> 泛型

还在更新中......