一篇文章让你从入门到彻底学会Java_java语言基础最重要的是那一点

最新推荐文章于 2024-05-19 21:34:53 发布

2301_82242528

最新推荐文章于 2024-05-19 21:34:53 发布

阅读量347

点赞数 8

分类专栏：程序员文章标签： java python 开发语言

本文链接：https://blog.csdn.net/2301_82242528/article/details/138364803

版权

程序员专栏收录该内容

222 篇文章 0 订阅

订阅专栏

+ [Java 流(Stream)、文件(File)和IO](#Java_StreamFileIO_855)
+ [Java Scanner 类](#Java_Scanner__972)
+ [Java 异常处理](#Java__1074)

第一个Java程序+基础知识详解

java语言基础主要有以下几个重要的方面：类，对象，方法，实例变量。

对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
接下来就是经典的程序员必会：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World"); 
    }
}

这就是Java的第一个程序了，下面我将解释一下上述的各个部分分别是什么意思。
在主程序中public static void main(String[] args)这句就是在所有语言中最重要的主函数。他的构成主要是：
public：访问修饰符（这个关键字说明了方法main()是公有的，可以被任何的方法所访问）；
static：关键字（这个关键字告诉编译器main()方法是静态的，不需要通过实例来调用。）
void：返回类型（指明main()方法不返回任何值，这一点很重要。）
String[]：Sting类（记得区分大小写，这点很重要）
args：字符串数组。
String args[]:合在一起表示命令行参数。
解释完了最重要的主函数之后，我们看看public class HelloWorld，这就很好理解了，这行代码的主要目的就是声明了一个公有类，类名为： HelloWorld。
在自己编写java程序的时候一定一定一定要注意下面几点：

大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为
.java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。这里一定要注意是String而不是string。

Java所包含的标识符：这里和c语言有点区别，Java含有大小写字母，＄符，下划线，在这三个条件下只要不是数字开头就合法，数字可以包含在其中。
Java中的修饰符：主要分为两类：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized
Java中含有的变量:1，局部变量 2，类变量（静态变量） 3，成员变量（非静态变量）
Java的枚举：枚举的主要做用就是限制变量，举个栗子：你是奶茶店的，奶茶只有大中小三种类型，顾客只能点这三种类型，他要是点半杯，你肯定说卖不了，对于程序来说就直接给你报错了。（后面到这一章节的时候将会详细讲述）
注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。
Java的关键字：
国际通用表格来了

Java的注释：有两种常用的注释方式：/*+++++++++*/这是多行注释的注释方式，

 // 这是单行注释的示例

Java的继承：在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（sub class）。
Java的接口：在 Java 中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
Java 源程序与编译型运行区别：
在这里插入图片描述

Java的对象和类

Java在面向对象的过程中，主要支持的有以下的方法：
多态，继承，封装，抽象，类，对象，实例，方法，重载。
对象：对象是类的一个实例，有行为状态等。
类：类是一个模板，他描述一类对象的行为和状态。
这里要明确的弄懂类和对象之间的关系，明白了这二者之间的关系就学明白了这一张节。
举个栗子：在下图中class表示类，object表示对象
请添加图片描述
Java中的对象：软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。
在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。
Java 中的类：类可以看成是创建 Java 对象的模板。
一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
构造方法：每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。为了实现这样的功能，系统自定义默认的构造函数，同时允许程序员编写自己的构造方法去完成不同的操作。构造方法是特殊的类方法，有着特殊的功能，他的名字与类名相同，没有返回值，在创建对象实例时由new运算符自动调用。同时为了创建实例的方便，一个类可以有多个具有不同参数列表的构造方法，即构造方法可以重载。事实上，不论是系统提供的标准类还是用户自定义的类，往往都含有多个构造方法。

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

创建对象：对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字 new 来创建一个对象。
初始化：使用 new 创建对象时，会调用构造方法初始化对象。

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Java中的数据类型

Java中含有的两大数据类型：

内置数据类型
引用数据类型

在这里插入图片描述
学了之前的内容，下面的代码应该是能看懂的哈

public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte 
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN\_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX\_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  
  
        // short 
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN\_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX\_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  
  
        // int 
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN\_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX\_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
  
        // long 
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN\_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX\_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
  
        // float 
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN\_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX\_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
  
        // double 
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN\_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX\_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
  
        // char 
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN\_VALUE输出到控制台 
        System.out.println("最小值：Character.MIN\_VALUE="  
                + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX\_VALUE输出到控制台 
        System.out.println("最大值：Character.MAX\_VALUE="  
                + (int) Character.MAX_VALUE);  
    }  
}

这里就不做多余解释了。
Java常量：在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

自动类型转换：整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。
低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double
数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度
强制类型转换：

条件是转换的数据类型必须是兼容的。
格式：(type)value type是要强制类型转换后的数据类型

Java变量类型

在Java语言中，所有的变量在使用前必须声明。
格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
下面看个实例：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

在之前你应该看到了我所提到的类变量，实例变量，局部变量。
下面就详细解释一下：

public class Variable{
    static int allClicks=0;    // 类变量
 
    String str="hello world";  // 实例变量
 
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

Java 局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
实例变量
实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
类变量（静态变量）
类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static
类型的变量。静态变量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。
变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。
Java修饰符
Java的修饰符分为两类：
1，访问修饰符
2，非访问修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端。

public class ClassName {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

访问控制修饰符

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

这里的访问和控制和c语言的几乎一模一样就不多赘述了。
访问的继承
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被子类继承。
非访问修饰符
为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
上述的各种修饰符前面有部分以及解释过，我会将比较难理解和需要注意的具体的解释一下
abstract 修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

Java运算符

总共有以下几种：
1，算术运算符
2，关系运算符
3，位运算符
4，逻辑运算符
5，赋值运算符
6，其他运算符
算术运算符
在这里插入图片描述
关系运算符

位运算符

逻辑运算符

在这里插入图片描述
赋值运算符

Java运算符优先级

Java中的循环

在Java中有三种主要的常用大的循环结构
while循环
do…while循环
for循环
while 循环
while是最基本的循环，它的结构为：

while( 布尔表达式 ) {
  //循环内容
}

只要布尔表达式为 true，循环就会一直执行下去。
do…while 循环
对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
for循环
虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。
关于 for 循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。
Java 增强 for 循环
Java5 （一般学习常用java8）引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式)
{
   //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
这里可能不太好理解，我们结合实例看一下：

public class Test {
   public static void main(String[] args) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         // x 等于 30 时跳出循环
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

public class Test {
   public static void main(String[] args) {
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

Java 条件语句

if 语句的语法如下

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

这一章节与c语言完全一样，用法方面就不多赘述了。

public class Test {
 
   public static void main(String args[]){
      int x = 10;
 
      if( x < 20 ){
         System.out.print("这是 if 语句");
      }
   }
}

Java中的switch case语句

switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch
支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
switch 语句可以包含一个 default 分支，该分支一般是 switch语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default分支不需要 break 语句。

Java 中的 Math 类

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

上述代码的结果
90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
3.141592653589793

下面的表中列出的是 Number & Math 类常用的一些方法：请添加图片描述
Math 的 floor,round 和 ceil 方法实例比较
在这里插入图片描述

Java Character 类

Character 类用于对单个字符进行操作。
Character 类在对象中包装一个基本类型 char 的值

char ch = 'a';
 
// Unicode 字符表示形式
char uniChar = '\u039A'; 
 
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。
Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象
转义序列
在这里插入图片描述
Character 方法

要想详细了解具体的构成方法可以查一查官方的API文档
Java官方API链接

Java String类

字符串广泛应用在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串
语法方式如下：

String str = "zifuchuan";

在代码中遇到字符串常量时，这里的值是 “zifuchuan”，编译器会使用该值创建一个 String 对象。
和其它对象一样，可以使用关键字和构造方法来创建 String 对象。
String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

字符串长度
用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
下面的代码执行后，len 变量等于 14:

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.csdn.net";
        int len = site.length();
        System.out.println( "csdn网址长度 : " + len );
   }
}

运行结果如下：

csdn网址长度 : 12

连接字符串
String 类提供了连接两个字符串的方法：

string1.concat(string2);

更常用的是使用’+'操作符来连接字符串，如：

"Hello," + " World" + "!"

创建格式化字符串
我们知道输出格式化数字可以使用 printf() 和 format() 方法。

String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。

String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不仅仅是用于一次打印输出。

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

请添加图片描述
上图是字符串的一些用法，就不多赘述了，可以自己试验一下，或者去官方的API中详细了解一下。

Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
在这里插入图片描述
在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
StringBuffer 方法
在这里插入图片描述

Java 数组

Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。
声明数组变量

dataType[] arrayRefVar;   // 首选的方法
 
或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
在Java中常用的数组声明方法

double[] myList;         // 首选的方法
 
或
 
double myList[];         // 效果相同，但不是首选方法

创建数组
创建数组方法如下：

arrayRefVar = new dataType[arraySize];

另一种方法创建

dataType[] arrayRefVar = {value0, value1, ..., valuek};

示例：

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

输出结果：

总和为： 11367.373

下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素，它的下标从 0 到 9。
在这里插入图片描述

java的日期和时间

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
第一个构造函数使用当前日期和时间来初始化对象。

Date( )

第二个构造函数接收一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数。

Date(long millisec)

对象创建完成之后，就可以调用下面的各种方法
在这里插入图片描述
获取当前日期时间
使用 Date 对象的 toString() 方法来打印当前日期和时间

import java.util.Date;
  
public class DateDemo {
   public static void main(String[] args) {
       // 初始化 Date 对象
       Date date = new Date();
        
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

上述代码就是时间获取的代码示例，大家可以自己在编译环境中尝试一下，结果就不给大家演示了。
Java 休眠(sleep)
重点哦
sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。

你可以让程序休眠一毫秒的时间或者到您的计算机的寿命长的任意段时间。例如，下面的程序会休眠3秒：

import java.util.\*;
  
public class SleepDemo {
   public static void main(String[] args) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(1000\*3);   // 休眠3秒
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) { 
          System.out.println("Got an exception!"); 
      }
   }
}

Java 正则表达式

正则表达式一般用来匹配文本搜索文本。
正则表达式实例
在这里插入图片描述
java.util.regex 包主要包括以下三个类：

Pattern 类： pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
PatternSyntaxException：PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

import java.util.regex.\*;
 
class RegexExample1{
   public static void main(String[] args){
      String content = "I am coder " +
        "from csdn.com.";
 
      String pattern = ".\*csdn.\*";
 
      boolean isMatch = Pattern.matches(pattern, content);
      System.out.println("字符串中是否包含了 'csdn' 子字符串? " + isMatch);
   }
}

输出结果：

字符串中是否包含了 'csdn' 子字符串? true

捕获组
捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，“o”，和"g"。

框架相关

原生JS虽能实现绝大部分功能，但要么就是过于繁琐，要么就是存在缺陷，故绝大多数开发者都会首选框架开发方案。现阶段较热门是React、Vue两大框架，两者工作原理上存在共通点，也存在一些不同点，对于校招来说，不需要两个框架都学得特别熟，一般面试官会针对你简历中写的框架进行提问。

在框架方面，生命周期、钩子函数、虚拟DOM这些基本知识是必须要掌握的，在学习的过程可以结合框架的官方文档

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

Vue框架

知识要点：
1. vue-cli工程
2. vue核心知识点
3. vue-router
4. vuex
5. http请求
6. UI样式
7. 常用功能
8. MVVM设计模式

React框架

知识要点：
1. 基本知识
2. React 组件
3. React Redux
4. React 路由

g pattern = “.*csdn.*”;

  boolean isMatch = Pattern.matches(pattern, content);
  System.out.println("字符串中是否包含了 'csdn' 子字符串? " + isMatch);

}
}


输出结果：

字符串中是否包含了 ‘csdn’ 子字符串? true


**捕获组**  
 捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。


例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，“o”，和"g"。




##### 框架相关

原生JS虽能实现绝大部分功能，但要么就是过于繁琐，要么就是存在缺陷，故绝大多数开发者都会首选框架开发方案。现阶段较热门是React、Vue两大框架，两者工作原理上存在共通点，也存在一些不同点，对于校招来说，不需要两个框架都学得特别熟，一般面试官会针对你简历中写的框架进行提问。

在框架方面，**生命周期、钩子函数、虚拟DOM这些基本知识是必须要掌握的**，在学习的过程可以结合框架的官方文档

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/topics/618166371)**

**Vue框架**

>**知识要点：**
>**1. vue-cli工程**
>**2. vue核心知识点**
>**3. vue-router**
>**4. vuex**
>**5. http请求**
>**6. UI样式**
>**7. 常用功能**
>**8. MVVM设计模式**

[外链图片转存中...(img-vCbx7d8g-1714516879880)]


**React框架**

>**知识要点：**
>**1. 基本知识**
>**2. React 组件**
>**3. React Redux**
>**4. React 路由**

[外链图片转存中...(img-Y4S3A2SU-1714516879880)]