Java入门1: 基础语法

已于 2024-06-18 00:16:15 修改
阅读量688 收藏 29
点赞数 25
分类专栏： Java入门 文章标签： java 开发语言
于 2024-05-13 23:45:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silencewx1005/article/details/138824501
版权


Java入门1: 基础语法

MangoGO 芒狗狗

目录

1 基础语法

1.1 Hello World

  每门语言学习前，都会有一个 HelloWorld 的示例，Java 当然也不例外。Java 中所有的代码都必须包含在 class 中，main 方法是程序的入口，并且 Java 是区分大小写的。
  我们创建 HelloWorld.java ，内容如下：

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

  执行下面shell命令进行编译：

!javac HelloWorld.java

  会在同级目录下生成对应 class 文件。执行下面 shell 命令进行运行：

!java HelloWorld

Hello World!

1.2 常量

  常量代表程序运行过程中不能改变的值。我们也可以把它们理解为特殊的变量，只是它们在程序的运行过程中是不允许改变的。

  Java 中的 final 关键字可以用于声明属性（常量），方法和类。当 final 修饰属性时，代表该属性一旦被分配内存空间就必须初始化，它的含义是“这是无法改变的”或者“终态的”。在变量前面添加关键字 final 即可声明一个常量。在 Java 编码规范中，要求常量名必须大写。

// final 数据类型 常量名 = 值;
final double PI = 3.14;

  或者先声明变量，再进行赋值：

final int FINAL_VARIABLE;
FINAL_VARIABLE = 100;

  创建 FinalVar.java 文件，并编译运行。

public class FinalVar {
    public static void main(String[] args){
        final String FINAL_STRING = "MangoGO";
        System.out.println(FINAL_STRING);
    }
}

!java FinalVar.java

MangoGO

1.3 数据类型

  Java 中一共八种基本数据类型，下表列出了基本数据类型的数据范围、存储格式、默认值和包装类型等。

数据类型默认值存储格式数据范围包装类型
short02 个字节-32,768 到 32,767Short
int04 个字节-2,147,483,648 到 2,147,483,647Integer
byte01 个字节-128 到 127Byte
char空2 个字节Unicode 的字符范围：\u0000（即为 0）到 \uffff（即为 65,535）Character
long0L 或 0l8 个字节-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807Long
float0.0F 或 0.0f4 个字节32 位 IEEEE-754 单精度范围Float
double0.0 或 0.0D(d)8 个字节64 位 IEEE-754 双精度范围Double
booleanfalse1 位true 或 falseBoolean
  1. 整数
    byte、short、int、long 四种基本数据类型表示整数，需要注意的是 long 类型，使用 long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。
  2. 浮点数
    float 和 double 类型表示浮点数，即可以表示小数部分。需要注意的是 float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。
  3. char 类型
    char 类型用于表示单个字符。需要将字符用单引号括起来char a = ‘a’，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = ‘\u0061’。
  4. boolean 类型
    boolean 类型（布尔类型）用于表示真值 true或者假值 false，Java 中布尔值不能和整数类型或者其它类型互相转换。

1.4 String

  Java 中使用 String 类来定义一个字符串，字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。String 对象的初始化格式有如下两种：

String s0 = "abc";

String s1 = new String("abd")

  String 类具有丰富的方法，比如计算字符串的长度、连接字符串、比较字符串、提取字符串等等。

  （1）字符串长度
  调用方法：字符串标识符.length(); 返回一个 int 类型的整数（字符串中字符数，中文字符也是一个字符）。例如：

String s1 = "abc";
String s2 = "Java语言";
int len1 = s1.length();  // 3
int len2 = s2.length();  // 6

  （2）字符串比较

  equals() 方法，该方法的作用是判断两个字符串对象的内容是否相同。如果相同则返回 true，否则返回 false。

  equals() 方法比较是从第一字符开始，一个字符一个字符依次比较。

  如果想忽略掉大小写关系，比如：java 和 Java 是一样的，可以调用 equalsIgnoreCase() 方法：

String s = new String("Java");
String m = "java";
System.out.println(s.equals(m));  // false
System.out.println(s.equalsIgnoreCase(m));  // true

  而使用 “==” 比较的是两个对象在内存中存储的地址是否一样。

String s1 = "abc";
String s2 = new String("abc");
boolean b = (s1 == s2);  // false

  （3）字符串连接
  字符串连接有两种方法：

  1. 使用 +，比如 String s = "Hello " + “World!”。
  2. 使用 String 类的 concat() 方法。
String s0 = new String("Hello ");
String s1 = "World" + "!";   // +号连接
String s2 = s0.concat(s1);   // concat()方法连接
System.out.println(s2);

  （4）字符串索引

  charAt() 方法的作用是按照索引值（规定字符串中第一个字符的索引值是 0，第二个字符的索引值是 1，依次类推），获得字符串中的指定字符。

String s = "abc";
char c = s.charAt(1);  // 6

  （5）字符串提取

方法返回值功能描述
indexOf(char ch)int搜索字符 ch 第一次出现的索引
indexOf(String value)int搜索字符串 value 第一次出现的索引
lastIndexOf(char ch)int搜索字符 ch 最后一次出现的索引
lastIndexOf(String value)int搜索字符串 value 最后一次出现的索引
substring(int index)String提取从位置索引开始到结束的字符串
substring(int beginindex, int endindex)String提取 beginindex 和 endindex 之间的字符串部分
trim()String返回一个前后不含任何空格的调用字符串的副本
public class StringTest {
    public static void main(String[] args){
        String s0 = new String("Java");
        String s1 = "java";
        System.out.println("用equals()比较，java和Java结果为"+s0.equals(s1));
        System.out.println("用equalsIgnoreCase()比较，java和Java结果为"+s0.equalsIgnoreCase(s1));

        String s2 = "abcdefabc";
        System.out.println("字符串s2："+s2);
        System.out.println("字符a第一次出现的位置为"+s2.indexOf('a'));
        System.out.println("字符串bc第一次出现的位置为"+s2.indexOf("bc"));
        System.out.println("字符a最后一次出现的位置为"+s2.lastIndexOf('a'));
        System.out.println("从位置3开始到结束的字符串"+s2.substring(3));
        System.out.println("从位置3开始到6之间的字符串"+s2.substring(3,6));
    }
}

!java StringTest.java

用equals()比较，java和Java结果为false
用equalsIgnoreCase()比较，java和Java结果为true
字符串s2：abcdefabc
字符a第一次出现的位置为0
字符串bc第一次出现的位置为1
字符a最后一次出现的位置为6
从位置3开始到结束的字符串defabc
从位置3开始到6之间的字符串def

1.5 StringBuilder

  String 是无法被修改的，对 String 的修改，其实是新建了一个 String 对象。如果需要修改字符串的内容，可以使用 StringBuilder。它相当于一个存储字符的容器。

  初始化格式有以下三种：

// 构造一个不包含任何字符且初始容量为 16 的 StringBuilder
StringBuilder a = new StringBuilder();

// 构造一个不包含任何字符且容量为 cap 的 StringBuilder
StringBuilder b = new StringBuilder(int cap);
// 构造一个 StringBuilder，内容初始化为 str
StringBuilder  c = new StringBuilder(String str);

public class StringBuilderTest {
    public static void main(String[] args){
        StringBuilder s1 = new StringBuilder();
        s1.append("java");
        StringBuilder s2 = new StringBuilder(5);
        StringBuilder s3 = new StringBuilder("MangoGO");
        System.out.println("s1:" + s1.toString() + "\tcap:" + s1.capacity());
        System.out.println("s2:" + s2.toString() + "\tcap:" + s2.capacity());
        System.out.println("s3:" + s3.toString() + "\tcap:" + s3.capacity());
    }
}

!java StringBuilderTest.java

s1:java	cap:16
s2:	cap:5
s3:MangoGO	cap:23
s2:MangoGO	cap:12

  其中 s3 的 capacity 为 23 是因为初始容量 16 + MangoGO 的长度 7。

  StringBuilder 常用方法：

方法返回值功能描述
deleteCharAt(int index)StringBuilder删除 StringBuilder 中指定位置的 char
indexOf()int返回子字符串首次出现在该字符串中的索引
capacity()int返回当前容量
charAt(int index)char返回序列中指定索引的 char 值
toString()String返回序列数据的 string 格式

1.6 运算符

算术运算符名称描述类型举例
+加法相加运算符两侧的值双目运算符a + b 等于 8
-减法左操作数减去右操作数双目运算符a - b 等于 2
*乘法相乘操作符两侧的值双目运算符a * b 等于 15
/除法左操作数除以右操作数双目运算符a / b 等于 1
%取余左操作数除右操作数的余数双目运算符a % b 等于 2
++自增操作数的值增加 1单目运算符++i（或 i++） 等于 2
--自减操作数的值减少 1单目运算符--i（或 i--） 等于 0

  其中，自增 (++) 和自减 (–) 运算符有两种写法：前缀（++i,–i）和后缀（i++,i–）。

  • 前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
  • 后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算
public class ArithmeticOperation {
    public static void main(String args[]) {
        int a = 5;
        int b = 3;
        int c = 3;
        int d = 3;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
        System.out.println("a++ = " + (a++));
        System.out.println("++a = " + (++a));
        System.out.println("b-- = " + (b--));
        System.out.println("--b = " + (--b));
        System.out.println("c++ = " + (c++));
        System.out.println("++d = " + (++d));
    }
}

!java ArithmeticOperation.java

a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4

1.7 位运算符

  Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。位运算时先转换为二进制，再按位运算。

  表格中的例子中，变量 a 的值为 60（二进制：00111100），变量 b 的值为 13（二进制：00001101）：

位运算符名称描述举例
&按位与如果相对应位都是 1，则结果为 1，否则为 0（a＆b），得到 12，即 0000 1100
丨按位或如果相对应位都是 0，则结果为 0，否则为 1（ a 丨 b ）得到 61，即 0011 1101
^按位异或如果相对应位值相同，则结果为 0，否则为 1（a^b）得到 49，即 0011 0001
~按位补翻转操作数的每一位，即 0 变成 1，1 变成 0（~a）得到 -61，即 1100 0011
<<按位左移左操作数按位左移右操作数指定的位数a<<2 得到 240，即 1111 0000
>>按位右移左操作数按位右移右操作数指定的位数a>>2 得到 15 即 1111
>>>按位右移补零左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充a>>>2 得到 15 即 0000 1111
public class BitOperation {
    public static void main(String[] args) {
        int a = 60;
        int b = 13;
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));
        System.out.println("a << 2 = " + (a << 2));
        System.out.println("a >> 2 = " + (a >> 2));
        System.out.println("a >>> 2 = " + (a >>> 2));
    }
}

!java BitOperation.java

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

1.8 逻辑运算符

  逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。

  表格中的例子中，假设布尔变量 a 为真（true），变量 b 为假（false）：

逻辑运算符名称描述类型举例
&& 或 &与当且仅当两个操作数都为真，条件才为真双目运算符(a && b) 或 (a & b) 为假
| | 或 |或两个操作数任何一个为真，条件为真双目运算符(a || b) 或 (a | b) 为真
!非用来反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将得到假单目运算符(!a）为假
^异或如果两个操作数逻辑相同，则结果为假，否则为真双目运算符(a ^ b) 为真
public class LogicOperation {
    public static void main(String args[]) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a && b));
        System.out.println("a || b = " + (a || b));
        System.out.println("!a = " + (!a));
        System.out.println("a ^ b = " + (a ^ b));
    }
}

!java LogicOperation.java

a && b = false
a || b = true
!a = false
a ^ b = true

1.9 关系运算符

关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。

比较运算符名称描述举例
==等于判断两个操作数的值是否相等，如果相等则条件为真(a == b） 为 false
!=不等于判断两个操作数的值是否相等，如果值不相等则条件为真(a != b) 为 true
>大于判断左操作数的值是否大于右操作数的值，如果是那么条件为真(a > b) 为 false
<小于判断左操作数的值是否小于右操作数的值，如果是那么条件为真(a < b) 为 true
>=大于等于判断左操作数的值是否大于或等于右操作数的值，如果是那么条件为真(a >= b) 为 false
<=小于等于判断左操作数的值是否小于或等于右操作数的值，如果是那么条件为真(a <= b) 为 true
public class RelationalOperation {
    public static void main(String[] args) {
        int a = 3;
        int b = 5;
        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));
        System.out.println("(a > b ? a : b) = " + (a > b ? a : b));
    }
}

!java RelationalOperation.java

a == b: false
a != b: true
a > b: false
a < b: true
a >= b: false
a <= b: true
(a > b ? a : b) = 5

1.10 练习：计算数字和

  需要实现以下需求：

  • 获取控制台输入的两个整型参数。
  • 输出两个整型参数和。

  比如输入 3 和 4 对应输出 7。

import java.util.Scanner;

public class Sum {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int x1 = in.nextInt();
        int x2 = in.nextInt();

        int sum = x1 + x2;
        System.out.println("The sum of " + x1 + " and " + x2 + " is " + sum);
    }
}

  Jupyter执行java代码不支持从键盘获取输入，就不演示了。

1.11 关键字和语句

  • 关键字

  Java 的关键字对 Java 的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。

  • 方法

  Java 中的方法，可以将其看成一个功能的集合，它们是为了解决特定问题的代码组合。

  方法的定义语法：

访问修饰符 返回值类型 方法名(参数列表) {
    方法体;
}

  例如：

public void functionName(Objetc arg){
    System.out.println("Hello World.")
}

  在上面的语法说明中：

  1. 访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default） ，其中 public 表示该方法可以被其他任何代码调用。

  2. 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void （代表无类型）；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值。

  3. 方法名：是方法的名字，必须使用合法的标识符。

  4. 参数列表：是传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

  5. 方法体：方法体包含具体的语句，定义该方法的功能。

  当方法定义好之后，需要调用才可以生效，我们可以通过 main 方法（main 方法是 Java 程序的入口，所以需要用它来调用）来调用它，比如：

public class MethodDemo {
    public static void main(String[] args) {
        method();
    }
    
    public static void method() {
        System.out.println("方法被调用");
    }
}

!java MethodDemo.java

方法被调用

1.12 流程控制

  常见主要为：条件语句、循环语句、跳转语句。

  1. 条件语句

  语法：

if (条件表达式) {
    条件成立时执行的代码;
}

  或者：

if (条件表达式) {
    条件成立时执行的代码;
}
else {
    条件不成立时执行的代码;
}

  或者：

if (条件表达式) {
    代码块1;
}
else if {
    代码块2;
}
···
else {
    代码块3;
}

public class ScoreJudge {
    public static void main(String[] args) {
        int score = 78;
        if (score >= 60) {
            if (score >= 80) {
                if (score >= 90) {
                    System.out.println("优秀");
                } else {
                    System.out.println("良好");
                }
            } else {
                System.out.println("及格");
            }
        } else {
            System.out.println("不及格");
        }
    }
}

!java ScoreJudge.java

及格
  1. switch 语句
switch(表达式) {
    case 值1:
        语句块1;
        break;
    case 值2:
        语句块2;
        break;
    ···
    default:
        默认语句块;
}

```java
public class Draw {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("恭喜你，获得了一等奖");
                break;
            case 2:
                System.out.println("恭喜你，获得了二等奖");
                break;
            case 3:
                System.out.println("恭喜你，获得了三等奖");
            default:
                System.out.println("很遗憾，你没有获奖");
        }
    }
}

!java Draw.java

恭喜你，获得了二等奖
  1. while 和 do-while 语句

  while 语法：

while(条件表达式) {
    循环体;
}

  do-while 语法：

do {
    循环体;
} while (条件表达式);

public class SumOfEven {
    public static void main(String[] args) {
        int i1 = 1, i2 = 1;
        int sum1 = 0, sum2 = 0;

        while (i1 <= 1000) {
            if (0 == i1 % 2) {
                sum1 += i1;
            }
            i1++;
        }
        System.out.println("用while，1到1000中，所有偶数的和为：" + sum1);

        do {
            if (0 == i2 % 2) {
                sum2 += i2;
            }
            i2++;
        } while (i2 <= 1000);
        System.out.println("用do-while，1到1000中，所有偶数的和为：" + sum2);
    }
}

!java SumOfEven.java

用while，1到1000中，所有偶数的和为：250500
用do-while，1到1000中，所有偶数的和为：250500
  1. for 语句

  for 语法：

for (初始化表达式; 条件表达式; 迭代表达式) {
    循环体;
}

public class SumOfEvenWithFor {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 1000; i++) {
            if (0 == i % 2) {
                sum += i;
            }
        }
        System.out.println("用for循环，1到1000中，所有偶数的和为：" + sum);
    }
}

!java SumOfEvenWithFor.java

用for循环，1到1000中，所有偶数的和为：250500
  1. 跳转语句

  break 关键字经常用在条件和循环语句中，用来跳出循环语句。

  continue关键字的作用是跳过循环体中剩余的语句执行下一次循环。

public class Jump {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println("循环第" + i + "次");
            if (0 == i % 3) {
                break;
            }
            if (0 == i % 5) {
                System.out.println("我进来了！");
            }
        }

        for (int i = 1; i <= 10; i++) {
            if (0 == i % 2) {
                continue;
            }
            System.out.println(i);
        }
    }
}

!java Jump.java

循环第1次
循环第2次
循环第3次
1
3
5
7
9

1.13 数组

  数组就是相同数据类型的元素按一定顺序排列的集合。可以把它看成一个大的盒子，里面按顺序存放了多个数据类型相同的数据。

  数组中的元素都可以通过下标来访问，下标从 0 开始，到数组长度 -1 结束。

  数组的声明语法：

数据类型[] 数组名;

  例如：

int[] ages;
char[] symbols;
String[] names;

  声明数组后，需要为数组分配内存空间，也就是定义多大的数组：

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

  数组长度就是数组最多可存放元素的个数。可以在数组声明的时候初始化数组，或者在声明时就为它分配好空间，这样就不用再为数组分配空间:

int [] ages = {12, 21, 22, 32, 45}; //声明并初始化一个整型数组，有5个元素
char [] symbols = new char[10]; //声明并分配一个长度为10的字符数组

  分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的：

age[0] = 12;

  Java 中可以将一个数组赋值给另一个数组，如:

int[] arr1 = {1, 2, 3};
int[] arr2;
arr2 = arr1;

  这里只是复制了一个引用，即 a2 和 a1 是相同数组的不同名称。

public class ArrayTest {
    public static void main(String[] args) {
        int [] a1 = {1, 2, 3};
        int [] a2;
        a2 = a1;
        for (int i = 0; i < a2.length; i++) {
            a2[i]++;
        }
        for (int i = 0; i < a1.length; i++) {
            System.out.println(a1[i]);
        }
    }
}

!java ArrayTest.java

2
3
4

  for 语句在数组内可以使用特殊简化版本，在遍历数组、集合时，foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思:

for (元素类型 变量名 : 数组名) {
    循环体;
}

public class JudgePrime {
    public static void main(String[] args) {
        int[] ages = {12, 18, 9, 33, 45, 60};
        int i = 1;
        for (int age : ages) {
            Sys1tem.out.println("数组中的第“ + i +"个元素是: " + age);
            i++;
        }
    }
}

!java JudgePrime.java

数组中的第1个元素是: 12
数组中的第2个元素是: 18
数组中的第3个元素是: 9
数组中的第4个元素是: 33
数组中的第5个元素是: 45
数组中的第6个元素是: 60

  二维数组可以看成是一间有座位的教室，座位一般用第几排的第几个进行定位，每一个座位都有一个行和一个列的属性，一排的座位相当于一个一维数组，所以可以将二维数组简单的理解为是一种“特殊”的一维数组，它的每个数组空间中保存的是一个一维数组。

数据类型 [][] 数组名 = new 数据类型[行数][列数];

//或者
数据类型[][] 数组名;
数组名 = new 数据类型[行数][列数];

//或者
数据类型 [][] 数组名 = {
    {值11, 值12, 值13, ...},
    {值21, 值22, 值23, ...},
    ···
}

//二维数组赋值与访问也是通过下标进行
数组名[行索引][列索引] = 值;

public class ArrayTest2 {
    public static void main(String[] args) {
        String[][] name = {{"xiaoming", "xiaohua", "xiaohong"},
            {"zhangsan", "lisi", "wangwu"}};
        for (int i = 0; i < name.length; i++) {
            for (int j = 0; j < name[0].length; j++) {
                System.out.println(name[i][j]);
            }
        }
    }
}

!java ArrayTest2.java

xiaoming
xiaohua
xiaohong
zhangsan
lisi
wangwu

1.14 用户输入操作

  在 Java 中使用 java.util 包下的Scanner 类来获取用户的输入。使用 import java.util.Scanner; 即可导入 Scanner，使用方法示例：

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        System.out.println(s);

        while (!in.hasNext("exit")) {
            System.out.println(in.nextLine());
        }
        in.close();
    }
}

  由于jupyter中不能接收键盘输入，故不做展示。

参考代码

  GitCode

系列文章专栏：
Java入门

  1 基础部分
  2 面向对象
  3 常用类
  4 常用类
  5 异常
  6 函数式编程

  持续更新中

  7 IO
  8 网络编程
  9 多线程
  10 JDBC
  11 反射
  12 正则表达式
  13 设计模式

MangoGO芒狗狗
关注
  • 25
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java入门之~Java基础语法
Ara-追着风跑
03-12 7036
Java入门之基础语法篇，收藏学起来
Java入门指南：基础概述
栗筝i的博客
11-13 4493
Java 是由 Sun 公司的 James Gosling 团队于 1991 年研发的一门面向对象的编程语言。最初命名为 Oak，于 1995 年更名为 Java 并开始推广。随着互联网的崛起，Java 逐渐成为最重要的 Web 应用开发语言之一。Java 是一门面向对象的高级编程语言，它吸收了 C 语言的优点，同时摒弃了 C 语言中难以理解的多继承、指针等概念，使得 Java 语言既功能强大又简单易用。
Java基础篇 | Java基础语法
热门推荐
分享思想，留下痕迹。
05-31 1万+
Java以前自学过一写，现在工作了，时间太久有一些知识都遗忘了，今天开始就更新Java了，想着把之前的Java基础知识捡起来；从最基础的开始，打好Java基础，便于以后复习。也欢迎大家跟我一起复习。Java中，字面量指的是在程序中直接使用的数据，字面量是Java中最基本的表达式，不需要进行计算或转换，直接使用即可。基本数据类型整数类型：包括byteshortint和long四种类型，用于表示整数。浮点类型：包括float和double两种类型，用于表示带小数点的数值。boolean。
第一章java入门：Markdown语法
wintermiya的博客
11-09 1900
Markdown语法是一种纯文本格式的标记语言，它可以使用普通的文本编辑器进行编写，通过简单的标记语法，使普通的文本内容具有一定的格式。
java入门之java基础语法.docx
06-28
java入门之java基础语法.docx
python入门之基础语法学习笔记
12-20
在学习Python的基础语法时，有几个关键概念需要了解。 首先，关于Python的中文编码问题。在处理包含中文字符的Python文件时，由于Python默认使用ASCII编码，这可能导致在读取或打印汉字时出现错误。为了解决这个...
Java自学视频教程-JavaSE基础-Java基础语法-05、Java入门程序：常见问题.mp4
08-23
Java是一种编程语言，被特意设计用于互联网的分布式环境。Java具有类似于C++语言的“形式和感觉”，但它要比C++语言更易于使用，而且在编程时彻底采用了一种“以对象为导向”的方式。 使用Java编写的应用程序，既...
JAVA基础语法格式入门
12-26
理解和掌握Java的基础语法格式是成为合格Java开发者的第一步，这包括注释的使用、关键字和标识符的理解，以及如何编写和运行第一个Java程序。随着技术的不断发展，Java将继续扮演着至关重要的角色。
Java入门基础.pdf
11-30
"Java入门基础.pdf" 本文档是Java入门基础的学习资源，涵盖Java开发入门、Java编程基础、面向对象、多线程、集合框架、IO流、网络编程、安全加密、反射机制、新特性和内存管理等多方面的内容。 Java开发入门 * ...
redis+spring面试题
github_36510643的博客
07-21 268
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 155
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 490
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1130
JVM-垃圾回收与内存分配
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1154
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1059
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 507
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 542
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 476
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
Java入门教程：基础语法与开发环境
"Java基本语法第一季，涵盖了Java语言的基础概念、开发环境的搭建、编程工具的使用，以及关键字、标识符、变量等核心语法知识。" 在学习Java的过程中，首先要了解Java的基本运行机制。Java源代码文件通常以`.java`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MangoGO芒狗狗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值