[{"data":1,"prerenderedAt":1547},["ShallowReactive",2],{"content:\u002F2026\u002Fjava":3,"surround:\u002F2026\u002Fjava":1536},{"id":4,"title":5,"body":6,"categories":1513,"date":1515,"description":1516,"draft":1517,"extension":1518,"image":1519,"meta":1520,"navigation":1522,"path":1523,"permalink":1524,"published":1524,"readingTime":1525,"recommend":1524,"references":1524,"seo":1530,"sitemap":1531,"stem":1532,"tags":1533,"type":1534,"updated":1515,"__hash__":1535},"content\u002Fposts\u002F2026\u002FJava基础.md","Java基础",{"type":7,"value":8,"toc":1421},"minimark",[9,14,39,43,48,51,55,61,71,74,82,86,92,98,102,108,112,116,261,265,276,282,286,291,294,300,304,311,317,320,326,330,333,339,342,348,352,356,359,365,367,373,377,379,385,387,393,397,400,406,408,414,418,421,424,428,435,438,444,451,454,460,467,470,476,480,486,490,494,500,504,507,509,515,519,522,524,530,534,537,541,548,550,556,560,573,577,588,592,595,603,614,621,632,636,744,748,752,758,762,813,817,823,827,830,902,906,958,960,964,967,973,977,981,990,994,1007,1011,1022,1026,1032,1036,1042,1046,1052,1056,1062,1066,1072,1078,1082,1088,1094,1098,1104,1110,1114,1117,1123,1126,1130,1134,1165,1169,1172,1215,1219,1232,1235,1241,1244,1248,1258,1269,1275,1279,1286,1292,1298,1367,1371,1385,1391,1397,1401,1405,1409,1413,1417],[10,11,13],"h2",{"id":12},"java-简介","Java  简介",[15,16,17,21,22,26,27,30,31,34,35,38],"p",{},[18,19,20],"strong",{},"Java"," 是一种面向对象、跨平台、强类型的高级编程语言。通常是通过",[23,24,25],"code",{"code":25},"javac","将",[23,28,29],{"code":29},".java","源码编译成",[23,32,33],{"code":33},".class","字节码，再交由",[23,36,37],{"code":37},"JVM","运行。",[10,40,42],{"id":41},"java-包和导包","Java  包和导包",[44,45,47],"h3",{"id":46},"_1-源文件命名","1.  源文件命名",[15,49,50],{},"Java源文件命名要严格和文件中类的名字相同，且区分大小写。",[44,52,54],{"id":53},"_2-package","2.  package",[15,56,57,60],{},[18,58,59],{},"package","是对Java文件进行分类管理，写在源文件首行，通常是该文件的路径，例如：",[62,63,69],"pre",{"className":64,"code":66,"language":67,"meta":68},[65],"language-text","com\n└── test\n    └── demo\n        └── Main.java\n","text","",[23,70,66],{"__ignoreMap":68},[15,72,73],{},"那么Main.java就应该是",[62,75,80],{"className":76,"code":78,"language":79,"meta":68},[77],"language-java","package com.test.demo;\npublic class Main{\n    public static void main(String[] args){\n        System.out.println(\"Hello\");\n    }\n}\n","java",[23,81,78],{"__ignoreMap":68},[44,83,85],{"id":84},"_3-import","3.  import",[15,87,88,91],{},[18,89,90],{},"import","是用来导入已经写好的类，可以导入具体的类或者某个包下所有的类。",[62,93,96],{"className":94,"code":95,"language":79,"meta":68},[77],"import com.test.demo.Main;\t\t\t\t\t\t\t\t \u002F\u002F导入Main类\nimport com.test.demo.*;\t\t\t\t\t\t\t\t\t \u002F\u002F导入demo包中所有的类\n",[23,97,95],{"__ignoreMap":68},[10,99,101],{"id":100},"java-注释","Java  注释",[62,103,106],{"className":104,"code":105,"language":79,"meta":68},[77],"class Demo {\n\n\u002F\u002F 这是一个单行注释\n\n\u002F*\n这是一个多行注释\n可以用来注释多行代码\n*\u002F\n\n\u002F**\n * 这是一个文档注释示例\n * 它通常包含有关类、方法或字段的详细信息\n *\u002F\n\n    System.out.println(\"Hello\");\n}\n",[23,107,105],{"__ignoreMap":68},[10,109,111],{"id":110},"java-基础语法","Java  基础语法",[44,113,115],{"id":114},"_1-基本数据类型","1.  基本数据类型",[117,118,119,135],"table",{},[120,121,122],"thead",{},[123,124,125,129,132],"tr",{},[126,127,128],"th",{},"类型",[126,130,131],{},"默认值",[126,133,134],{},"示例",[136,137,138,154,168,182,197,212,227,244],"tbody",{},[123,139,140,146,149],{},[141,142,143],"td",{},[18,144,145],{},"byte",[141,147,148],{},"0",[141,150,151],{},[23,152,153],{"code":153},"byte a = 44",[123,155,156,161,163],{},[141,157,158],{},[18,159,160],{},"short",[141,162,148],{},[141,164,165],{},[23,166,167],{"code":167},"short a = 33",[123,169,170,175,177],{},[141,171,172],{},[18,173,174],{},"int",[141,176,148],{},[141,178,179],{},[23,180,181],{"code":181},"int a = 11",[123,183,184,189,192],{},[141,185,186],{},[18,187,188],{},"long",[141,190,191],{},"0L",[141,193,194],{},[23,195,196],{"code":196},"long a = 22L",[123,198,199,204,207],{},[141,200,201],{},[18,202,203],{},"float",[141,205,206],{},"0.0F",[141,208,209],{},[23,210,211],{"code":211},"float a = 55.6F",[123,213,214,219,222],{},[141,215,216],{},[18,217,218],{},"double",[141,220,221],{},"0.0D",[141,223,224],{},[23,225,226],{"code":226},"double a = 11.6D",[123,228,229,234,239],{},[141,230,231],{},[18,232,233],{},"boolean",[141,235,236],{},[18,237,238],{},"false",[141,240,241],{},[23,242,243],{"code":243},"boolean a = true",[123,245,246,251,256],{},[141,247,248],{},[18,249,250],{},"char",[141,252,253],{},[18,254,255],{},"\\u0000",[141,257,258],{},[23,259,260],{"code":260},"char a = 'p'",[44,262,264],{"id":263},"_2-引用类型","2.  引用类型",[15,266,267,268,271,272,275],{},"在java中，引用类型的变量类似于C++中的指针，引用变量保存的是 ",[18,269,270],{},"对象的引用"," 。引用类型默认值是",[18,273,274],{},"null","。类和数组等都是引用类型。",[62,277,280],{"className":278,"code":279,"language":79,"meta":68},[77],"int[] arr = {1, 2, 3};                                         \n\nString str = \"Hello\";\nStudent stu = new Student();\n",[23,281,279],{"__ignoreMap":68},[44,283,285],{"id":284},"_3-数组","3.  数组",[287,288,290],"h4",{"id":289},"_1-声明数组","1.  声明数组",[15,292,293],{},"在程序中首先必须声明数组变量，才能使用数组。下面是声明数组变量的语法：",[62,295,298],{"className":296,"code":297,"language":79,"meta":68},[77],"dataType[] arrayRefVar;\nint[] a;\n",[23,299,297],{"__ignoreMap":68},[287,301,303],{"id":302},"_2-创建数组","2.  创建数组",[15,305,306,307,310],{},"在java中，用",[18,308,309],{},"new","去创建数组。下面是创建数组的语法：",[62,312,315],{"className":313,"code":314,"language":79,"meta":68},[77],"arrayRefVar = new dataType[arraySize];                             \u002F\u002F 先new了一个数组，然后赋值给变量\n",[23,316,314],{"__ignoreMap":68},[15,318,319],{},"当然也可以直接声明并创建数组。",[62,321,324],{"className":322,"code":323,"language":79,"meta":68},[77],"dataType[] arrayRefVar = new dataType[arraySize];\n\ndataType[] arrayRefVar = {value0, value1, ..., valuek};\n",[23,325,323],{"__ignoreMap":68},[287,327,329],{"id":328},"_3-for-each-循环","3.  For-Each 循环",[15,331,332],{},"JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。语法是：",[62,334,337],{"className":335,"code":336,"language":79,"meta":68},[77],"for (type element : array)\n{\n    System.out.println(element);\n}\n",[23,338,336],{"__ignoreMap":68},[15,340,341],{},"实例：",[62,343,346],{"className":344,"code":345,"language":79,"meta":68},[77],"public class TestArray {\n   public static void main(String[] args) {\n      double[] myList = {1.9, 2.9, 3.4, 3.5};\n \n      \u002F\u002F 打印所有数组元素\n      for (double element: myList) {\n         System.out.println(element);\n      }\n   }\n}\n",[23,347,345],{"__ignoreMap":68},[44,349,351],{"id":350},"_4-循环结构","4.  循环结构",[287,353,355],{"id":354},"_1-for循环","1.  For循环",[15,357,358],{},"语法：",[62,360,363],{"className":361,"code":362,"language":79,"meta":68},[77],"for(初始化; 布尔表达式; 更新) {\n    \u002F\u002F代码语句\n}\n",[23,364,362],{"__ignoreMap":68},[15,366,341],{},[62,368,371],{"className":369,"code":370,"language":79,"meta":68},[77],"public class Test {\n    public static void main(String[] args){\n        for(int i = 0; i \u003C 10; i++){\n            System.out.println( i );\n        }\n    }\n}\n",[23,372,370],{"__ignoreMap":68},[287,374,376],{"id":375},"_2-while循环","2.  While循环",[15,378,358],{},[62,380,383],{"className":381,"code":382,"language":79,"meta":68},[77],"while( 布尔表达式 ) {\n  \u002F\u002F循环内容\n}\n",[23,384,382],{"__ignoreMap":68},[15,386,341],{},[62,388,391],{"className":389,"code":390,"language":79,"meta":68},[77],"public class Test {\n   public static void main(String[] args) {\n      int x = 10;\n      while( x \u003C 20 ) {\n         System.out.println( x );\n         x++;\n      }\n   }\n}\n",[23,392,390],{"__ignoreMap":68},[287,394,396],{"id":395},"_3-do-while循环","3.  Do-While循环",[15,398,399],{},"do-while循环相比于while循环会先执行一遍循环内容再进入判断。语法：",[62,401,404],{"className":402,"code":403,"language":79,"meta":68},[77],"do {\n       \u002F\u002F代码语句\n}while(布尔表达式);\n",[23,405,403],{"__ignoreMap":68},[15,407,341],{},[62,409,412],{"className":410,"code":411,"language":79,"meta":68},[77],"public class Test {\n   public static void main(String[] args){\n      int x = 10;\n \t  do{\n         System.out.println( x );\n         x++;\n      }while( x \u003C 20 );\n   }\n}\n",[23,413,411],{"__ignoreMap":68},[287,415,417],{"id":416},"_4-break和continue","4.  break和continue",[15,419,420],{},"break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。",[15,422,423],{},"continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中，continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。",[44,425,427],{"id":426},"_5-输出","5.  输出",[287,429,431,432],{"id":430},"_1-systemoutprint","1.  ",[23,433,434],{"code":434},"System.out.print()",[15,436,437],{},"输出，不换行",[62,439,442],{"className":440,"code":441,"language":79,"meta":68},[77],"System.out.print(\"Hello\");\nSystem.out.print(\"World\");\n\n\u002F\u002F输出\nHelloWorld\n",[23,443,441],{"__ignoreMap":68},[287,445,447,448],{"id":446},"_2-systemoutprintln","2.  ",[23,449,450],{"code":450},"System.out.println()",[15,452,453],{},"输出后换行",[62,455,458],{"className":456,"code":457,"language":79,"meta":68},[77],"System.out.println(\"Hello\");\nSystem.out.println(\"World\");\n\n\u002F\u002F输出\nHello\nWorld\n",[23,459,457],{"__ignoreMap":68},[287,461,463,464],{"id":462},"_3-systemoutprintf","3.  ",[23,465,466],{"code":466},"System.out.printf()",[15,468,469],{},"格式化输出",[62,471,474],{"className":472,"code":473,"language":79,"meta":68},[77],"String name = \"Tom\";\nint age = 18;\nSystem.out.printf(\"姓名：%s，年龄：%d\", name, age);\n\n\u002F\u002F输出\n姓名：Tom，年龄：18\n",[23,475,473],{"__ignoreMap":68},[287,477,479],{"id":478},"_4-输出多个内容","4.  输出多个内容",[62,481,484],{"className":482,"code":483,"language":79,"meta":68},[77],"String name = \"Tom\";\nint age = 18;\nSystem.out.println(\"姓名：\" + name + \" 年龄：\" + age);\n\n\u002F\u002F输出\n姓名：Tom 年龄：18\n",[23,485,483],{"__ignoreMap":68},[10,487,489],{"id":488},"java-正则表达式","Java  正则表达式",[44,491,493],{"id":492},"_1-javautilregex-包","1.  java.util.regex 包",[15,495,496,499],{},[23,497,498],{"code":498},"java.util.regex"," 是 Java 标准库中专门用于正则表达式处理的包，主要负责字符串的匹配、查找、替换、分割等操作，该包一共有三个类。",[287,501,503],{"id":502},"_1-pattern-类","1.  Pattern 类：",[15,505,506],{},"Pattern 对象是一个正则表达式的编译表示。",[15,508,341],{},[62,510,513],{"className":511,"code":512,"language":79,"meta":68},[77],"import java.util.regex.Pattern;\n\nPattern pattern = Pattern.compile(\"\\\\d+\");                   \u002F\u002Fpattern类没有构造函数，可以使用静态方法compile()来编译正则表达式。\n\nMatcher m = pattern.matcher(\"123abc\");                       \u002F\u002F创建 Matcher 对象\n\nboolean result = Pattern.matches(\"\\\\d+\", \"12345\");           \u002F\u002F直接判断整个字符串是否匹配\n",[23,514,512],{"__ignoreMap":68},[287,516,518],{"id":517},"_2-matcher-类","2.  Matcher 类：",[15,520,521],{},"Matcher 对象是对输入字符串进行解释和匹配操作的引擎。",[15,523,341],{},[62,525,528],{"className":526,"code":527,"language":79,"meta":68},[77],"import java.util.regex.Matcher;\n\n\u002F\u002F 要求整个字符串都符合正则。matches()\nPattern p = Pattern.compile(\"\\\\d+\");\nMatcher m = p.matcher(\"123\");\nSystem.out.println(m.matches());\n\n\u002F\u002F 查找下一段符合规则的内容。find()\nPattern p = Pattern.compile(\"\\\\d+\");\nMatcher m = p.matcher(\"abc123xyz456\");\nwhile(m.find()){\n    System.out.println(m.group());\n}\n\n\u002F\u002F 返回最近一次匹配到的内容。group()\nMatcher m = p.matcher(\"abc123\");\nm.find();\nSystem.out.println(m.group());\n",[23,529,527],{"__ignoreMap":68},[287,531,533],{"id":532},"_3-patternsyntaxexception-类","3.  PatternSyntaxException 类：",[15,535,536],{},"PatternSyntaxException表示一个正则表达式模式中的语法错误。",[44,538,540],{"id":539},"_2-捕获组","2.  捕获组",[15,542,543,544,547],{},"捕获组是Java 正则表达式中非常重要的概念，用于",[18,545,546],{},"将匹配到的某一部分内容保存起来，以便后续获取或引用","。",[15,549,341],{},[62,551,554],{"className":552,"code":553,"language":79,"meta":68},[77],"import java.util.regex.*;\n\npublic class Test {\n    public static void main(String[] args) {\n\n        Pattern p = Pattern.compile(\"(\\\\d+)\");\n        Matcher m = p.matcher(\"abc123xyz\");\n\n        if (m.find()) {\n            System.out.println(m.group());\n            System.out.println(m.group(1));\n        }\n    }\n}\n\n\u002F\u002F 输出\n123\n123\n\u002F\u002F group()等价于group(0),表示整个正则表达式匹配到的内容。\n    \n\u002F\u002F groupCount()  查看有多少个捕获组。\n\nPattern p = Pattern.compile(\"(\\\\d+)-([a-z]+)\");\nMatcher m = p.matcher(\"123-abc\");\n\nSystem.out.println(m.groupCount());\n\n\u002F\u002F 输出\n2\n\u002F\u002F groupCount() 不包括 group(0)。\n\n",[23,555,553],{"__ignoreMap":68},[44,557,559],{"id":558},"_3-语法","3.  语法",[15,561,562,563,566,567,570,571,547],{},"在Java 中，",[23,564,565],{"code":565},"\\\\ ","表示：插入一个正则表达式的反斜线，使其后的字符具有特殊的意义。在其他语言中，只需要一个",[23,568,569],{"code":569}," \\"," 就能表示转义的作用，而在Java 中，要有两个 ",[23,572,565],{"code":565},[287,574,576],{"id":575},"_1-普通字符","1.  普通字符",[15,578,579,580,583,584,587],{},"普通字符表示",[18,581,582],{},"按字面意思匹配","。例如正则",[23,585,586],{"code":586},"a","匹配字符 a 。",[287,589,591],{"id":590},"_2-元字符","2.  元字符",[15,593,594],{},"元字符具有特殊含义。",[596,597,599,600],"h5",{"id":598},"_1-点号","1.  点号",[23,601,602],{"code":602},".",[15,604,605,606,609,610,613],{},"匹配",[18,607,608],{},"任意一个字符","（默认不包括换行符）。例如正则",[23,611,612],{"code":612},"a.e","可以匹配ase afe a2e等。",[596,615,617,618],{"id":616},"_2-转义符","2.  转义符 ",[23,619,620],{"code":620},"\\",[15,622,623,624,627,628,631],{},"用于取消元字符的特殊含义。例如正则",[23,625,626],{"code":626},"\\."," ",[23,629,630],{"code":630},"\\\\","分别匹配 . \\ 。",[596,633,635],{"id":634},"_3-常见转义字符","3.   常见转义字符",[117,637,638,649],{},[120,639,640],{},[123,641,642,646],{},[126,643,645],{"align":644},"left","正则",[126,647,648],{"align":644},"含义",[136,650,651,664,674,684,694,704,714,724,734],{},[123,652,653,658],{},[141,654,655],{"align":644},[23,656,657],{"code":657},"\\d",[141,659,660,661],{"align":644},"数字 ",[23,662,663],{"code":663},"[0-9]",[123,665,666,671],{},[141,667,668],{"align":644},[23,669,670],{"code":670},"\\D",[141,672,673],{"align":644},"非数字",[123,675,676,681],{},[141,677,678],{"align":644},[23,679,680],{"code":680},"\\w",[141,682,683],{"align":644},"单词字符（字母、数字、下划线）",[123,685,686,691],{},[141,687,688],{"align":644},[23,689,690],{"code":690},"\\W",[141,692,693],{"align":644},"非单词字符",[123,695,696,701],{},[141,697,698],{"align":644},[23,699,700],{"code":700},"\\s",[141,702,703],{"align":644},"空白字符（空格、Tab、换行等）",[123,705,706,711],{},[141,707,708],{"align":644},[23,709,710],{"code":710},"\\S",[141,712,713],{"align":644},"非空白字符",[123,715,716,721],{},[141,717,718],{"align":644},[23,719,720],{"code":720},"\\t",[141,722,723],{"align":644},"Tab",[123,725,726,731],{},[141,727,728],{"align":644},[23,729,730],{"code":730},"\\n",[141,732,733],{"align":644},"换行",[123,735,736,741],{},[141,737,738],{"align":644},[23,739,740],{"code":740},"\\r",[141,742,743],{"align":644},"回车",[287,745,747],{"id":746},"_3-字符类","3.  字符类",[596,749,751],{"id":750},"_1-基本字符类","1.  基本字符类",[15,753,645,754,757],{},[23,755,756],{"code":756},"[abc]","匹配a 或 b 或 c 。",[596,759,761],{"id":760},"_2-范围","2.  范围",[117,763,764,772],{},[120,765,766],{},[123,767,768,770],{},[126,769,645],{"align":644},[126,771,648],{"align":644},[136,773,774,784,794,803],{},[123,775,776,781],{},[141,777,778],{"align":644},[23,779,780],{"code":780},"[a-z]",[141,782,783],{"align":644},"所有小写字母",[123,785,786,791],{},[141,787,788],{"align":644},[23,789,790],{"code":790},"[A-Z]",[141,792,793],{"align":644},"所有大写字母",[123,795,796,800],{},[141,797,798],{"align":644},[23,799,663],{"code":663},[141,801,802],{"align":644},"数字",[123,804,805,810],{},[141,806,807],{"align":644},[23,808,809],{"code":809},"[a-z0-9A-Z]",[141,811,812],{"align":644},"所有字母和数字",[596,814,816],{"id":815},"_3-取反","3.  取反",[15,818,819,822],{},[23,820,821],{"code":821},"[^abc]"," 表示不是 a 、b 、c的。",[287,824,826],{"id":825},"_4-量词","4.  量词",[15,828,829],{},"控制匹配次数。",[117,831,832,840],{},[120,833,834],{},[123,835,836,838],{},[126,837,645],{"align":644},[126,839,648],{"align":644},[136,841,842,852,862,872,882,892],{},[123,843,844,849],{},[141,845,846],{"align":644},[23,847,848],{"code":848},"*",[141,850,851],{"align":644},"0 次或多次",[123,853,854,859],{},[141,855,856],{"align":644},[23,857,858],{"code":858},"+",[141,860,861],{"align":644},"1 次或多次",[123,863,864,869],{},[141,865,866],{"align":644},[23,867,868],{"code":868},"?",[141,870,871],{"align":644},"0 次或1 次",[123,873,874,879],{},[141,875,876],{"align":644},[23,877,878],{"code":878},"{n}",[141,880,881],{"align":644},"恰好 n 次",[123,883,884,889],{},[141,885,886],{"align":644},[23,887,888],{"code":888},"{n,}",[141,890,891],{"align":644},"至少 n 次",[123,893,894,899],{},[141,895,896],{"align":644},[23,897,898],{"code":898},"{n,m}",[141,900,901],{"align":644},"n~m 次",[287,903,905],{"id":904},"_5-边界匹配","5.  边界匹配",[117,907,908,916],{},[120,909,910],{},[123,911,912,914],{},[126,913,645],{},[126,915,648],{},[136,917,918,928,938,948],{},[123,919,920,925],{},[141,921,922],{},[23,923,924],{"code":924},"^",[141,926,927],{},"匹配开头",[123,929,930,935],{},[141,931,932],{},[23,933,934],{"code":934},"$",[141,936,937],{},"匹配结尾",[123,939,940,945],{},[141,941,942],{},[23,943,944],{"code":944},"\\b",[141,946,947],{},"匹配单词边界",[123,949,950,955],{},[141,951,952],{},[23,953,954],{"code":954},"\\B",[141,956,957],{},"匹配非单词边界",[44,959],{"id":68},[10,961,963],{"id":962},"java-类与对象","Java  类与对象",[15,965,966],{},"Java 中类与对象和 C++ 较为相似，直接通过一个实例去学习。",[62,968,971],{"className":969,"code":970,"language":79,"meta":68},[77],"public class Student{\n    public String name;\n    public int age;\n\n    public Student(String name, int age){\n        this.name = name;\n        this.age = age;\n    }\n\n    public void Setname(String name){\n        this.name = name;\n    }\n\n    public void Setage(int age){\n        this.age = age;\n    }\n\n    public static void main(String[] args){\n        Student s1 = new Student(\" \",0);\n        System.out.println(s1.name+\" \"+s1.age);\n\n        s1.Setname(\"nailong\");\n        s1.Setage(10);\n        System.out.println(s1.name+\" \"+s1.age);\n    }\n}\n\n",[23,972,970],{"__ignoreMap":68},[10,974,976],{"id":975},"java-关键字","Java  关键字",[44,978,980],{"id":979},"_1-new","1.  new",[15,982,983,985,986,989],{},[23,984,309],{"code":309}," 用于",[18,987,988],{},"创建对象","，在堆内存中分配空间，并调用对象的构造方法完成初始化。",[44,991,993],{"id":992},"_2-this","2.  this",[15,995,996,999,1000,1003,1004,1006],{},[23,997,998],{"code":998},"this"," 表示",[18,1001,1002],{},"当前对象本身","。哪个对象调用方法，",[23,1005,998],{"code":998}," 就代表哪个对象。",[44,1008,1010],{"id":1009},"_3-static","3.  static",[15,1012,1013,999,1016,547,1019,1021],{},[23,1014,1015],{"code":1015},"static",[18,1017,1018],{},"属于类，而不是属于对象",[23,1020,1015],{"code":1015},"修饰成员变量表示该成员变量是该类的；静态方法要访问普通成员，必须要先创建对象。",[44,1023,1025],{"id":1024},"_4-final","4.  final",[15,1027,1028,1031],{},[23,1029,1030],{"code":1030},"final"," 表示不可改变。修饰变量不可再次赋值，修饰方法不能重写，修饰类不能继承。",[44,1033,1035],{"id":1034},"_5-extends","5.  extends",[15,1037,1038,1041],{},[23,1039,1040],{"code":1040},"extends"," 表示子类继承父类。子类自动拥有父类的属性和方法。Java 中只能继承一个类。",[44,1043,1045],{"id":1044},"_6-super","6.  super",[15,1047,1048,1051],{},[23,1049,1050],{"code":1050},"super"," 表示父类。",[44,1053,1055],{"id":1054},"_7-abstract","7.  abstract",[15,1057,1058,1061],{},[23,1059,1060],{"code":1060},"abstract","表示抽象，用于修饰抽象类和抽象方法。当有抽象方法时，抽象方法不能实现，该类就是抽象类。子类必须实现抽象方法，或者继续保持抽象，抽象类不能创建对象。",[44,1063,1065],{"id":1064},"_8-interface","8.  interface",[15,1067,1068,1071],{},[23,1069,1070],{"code":1070},"interface"," 表示接口，是一种规范。",[62,1073,1076],{"className":1074,"code":1075,"language":79,"meta":68},[77],"interface Fly{\n\n    void fly();\n\n}\n",[23,1077,1075],{"__ignoreMap":68},[44,1079,1081],{"id":1080},"_9-implements","9.  implements",[15,1083,1084,1087],{},[23,1085,1086],{"code":1086},"implements"," 表示实现接口。一个类可以实现多个接口。",[62,1089,1092],{"className":1090,"code":1091,"language":79,"meta":68},[77],"interface Fly{\n\n    void fly();\n\n}\n\nclass Bird implements Fly{\n\n    public void fly(){\n\n        System.out.println(\"飞\");\n\n    }\n\n}\n",[23,1093,1091],{"__ignoreMap":68},[44,1095,1097],{"id":1096},"_10-instanceof","10.  instanceof",[15,1099,1100,1103],{},[23,1101,1102],{"code":1102},"instanceof"," 表示判断对象是否属于某个类或接口。",[62,1105,1108],{"className":1106,"code":1107,"language":79,"meta":68},[77],"Animal a = new Dog();\n\nSystem.out.println(a instanceof Dog);\n\n\u002F\u002F 输出\ntrue\n",[23,1109,1107],{"__ignoreMap":68},[10,1111,1113],{"id":1112},"java-继承和多态","Java  继承和多态",[15,1115,1116],{},"Java 中继承和多态与 C++ 有类似的，这里用一个实例学习。",[62,1118,1121],{"className":1119,"code":1120,"language":79,"meta":68},[77],"public class Student {\n    public String name;\n    public String sex;\n\n    public Student(String s1,String s2){\n        this.name = s1;\n        this.sex = s2;\n    }\n\n    public void Getsex(){\n        System.out.println(\"性别：\"+sex);\n    }\n\n    public static void main(String[] args){\n        System.out.println(\"父类\");\n    }\n}\n\nclass man extends Student{\n    public man(String s1){\n        super(s1,\"man\");\n    }\n\n    public void Getsex(){\n        System.out.println(\"性别：man\");\n    }\n\n    public static void main(String[] args) {\n        System.out.println(\"子类\");\n        man man1 = new man(\"小明\");\n        man1.Getsex();\n    }\n}\n\nclass woman extends Student{\n    public woman(String s1){\n        super(s1,\"woman\");\n    }\n\n    public void Getsex(){\n        System.out.println(\"性别：woman\");\n    }\n\n    public static void main(String[] args) {\n        System.out.println(\"子类\");\n        woman woman1 = new woman(\"小红\");\n        woman1.Getsex();\n    }\n}\n\nclass Test {\n    public static void main(String[] args) {\n\n        Student s1 = new man(\"小明\");\n        Student s2 = new woman(\"小红\");\n\n        s1.Getsex();\n        s2.Getsex();\n\n    }\n\n}\n\n",[23,1122,1120],{"__ignoreMap":68},[15,1124,1125],{},"与 C++ 不同的是，Java只支持继承一个类，要想继承多个，可以通过类继承接口的方式。",[10,1127,1129],{"id":1128},"java-异常处理","Java  异常处理",[44,1131,1133],{"id":1132},"_1-类结构","1.  类结构",[15,1135,1136,1137,1140,1141,1144,1145,1148,1149,1152,1153,1156,1157,1160,1161,1164],{},"Java 中有关异常处理的类都位于 ",[18,1138,1139],{},"java.lang"," 包中。根类是",[18,1142,1143],{},"Throwable","，它由两个子类，",[18,1146,1147],{},"Error","和",[18,1150,1151],{},"Exception","。前者是错误，表示 ",[18,1154,1155],{},"JVM 或系统级错误","。后者是异常，又分为两大类：",[18,1158,1159],{},"RuntimeException"," （非受检异常，编译器不会强制处理）和 ",[18,1162,1163],{},"非 RuntimeException"," （受检异常，编译器要求必须处理）。",[44,1166,1168],{"id":1167},"_2-关键字和类","2.  关键字和类",[15,1170,1171],{},"Java 提供了一些关键字和类去处理异常。",[1173,1174,1175,1182,1188,1194,1200,1206],"ul",{},[1176,1177,1178,1181],"li",{},[18,1179,1180],{},"try","：用于包裹可能会抛出异常的代码块。",[1176,1183,1184,1187],{},[18,1185,1186],{},"catch","：用于捕获异常并处理异常的代码块。",[1176,1189,1190,1193],{},[18,1191,1192],{},"finally","：用于包含无论是否发生异常都需要执行的代码块。",[1176,1195,1196,1199],{},[18,1197,1198],{},"throw","：用于手动抛出异常。",[1176,1201,1202,1205],{},[18,1203,1204],{},"throws","：用于在方法声明中指定方法可能抛出的异常。",[1176,1207,1208,1210,1211,1214],{},[18,1209,1151],{},"类：是所有异常类的父类，它提供了一些方法来获取异常信息，如 ",[18,1212,1213],{},"getMessage()、printStackTrace()"," 等。",[10,1216,1218],{"id":1217},"java-集合框架","Java  集合框架",[15,1220,1221,1222,1225,1226,547],{},"Java 集合框架是 Java 提供的一套用于存储和管理对象的统一容器体系，位于 ",[23,1223,1224],{"code":1224},"java.util"," 包中。分为",[18,1227,1228,1229,1231],{},"Collection（单列集合）",[18,1230,1148],{},"Map（双列集合）",[15,1233,1234],{},"这里对泛型进行一个介绍，它允许在定义类、接口、方法时使用类型参数，从而实现代码复用、类型安全、减少强制类型转换。这里用一个泛型类学习。",[62,1236,1239],{"className":1237,"code":1238,"language":79,"meta":68},[77],"class Box\u003CT>{\n    private T value;\n\n    public void set(T value){\n        this.value = value;\n    }\n\n    public T get(){\n        return value;\n    }\n}\n\n",[23,1240,1238],{"__ignoreMap":68},[15,1242,1243],{},"Java 泛型要求类型参数必须是引用类型，在后面使用基本类型的包装类。",[44,1245,1247],{"id":1246},"_1-collection","1.  Collection",[15,1249,1250,1251,1148,1254,1257],{},"Collection 是所有单列集合的根接口，由它继承出了许多接口，这里学习一下",[18,1252,1253],{},"List",[18,1255,1256],{},"Set","两个。",[15,1259,1260,1261,1264,1265,1268],{},"List 集合是有序的、可以重复的、有索引的接口，以",[18,1262,1263],{},"ArrayList","具体实现为例。Set集合是无重复元素、无索引的接口，以",[18,1266,1267],{},"HashSet","具体实现为例。",[62,1270,1273],{"className":1271,"code":1272,"language":79,"meta":68},[77],"\nimport java.util.ArrayList;\nimport java.util.HashSet;\nimport java.util.List;\nimport java.util.Set;\n\npublic class Test {\n    public static void main(String[] args) {\n\n        \u002F\u002F List接口\n        List\u003CString> list = new ArrayList\u003CString>();\n        list.add(\"a\");\n        list.add(\"b\");\n        list.add(\"c\");\n        for(String s: list){\n            System.out.println(s);\n        }\n        System.out.println(\"list\");\n\n        \u002F\u002F Set接口\n        Set\u003CString> set = new HashSet\u003CString>();\n        set.add(\"a\");\n        set.add(\"a\");\n        set.add(\"b\");\n        set.add(\"b\");\n        set.add(\"c\");\n        set.add(\"c\");\n        for(String s: set){\n            System.out.println(s);\n        }\n        System.out.println(\"Set\");\n    }\n\n}\n\n\n",[23,1274,1272],{"__ignoreMap":68},[44,1276,1278],{"id":1277},"_2-map","2.  Map",[15,1280,1281,1282,1285],{},"map 是双列的，按照键值对的形式存储。这里以",[18,1283,1284],{},"HashMap","为例。",[62,1287,1290],{"className":1288,"code":1289,"language":79,"meta":68},[77],"import java.util.Map;\nimport java.util.HashMap;\nimport java.util.Set;\n\npublic class Test {\n    public static void main(String[] args) {\n\n        \u002F\u002F 这里要用int的包装类\n        Map\u003CString,Integer> student = new HashMap\u003CString,Integer>();\n        student.put(\"小张\",12);\n        student.put(\"小王\",19);\n        student.put(\"小明\",15);\n\n        \u002F\u002F Map的遍历要先获得键Set，然后遍历键\n        Set\u003CString> name = student.keySet();\n        for (String key : name) {\n            \u002F\u002F 这里因为Map值可以使null，如果用int会因为空指针报错，需要用包装类\n            Integer value = student.get(key);\n            System.out.println(key+\":\"+value);\n        }\n    }\n}\n\n\n",[23,1291,1289],{"__ignoreMap":68},[15,1293,1294,1295,547],{},"Java 为每个基本类型都提供了对应的",[18,1296,1297],{},"包装类",[117,1299,1300,1309],{},[120,1301,1302],{},[123,1303,1304,1307],{},[126,1305,1306],{},"基本类型",[126,1308,1297],{},[136,1310,1311,1318,1325,1332,1339,1346,1353,1360],{},[123,1312,1313,1315],{},[141,1314,174],{},[141,1316,1317],{},"Integer",[123,1319,1320,1322],{},[141,1321,218],{},[141,1323,1324],{},"Double",[123,1326,1327,1329],{},[141,1328,250],{},[141,1330,1331],{},"Character",[123,1333,1334,1336],{},[141,1335,233],{},[141,1337,1338],{},"Boolean",[123,1340,1341,1343],{},[141,1342,188],{},[141,1344,1345],{},"Long",[123,1347,1348,1350],{},[141,1349,203],{},[141,1351,1352],{},"Float",[123,1354,1355,1357],{},[141,1356,160],{},[141,1358,1359],{},"Short",[123,1361,1362,1364],{},[141,1363,145],{},[141,1365,1366],{},"Byte",[10,1368,1370],{"id":1369},"java-io流","Java  IO流",[1173,1372,1373,1379],{},[1176,1374,1375,1378],{},[18,1376,1377],{},"Input（输入）","：把数据读到程序里",[1176,1380,1381,1384],{},[18,1382,1383],{},"Output（输出）","：把程序里的数据写出去",[15,1386,1387,1390],{},[18,1388,1389],{},"IO流"," 可以分为字节流和字符流两类，字节流一切数据都可以操作，字符流专门处理文本。以文件流举例。",[62,1392,1395],{"className":1393,"code":1394,"language":79,"meta":68},[77],"\u002F\u002F FileReader\nFileReader fr = new FileReader(\"a.txt\");\n\nint ch;\n\nwhile((ch = fr.read()) != -1){\n    System.out.print((char)ch);\n}\n\nfr.close();\n\n\u002F\u002F FileWriter\nFileWriter fw = new FileWriter(\"a.txt\");\n\nfw.write(\"Hello Java\");\n\nfw.close();\n\n",[23,1396,1394],{"__ignoreMap":68},[10,1398,1400],{"id":1399},"java-反射","Java  反射",[10,1402,1404],{"id":1403},"java-序列化与反序列化","Java  序列化与反序列化",[10,1406,1408],{"id":1407},"java-类加载机制","Java  类加载机制",[10,1410,1412],{"id":1411},"java-动态代理","Java 动态代理",[10,1414,1416],{"id":1415},"servlet-基础","Servlet 基础",[10,1418,1420],{"id":1419},"maven-基础","Maven 基础",{"title":68,"searchDepth":1422,"depth":1422,"links":1423},4,[1424,1426,1432,1433,1457,1484,1485,1497,1498,1502,1506,1507,1508,1509,1510,1511,1512],{"id":12,"depth":1425,"text":13},2,{"id":41,"depth":1425,"text":42,"children":1427},[1428,1430,1431],{"id":46,"depth":1429,"text":47},3,{"id":53,"depth":1429,"text":54},{"id":84,"depth":1429,"text":85},{"id":100,"depth":1425,"text":101},{"id":110,"depth":1425,"text":111,"children":1434},[1435,1436,1437,1442,1448],{"id":114,"depth":1429,"text":115},{"id":263,"depth":1429,"text":264},{"id":284,"depth":1429,"text":285,"children":1438},[1439,1440,1441],{"id":289,"depth":1422,"text":290},{"id":302,"depth":1422,"text":303},{"id":328,"depth":1422,"text":329},{"id":350,"depth":1429,"text":351,"children":1443},[1444,1445,1446,1447],{"id":354,"depth":1422,"text":355},{"id":375,"depth":1422,"text":376},{"id":395,"depth":1422,"text":396},{"id":416,"depth":1422,"text":417},{"id":426,"depth":1429,"text":427,"children":1449},[1450,1452,1454,1456],{"id":430,"depth":1422,"text":1451},"1.  System.out.print()",{"id":446,"depth":1422,"text":1453},"2.  System.out.println()",{"id":462,"depth":1422,"text":1455},"3.  System.out.printf()",{"id":478,"depth":1422,"text":479},{"id":488,"depth":1425,"text":489,"children":1458},[1459,1464,1465,1483],{"id":492,"depth":1429,"text":493,"children":1460},[1461,1462,1463],{"id":502,"depth":1422,"text":503},{"id":517,"depth":1422,"text":518},{"id":532,"depth":1422,"text":533},{"id":539,"depth":1429,"text":540},{"id":558,"depth":1429,"text":559,"children":1466},[1467,1468,1476,1481,1482],{"id":575,"depth":1422,"text":576},{"id":590,"depth":1422,"text":591,"children":1469},[1470,1473,1475],{"id":598,"depth":1471,"text":1472},5,"1.  点号.",{"id":616,"depth":1471,"text":1474},"2.  转义符 \\",{"id":634,"depth":1471,"text":635},{"id":746,"depth":1422,"text":747,"children":1477},[1478,1479,1480],{"id":750,"depth":1471,"text":751},{"id":760,"depth":1471,"text":761},{"id":815,"depth":1471,"text":816},{"id":825,"depth":1422,"text":826},{"id":904,"depth":1422,"text":905},{"id":68,"depth":1429,"text":68},{"id":962,"depth":1425,"text":963},{"id":975,"depth":1425,"text":976,"children":1486},[1487,1488,1489,1490,1491,1492,1493,1494,1495,1496],{"id":979,"depth":1429,"text":980},{"id":992,"depth":1429,"text":993},{"id":1009,"depth":1429,"text":1010},{"id":1024,"depth":1429,"text":1025},{"id":1034,"depth":1429,"text":1035},{"id":1044,"depth":1429,"text":1045},{"id":1054,"depth":1429,"text":1055},{"id":1064,"depth":1429,"text":1065},{"id":1080,"depth":1429,"text":1081},{"id":1096,"depth":1429,"text":1097},{"id":1112,"depth":1425,"text":1113},{"id":1128,"depth":1425,"text":1129,"children":1499},[1500,1501],{"id":1132,"depth":1429,"text":1133},{"id":1167,"depth":1429,"text":1168},{"id":1217,"depth":1425,"text":1218,"children":1503},[1504,1505],{"id":1246,"depth":1429,"text":1247},{"id":1277,"depth":1429,"text":1278},{"id":1369,"depth":1425,"text":1370},{"id":1399,"depth":1425,"text":1400},{"id":1403,"depth":1425,"text":1404},{"id":1407,"depth":1425,"text":1408},{"id":1411,"depth":1425,"text":1412},{"id":1415,"depth":1425,"text":1416},{"id":1419,"depth":1425,"text":1420},[1514],"技术","2026-06-22 14:38:15","补一下Java的知识",false,"md","\u002F2026\u002FJava基础\u002Fcover.jpg",{"slots":1521},{},true,"\u002F2026\u002Fjava",null,{"text":1526,"minutes":1527,"time":1528,"words":1529},"16 min read",15.285,917100,3057,{"title":5,"description":1516},{"loc":1523},"posts\u002F2026\u002FJava基础",[],"tech","timtAhABXpiaQ1duMxvBGv65lK6gLdlWtqv7DGLp4w0",[1537,1542],{"title":1538,"path":1539,"stem":1540,"date":1541,"type":1534,"children":-1},"CTFShow Web入门 PHP反序列化 Writeup 合集","\u002F2026\u002Fctfshow-web-php-writeup","posts\u002F2026\u002FCTFShow Web入门 PHP反序列化 Writeup 合集","2026-06-16 08:59:34",{"title":1543,"path":1544,"stem":1545,"date":1546,"type":1534,"children":-1},"青岑CTF Web入门 WP","\u002F2026\u002Fctf-web-wp","posts\u002F2026\u002F青岑CTF Web入门 WP","2026-06-24 14:48:23",1786110316903]