第一章JAVA编程语言概述

走进Java：JAVA之父——James Gosling

​ java由1995年发布，正式版本于1996.01发布（JDK1.0）

主要特点

面向对象、分布式、简单化、多线程、安全、跨平台移植

跨平台的条件——JAVA虚拟机（JVM）

三大平台体系：JAVASE，JAVAEE，JAVAME

开发环境的搭建

JVM（java virtual machine） 将JAVA程序翻译成能在Win版、Linux、Mac版的操作系统上运行的应用程序

JRE（java runtime environment）java运行环境 =JVM+Java核心类库

---

配置path变量到bin路径下，【目的：在任意路径下执行javac】

（我的电脑——属性——用户变量）

【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili

执行流程：查找javac.exe，如若没有，在path环境变量中从前往后一次查找

HelloWorld的编译和运行

1. 编写java源文件。（HelloWorld.java）
2. 编译：通过javac命令，生成一个或多个.class字节码文件。
3. 运行：通过java命令，将.class字节码文件加载到内存中。

public class HelloWorld{public static void main(String [] args ){System.out.println(“HelloWorld”);}
}

注意：

​ 以.java结尾的文件是.java源文件。

​ 一个.java源文件只能有一个public修饰的类，且该类的类名与文件名相同。

​ 每条语句以“；”英文输入法下的分号结尾。

​ java严格区分大小写。

​ 执行类，需要有程序的入口，main方法。

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

注释语句 comment

不会被JVM解释执行的语句。对代码的解释说明。

//单行注释
/* 多行注释 注意不要嵌套  */
/** 文档注释 Java特有的一种注释方式
可以通过javadoc -d ./mydoc -author -version 源文件名.java
生成说明文档
*/

---

第二章 Java基础语法概述01

关键字

被java赋予了特殊含义的单词

public protected private
interface abstract implements extends new
class import package
byte char boolean short int float long double
void if else while for switch case default
do break continue return instanceof
static final super this native strictfp
synchronized transient volatile
catch try finally throw throws enum assert
——————————————————————————————
保留字：const \ goto
特殊值：true \ false \ null

标识符

Java中凡是命名的地方都有标识符。包、类、接口、方法、变量、常量

命名规则（编译的规则）

1. 可以由字母、数字、特殊字符、下划线_和美元符$组成。
2. 不能以数字开头。
3. 不得出现空格。
4. 不使用关键字、保留字，但可以包含关键字和保留字。 /例如:class100/
5. Java严格区分大小写，名字长度无限制。

命名规范（不影响编译，可以通过但不建议不遵守）

1. 包名：所有字母小写。/com.java.ittest/
2. 类名、接口名：大驼峰原则。每个单词首字母大写。 /XxxYyyZzz/
3. 方法名、变量名：第一个单词首字母小写，其余首字母大写。 /xxxYyyZzz/
4. 常量名：所有字母大写，每个单词之间以“_”隔开。 /XXX_YYY_ZZZ/

变量

保存数据 /局部变量|成员变量/

声明并赋值

int a = 10;
/*声明同时赋值*/
int a;
a = 10;
/*先声明后赋值*/

变量 = 数据类型 + 变量名

注意：

​ 在同一个作用域{}内变量名不能重复。

​ 局部变量在使用前必须赋值，全局变量若未赋值有默认值。

​ 先声明，后使用。

---

进制与位运算（了解）

位bit 与 字节byte

计算机中任何计算机和存储都是以二进制方式实现的

位是计算机中最小的存储单元。字节是计算机中基本的存储单元。

1 bit = 8 byte

以“0x”“0X”开头：十六进制 || 以“0b”“0B”开头：二进制 || 以“0”开头：八进制 ||默认：十进制

例如：0x3f20 0732 0b11111 999 其中A表示10，F表示15

---

变量的数据类型

基本数据类型（8种）

​ 整型：4种 浮点型：2种 字符型：1种 布尔型： 1种

byte 8位 short 16位 int 32位 long 64位
/整型默认为int类型 浮点型默认为double类型 /
float 32位 double 64位
char 16位=2个字节
boolean = ture | false
/*成员变量默认值 整型0 浮点型0.0 字符型0 布尔型false

引用数据类型（3种）​   类class、接口interface、数组[ ]注意：​ long类型变量，值后加上L 或 l​  float类型变量，值后加上F 或 f​ double类型变量，值后可以加D 或 d​   char类型变量，值加上**单引号**（‘A‘） ，只能存储单个字符​     【char类型变量用Unicode编码存储（ASCII 、 中文 、 日文 、特殊字符）】​    String类型变量，值加上**双引号*（"hello"）

---

数据类型之间的转换

自动类型转换 小容量转大容量（ boolean 类型不能转换）

​ byte，short，char—>int—>ong—>float—>double
​ byte,short,char之间不能直接运算，需要强转，否则自动升级为int
​ 任何基本数据类型与String类型使用连接符“+”，自动转换成String类型

强制类型转换 大容量转小容量（ 强转符：（转换类型））
int num = 123;
byte b =(byte)num;

运算符

算术运算符+ - * /(返回商) %(返回余数) ++(前/后) --(前/后)

int a = 10;
System.out.println(a++); //10
System.out.println(a); //11int a = 10;
a = a++; /*(相当于先赋值a = a，然后a++载入内存但不生效)（无效）*/
System.out.println(a); //10

​ 前++ - - ：先自增自减，后运算； 后++ - -：先运算，后自增自减。

赋值运算符

= +=  -=  *=  /=  %=

自动强转，不会编译错误
【s += 1】不完全等于 【s = s + 1】，
需要注明s 的数据类型，比如：【s = (short)(s+1);】

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

== ！= > < >= <=

逻辑运算符

&&   ||  & | ! ^

注意：关系/逻辑运算符都返回一个boolean值
【&& 与 &的区别？】
&&称为短路与，当左边结果false时，右边表达式不再计算
&是位运算符，无论左边结果ture还是false，右边表达式都计算

位运算符

~    &   |   ^   <<    >>    >>>

三元运算符

 =条件表达式？表达式1 ：表达式2

注意：

​ 若条件表达式结果true，执行表达式1，否则执行表达式2

​ 表达式1和表达式2 结果的数据类型需要保护一致

---

第三章 Java基础语法概述02

流程控制语句

顺序结构

分支结构（if条件else if语句 switch选择case语句）

• ​ if（）{}
• ​ if（）{}else{}
• ​ if（）{}else if （）{} … else{}
  • 若某个条件表达式为true，则不再继续向下执行。
  • if else 语句可以嵌套。else if 可以有多个。
• switch（）{case ： ；case ： ；…default： ；}
• switch（）{case： break；case： break； …}
  • 表达式结果类型不能为boolean值，只能是byte short int char String [枚举]enum。
  • default ，break是可选的。
  • case 后只能写常量值，不能写表达式。（古典概型：有限种可能结果）
  • 表达式结果类型必须与case后值的类型一致。

循环结构（for、while、do-while）

三种语法格式都有四个条件：

​ 1初始值、2循环条件、3迭代条件、4循环体

• for（1 ; 2 ; 3）{ 4 ;}

  1 2 4 3 2 4 3 2 … 2

• 1 while(2){ 4 3;}

• 1 do{ 4 3;}while(2)

while 与 do-while 区别：

​ while 先判断循环条件，再执行循环体

​ do-while 先执行循环体，再判断循环条件

特殊的流程控制语句（break & continue）**

break：跳出当前循环。

continue：跳出当次循环。

---

第四章 方法的声明和使用

方法:也称为函数，是一个功能的定义，是类中最基本的功能单元。

方法的格式：修饰符 返回值类型 方法名 （参数列表）{

​ return 返回值;}

1. 修饰符：访问修饰符public、
2. 返回值类型：返回结果的数据类型
3. 参数列表：局部变量，可以有0个或多个，每个变量之间以逗号“,”隔开
4. return：结束方法

注意：

​ 返回值类型与返回值(return 后+返回值)的数据类型保持一致

​ 方法名+参数列表调用方法 参数列表的参数个数和参数类型需一一对应

​ 方法声明了 返回值类型 说明有返回值，可以用于赋值。反之则为 void 类型

​ 方法不能嵌套(声明其它方法)，但是方法中可以调用其它方法

---

【将基本数据类型作为参数传递给方法，方法运行结束，基本数据类型保持原值不变】

【将引用数据类型作为参数传递给方法，方法运行结束，引用数据类型发生相应改变】

---

方法重载(Overload)

同一个类中：方法名相同、参数列表（参数类型、参数个数）不同

​ 注意：与返回值类型无关，println（）是一个重载方法

---

第五章 面向对象编程（01）(！=面向过程)

OOP Object Oriented Programming

面向过程：强调功能行为

面向对象：将功能行为封装进对象，强调具备了功能行为的对象

面向对象注重前期对类的设计，设计类的成员（属性&方法）将现实中的一类事物的共性内容提取，抽象成相应的 Java 类。

​ 共性内容：名称 年龄 性别 吃饭的功能 睡觉的功能

类是对象的抽象，对象是类的实例。

通过 new 关键字创建对象

//创建 Animal 的对象
Animal an = new Animal();
//定义对象的属性
an.name = "金毛";
an.age = 17;
an.gender = '男'
//调用对象的方法an.eat();an.sleep();

对象的属性和方法

属性也叫成员变量、实例变量

成员变量 与 局部变量 的区别

1. ​ 作用域、内存中的位置不同

2. ​ 成员变量有默认值【缺省值】，局部变量没有(必须赋值后使用)

   ​ 默认值: 0 , 0.0 , ‘\u0000’ , false , null

---

封装 ：

保证属性私有化(private)，只能通过方法修改属性值.

访问修饰符：private 只在本类中访问，public在任何地方访问

---

this 关键字 使用在本类中代表当前对象，可调用属性&方法&构造器
this 往往用于区分 局部变量 和 成员变量
this(...) 关键字必须写在执行代码块的首行super 关键字 使用在子类中代表父类，可调用属性&方法&构造器
当子类继承父类后，子类所有构造器默认第一行有一个隐藏的super()
super() 调用父类的无参构造器，继承父类所有属性和方法，需要初始化父类
若父类没有无参构造器，子类所有构造器中必须显示地调用父类的有参构造器
super(...) 关键字必须写在执行代码块的首行this() 与 super() 二者不能同时出现

【创建父类时需要显示地写一个无参构造器，因为子类继承父类后，所有构造器都默认调用父类的无参构造器，如果父类没有写出无参构造器，那么子类的所有构造器都必将显示地去调用父类的无参构造器，造成代码冗余。】

构造器也叫构造方法，是类的成员之一。（属性&方法）

构造器的格式：访问修饰符 类名 （参数列表）{}

构造器的作用：

1. ​ 创建对象（可以通过 new 关键字 调用构造器）
2. ​ 为对象进行初始化

注意：

​ 构造器的名称必须与类名一致

​ 一个类中没有显示地提供构造器，系统会提供一个默认的无参构造器

​ 一个类中显示地提供了任何构造器，系统默认的无参构造器不再提供

​ 构造器在创建对象时调用一次

​ 同一个类的多个构造器构成了重载方法

---

包package

不同包中的类可以重名

访问权限修饰符private，public，默认，protected，

package使用在 .java 源文件的可执行代码首行

​ 命名规范：所有字母小写。域名的倒置 com.baidu.[项目名].[模块名]

import使用在package和class之间，

​ import com.baidu.test.* --导入包test中所有类和接口，不包括test包中包中的类和接口

​ 【一个类中导入两个相同类名不同包名的类时，一个import导包，另一个全限定类名导入。

​ 例：import java.util.Date; java.sql.Date date = new java.sql.Date();】

​ 静态导包：import static + 包名 --导入包中的静态类和接口

第六章 数组的声明和使用

数组：用于批量存储同一类数据。

数组的格式：数据类型 变量名[] = new 数据类型{ 值 }；

​ 静态初始化：赋值和初始化同时进行

​ 动态初始化：先初始化数组，然后分别赋值

int [] scores = new int[]{55,66,77,88,99};
int [] scores2 = new int[5];
scores2 [0] = 55;//数组的索引值从0开始到 长度-1
scores2 [1] = 66;
scores2 [2] = 77;
scores2 [3] = 88;
scores2 [4] = 99;//初始化时即确定了数组的长度

数组的遍历：用普通 for 循环 for(int i = 0 ; i < scores.length ; i++){}

​ 用增强 for 循环 for(int i : scores){} --增强 for 循环不便于修改数组中元素值

数组的默认值：0 , 0.0 , ‘\u0000’ , false , null

数组的常见异常：ArrayIndexOutOfBoundsException数组下标越界异常

​ NullPointerException空指针异常

二维数组

数据类型 变量名[] [] = new 数据类型{ 值 }；

int [][]array = new int[][]{{1,2,3},{4,5,6,},{7,8}};//array[3][]
int [][]array2 = new int[3][];
array2[1] = new int[3]
array2[1][2] = 0;
array2[2] = new int[2]
array2[2][0] = 0;array2[0][1] = 0;//  null[1] = 0 --空指针异常(null后加方法、引用类型、常用类型)

二维数组的遍历：普通 for 循环

  for(int i = 0;i<array.length;i++0){int [] arr = array[i];for(int j = 0; j <arr.length;j++){System.out.print(arr[j]+"\t");}System.out.println();}// 普通 for 循环for(int [] arr: array){for(int i :arr){System.out.print(i+"\t");}System.out.println();}// 增强 for 循环

可变参数

注意：

​ 可变参数与数组之间不构成方法的重载

​ 可变参数必须写在当前参数列表的末尾,一个方法只能指定一个可变参数.

class HelloWorld{public static void main(String [] args){int []arr = new int[]{1,2,3,4};int sum = add(arr);}public static int add(int[]arr){int sum = 0;for(int i : arr)  {sum += arr[i];}return sum;}//可变参数：调用方法时可以传递0或多个实参【基层原理是数组】public static int add(int ... args){int sum = 0;for(int i : arr){sum += arr[i];}return sum;}
}

---

第七章 面向对象编程（02）(！=面向过程)

---

继承：用 extends 关键字 class [子类]A extends [父类/超类/基类]B{}

• ​ 子类继承父类中所有的属性&方法，子类是父类的’‘扩展’'

• ​ 可以继承私有属性，但是有private修饰符，子类不可以直接访问，

  ​ 需要使用public修饰的get/set方法才可以访问。私有方法无法调用。

注意：

​ 不能为了简化代码获取共同功能而继承，继承的父类子类需要有所属关系：is a

​ Java支持单继承，不支持多继承(一个子类只有一个父类)【支持多层继承】

---

方法重写(Override)

方法重写也叫方法覆盖，子类可以对父类方法重写

方法名与参数列表必须相同。

子类重写方法的访问修饰符不得小于父类的访问修饰符。

子类重写方法的返回值类型可以是父类的子类。(例：对象person , student ; animal , dog…)

通常情况下，方法签名保持不变。

Overload 与 Override 的区别：

• 方法的重载出现在同一个类中，方法名相同而参数列表不同。
• 方法的重写出现在子类继承父类中，方法名与参数列表相同，通常具有相同的方法签名。
• 子类重写方法的访问修饰发不能小于父类被重写方法的访问修饰符，
• 子类重写方法的返回值类型可以变为父类被重写方法返回值类型的子类。

---

四种访问控制修饰符

类class中 – public |default (·不写·)
包package中 – public |protected | private | default (·不写·)

public ：公共的，修饰 属性、方法、类。【任何地方】

protected：受保护的，修饰 属性、方法。【本类、本包、子类】

default：默认的(缺省的)，修饰 属性、方法、类。【本类、本包】

private：私有的，修饰 属性、方法。【本类】

面向对象的多态性 （polymorphism）

同一类事物的多种表现形态 人-男人/女人 动物-猫/狗 父类-子类1/子类2/…

---

动态绑定(虚拟方法调用)：编译时看左边，运行时看右边

​ 父类 [对象名] = new 子类( ); --向上转型

​ 子类[对象名] =(子类) [父类对象名]; --向下转型

​ 父类 [对象名] = new 子类( ); --父类没有子类特有的方法，实际运行子类重写的父类方法

​ 子类[对象名] =(子类) [父类对象名]; --子类与父类对象名的运行时类型必须一致，否则回造成向下转型的结果为 编译：YES 运行：NO。

注意：向下转型前可以用 instanceof 运算符作为判断条件

if(p instanceof Man){//判断 p 引用指向的对象是不是 Man类型或者 Man的子类类型
Man man = (Man) p;}

---

多态数组

Person[] person = new Person [3];person[0] = new Person("Ann",18);
person[1] = new Man();
person[2] = new Woman();for(int i : person){Person p = person[i];p.eat();p.sleep(); }

多态参数

public static void show(Person p){//多态参数 p//虚拟方法调用p.eat();p.sleep();if(p instanceof Man){//判断 p 引用指向的对象是不是 Man类型或者 Man的子类类型Man man = (Man) p; } }

java.lang.Object 类

Object 类是所有类的父类，java.lang 是默认导入的包。

Object 类的方法最具有共性，子类可以重写Object类的方法。

​ 1.public boolean equals(Object obj)

​ equals 比较两个对象是否相等【必须是引用数据类型】

​ ‘’==’‘ 运算符 ①比较两个基本数据类型的值是否相等

​ ②比较两个引用数据类型的地址值是否相等

重写Object类中的equals()方法，equals()源代码也是通过‘’==‘’运算符实现的。

【String字符串的equals()方法：比较字符串每一个字符是否相同】

public boolean equals(Object obj){if(this == obj){//判断两个对象的地址值是否相等return true;}if(obj instanceof Person){//判断 p 引用指向的对象是不是 Person类型或者 Person的子类类型Person p = (Person)obj;if(this.name.equals(p.name) && this.age == p.age){return true;}}return false;
}

​ 2.public String toString()

​ 返回对象的字符串形式

​ 当直接输出对象的引用时默认调用toString() --System.out.print § ; ‘’==’’ System.out.print(p.toString());

​ Object 类中 toString() 返回值：getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

重写方法Object类中的toString()方法，

public String toString(){return "姓名：" + name + "年龄：" + age;
}

static 修饰符

静态的(static)，可以修饰 属性、方法、构造器、代码块、内部类 【∈类的成员】

static 修饰属性：（静态变量 或 类变量）

• static 属性随着类加载而加载，随着类消失而消失。被类的所有对象共享。
• 某个类的对象修改static 属性值，其余对象的static 属性值随之改变。
• 静态变量的存在优先于对象。
• “类名.类变量” 代表类变量/静态变量。

static 修饰方法：（静态方法 或 类方法）

• static 方法随着类加载而加载。
• 静态方法中不能使用非静态成员，非静态方法中可以使用静态成员。
• 静态方法中不能使用 super 和 this 。
• 静态方法的存在优先于对象。
• “类名.类变量” 代表类变量/静态变量。

类的成员：代码块

非静态代码块（初始化块）

​ 格式：{ }

• 创建对象时执行一次。
• 代码块的执行优先于构造器。
• 用于初始化对象（通常提取了多个构造器的共性内容）

静态代码快

​ 格式：static{ }

• 随着类的加载而加载，每个类加载一次。
• 静态代码块中不能使用非静态成员，不能使用 super 和 this 。
• 静态代码块的执行优先于非静态代码块

为属性赋初始值的4 种方式：

1 默认值(缺省值) 2 直接显示赋值(声明时赋值) 3 构造器 4 代码块

​ 顺序： 1 24 3 【2和4顺序执行，不分主次】

【final 修饰符】

​ 修饰的类不能被其它类继承。

​ 修饰的方法不能被其它方法重写。

​ 修饰变量(=’‘常量’’)一旦赋值，值不能改变。

​ 常量的命名：所有字母大写，每个单词以" _ "隔开

​ 常量没有默认值，使用前必须赋值(直接显示赋值、构造器、代码块)

【使用构造器给常量赋值，需要保证所有的构造器都为该常量赋予初始值】

---

第八章 高级类特性

抽象类

父类中只提供方法的声明，不提供具体的实现。

拥有一个或多个抽象方法的类，称为抽象类

使用 abstract 关键字：

格式： 访问控制修饰符 abstract class 类名{}

​ 访问控制修饰符 abstract 返回值类型 方法名(参数列表) ;

注意：

​ 一个抽象类可以没有抽象方法，有抽象方法的类一定是抽象类。

​ 抽象类不能创建实例，是用来被继承的。

​ 抽象类中可以有构造器。目的：子类继承父类中所有属性&方法，子类需要对父类对象进行初始化。

​ 子类继承父类后，重写所有的父类抽象方法，可视为具体类，否则定义为抽象类。

【abstract 不能与 final / static / private 同时使用】【final 修饰方法不能被重写，static 可以通过‘类.方法名’调用，private 不可见】

接口

定义多个不相关事物的相同功能。用 implement 关键字 实现。

格式：public interface Flyer{ }

注意：

​ 接口是特殊的抽象类，接口不能创建实例，是用来被实现 implement 的。

​ 接口中不能有变量、构造器、代码块。

​ 实现接口的类可以继承接口中所有的成员。

​ 若实现类实现了接口中所有的抽象方法，可视为具体类，可以创建实例。

​ 若实现类没有实现接口中所有抽象方法，定义为抽象类，不能创建实例。

​ 接口只可以继承接口，且支持多继承接口。—解决了java中单继承的局限性！

​ 一个类可以继承类并实现一个或多个接口，先继承，后实现！

---

jdk1.8 后接口的特性

函数式接口：接口中只有一个抽象方法。用 @FuncationalInterface 注解修饰

注意：

​ 类优先原则. 若某个类继承其它一个类同时实现接口，父类与接口中有相同签名的方法时，默认优先继承类中方法。

​ 若某个类实现两个接口，接口出现相同方法签名的方法时，必须选择其中一个 格式：接口名.super.默认方法;

---

类的成员：内部类

成员内部类可以使用 static，final，也有四种访问控制修饰符(public ,protected ,private ,default[默认])

内部类与外部类具有相同的特性[继承、封装]

【阶段一】菜学21.11相关推荐

1. HALCON 21.11：深度学习笔记---语义分割/边缘提取(12)

   HALCON 21.11:深度学习笔记---语义分割/边缘提取(12) HALCON 21.11.0.0中,实现了深度学习方法. 本章介绍了如何使用基于深度学习的语义分割,包括训练和推理阶段. 通过语 ...

2. HALCON 21.11：深度学习笔记---分类(10)

   HALCON 21.11:深度学习笔记---分类(10) HALCON 21.11.0.0中,实现了深度学习方法. 本章介绍了如何在训练和推理阶段使用基于深度学习的分类. 基于深度学习的分类是一种对一 ...

3. HALCON 21.11：深度学习笔记---异常检测(9)

   HALCON 21.11:深度学习笔记---异常检测(9) HALCON 21.11.0.0中,实现了深度学习方法. 本章介绍了如何使用基于深度学习的异常检测. 通过异常检测,我们想要检测图像是否包含 ...

4. HALCON 21.11：深度学习笔记---术语表(7)

   HALCON 21.11:深度学习笔记---术语表(7) HALCON 21.11.0.0中,实现了深度学习方法.下面,我们将描述深度学习环境中使用的最重要的术语: anchor (锚) Anchor ...

5. HALCON 21.11：深度学习笔记---网络和训练过程(4)

   HALCON 21.11:深度学习笔记---网络和训练过程(4) HALCON 21.11.0.0中,实现了深度学习方法.关于网络和训练过程如下: 在深度学习中,任务是通过网络发送输入图像来执行的.整 ...

6. HALCON 21.11：深度学习笔记---Data（数据）(3)

   HALCON 21.11:深度学习笔记---Data(数据)(3) HALCON 21.11.0.0中,实现了深度学习方法.其中,关于术语"数据"的介绍如下: 术语"数据 ...

7. HALCON 21.11：深度学习笔记(2)

   HALCON 21.11:深度学习笔记(2) HALCON 21.11.0.0中,实现了深度学习方法.由于上面提到的DL方法在它们做什么以及它们如何需要数据方面各不相同,所以您需要知道哪种方法最适合您 ...

8. 字节跳动技术中台前端日常实习一面 21/11/19

   21/11/22更一波+预告,11/26二面,非常感谢面试官大大能给二面的机会,虽然这周是考试周,但是我会好好准备的! 21/11/26 最后一更XD, 字节跳动技术中台日常实习二面凉经-反面教材中的 ...

9. 零起点学算法11——求梯形面积

   零起点学算法11--求梯形面积 Time Limit: 1 Sec  Memory Limit: 64 MB   64bit IO Format: %lld Description 水题 Input ...

最新文章

1. 科技公司重新关注2级以上驾驶员辅助
2. 用户请求队列化_分布式消息队列选型分析
3. 风投报告：2017下半年VR/AR娱乐领域投资额同比上升79% 【52翻译】
4. 电脑安装python步骤-python3.8下载及安装步骤详解
5. MusicXML 3.0 - DTD 速查
6. boost::hana::zip_shortest_with用法的测试程序
7. 怎么使用ajax重定向,如何通过在特定控制器和动作上使用Ajax调用来重定向用户...
8. html怎么做交互留言,简单html与servlet交互
9. 修改tomcat服务器图标,修改tomcat小猫图标，设置项目的favicon图标
10. MFC中的CString类使用方法指南
11. 【英语学习】【English L06】U06 Banking L1 How can I save money?
12. [转载] python匿名（lambda）函数
13. Android源码——Logger日志系统
14. LoadRunner压力测试案列
15. 十进制 二进制 十六进制 八进制
16. php实现大文件分片上传
17. 提高ios app性能 初中高级实践
18. 【组成原理-处理器】处理器的相关概念
19. 计算机初级证书 英语怎么说,常见职业资格证书英文翻译（含英语、计算机等）...
20. 【逗老师带你学IT】PRTG获取HUAWEI FusionServer iBMC传感器状态

热门文章

1. 卧底软件：帮助公司找出“内奸”
2. 编程之美-中国象棋将帅问题
3. shell 正则取出中间文本。
4. 常用荧光染料的激发和发射波长
5. 高质量蓝牙耳机推荐，2023年热销火爆的蓝牙耳机推荐
6. Unity 获取 两个点的中心点
7. Oracle的Numer类型与C,C#数据类型对应关系
8. Prometheus 监控案例详解
9. Python3 使用科大讯飞 API 接口实现音频文件转写
10. 所有程序员会面临的问题：程序员只能吃青春饭？