代码链接：https://download.csdn.net/download/qq_52354698/86248464?spm=1001.2014.3001.5503

1. 包

1. 应用场景

现在有两个程序员共同开发一个java项目,程序员xiaoming希望定义一 个类取名Dog ,程序员xiaoqiang也想定义一个类也叫Dog。两个程序员为此还吵了起来,怎么办?
答案：包

2. 包的三大作用

1. 区分相同名字的类
2. 当类很多时，可以很好的管理类
3. 控制访问范围

3. 基本语法

package com.edu
说明：

1. package：关键字，表示打包
2. com.edu：表示包名

4. 包的命名

命名规则
只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字

demo.class.exec1//错误，class是关键字
demo.12a//错误，不能以数字开头
demo.ab12.oa//正确

命名规范
一般是小写字母+小圆点
一般是：com.公司名.项目名.业务模块名
例如：com.edu.oa.model
例子：

com.sina.crm.user
com.sina.crm.oder
com.sina.crm.utils

5. 包的本质分析

包的本质实际上就是创建不同的文件夹/目录来保存类文件

6. 示例

在两个包中定义两个相同名称的类
在声明的时候，第一个包中的类直接声明
第二个包中的类需要带有前缀

7. 常用的包

• java.lang.*：lang包是基本包，默认引入，不需要再引入
• java.util.*：util包，系统提供的工具包，工具类，使用Scanner
• java.net.*：网络包，网络开发
• java.awt.*：是做java的界面开发，GUI

8. 包的注意事项和使用细节

1. package的作用是声明当前类所在包，需要放在类的最上面，一个类中最多只有一句package。
2. import指令位置放在package的下面，在类定义前面，可以有多句且没有顺序要求。

2. 访问修饰符

1. 基本介绍

1. 公开级别：用public修饰，对外公开
2. 受保护级别：用protected修饰，对子类和同一个包中的类公开
3. 默认级别：没有修饰符，向同一个包的类公开
4. 私有级别：用private修饰，只有类本身可以访问，不对外公开

2. 注意事项

1. 修饰符可以用来修饰类中的属性，成员方法以及类
2. 只有默认的和public才能修饰类，并且遵循上述访问权限的特点

3. 封装

封装就是把抽象出的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作【方法】，才能对数据进行操作。

1. 封装的理解和好处

1. 隐藏实现细节
2. 可以对数据进行验证，保证安全合理

2. 封装的实现步骤

1. 将属性进行私有化（private）【不能直接修改属性】
2. 提供一个公共（public）的set方法，用于对属性判断并赋值

public void setXxx(类型 参数名){//加入数据验证的业务逻辑属性 = 参数名;
}

1. 提供一个公共的get方法，用于获取属性的值

public XX getXxx(){//权限判断return xx;
}

3. 案例一

那么在java中如何实现这种类似的控制呢?
请大家看一个小程序(com.edu.encap: EncapsulationO1.java),不能随便查看人的年龄，工资等隐私，并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认年龄，必须在1-120,年龄，工资不能直接查看，name的长度在2- 6字符之间。

package com.edu.encap;public class Encapsulation01 {public static void main(String[] args) {Person person = new Person();person.name = "薄情人";person.setAge(3000);person.setSalary(5000);System.out.println("姓名：" + person.getName() + " 年龄：" + person.getAge() + " 工资：" + person.getSalary());}}//那么在java中如何实现这种类似的控制呢?
//请大家看一个小程序(com.hspedu.encap: EncapsulationO1.java),不能
//随便查看人的年龄，工资等隐私，并对设置的年龄进行合理的验证。年龄合理
//就设置，否则给默认年龄，必须在1-120,年龄，工资不能直接查看，
//name的长度在2-6字符之间class Person {public String name;private int age;private int salary;public String getName() {return name;}public void setName(String name) {if (name.length() >= 2 && name.length() <= 6) {this.name = name;} else {System.out.println("输入的名字不符合要求，长度应在2-6之间，默认名字为：未名人");this.name = "未名人";}}public int getAge() {return age;}public void setAge(int age) {if (age >= 1 && age <= 120) {this.age = age;} else {System.out.println("输入的年龄不符合要求，年龄大小应在1-120之间，默认年龄为18");this.age = 18;}}public int getSalary() {return salary;}public void setSalary(int salary) {this.salary = salary;}
}

4. 将构造器与setXxx结合

如果直接使用构造器进行赋值的话，那么在setXxx里面实现的业务逻辑就失效了，对此我们可以将构造器与setXxx相结合

普通构造器

public Person(String name, int age, int salary) {this.name = name;this.age = age;this.salary = salary;}

与setXxx结合的构造器

    public Person(String name, int age, int salary) {//        this.name = name;
//        this.age = age;
//        this.salary = salary;setName(name);setAge(age);setSalary(salary);}

5. 案例二

com.edu.encap: TestAccount.java和Account.java
创建程序在其中定义两个类: Account和TestAccount类体会Java的封装性。

1. Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须> 20)、
   密码(必须是六位) , 如果不满足，则给出提示信息，并给默认值
2. 通过setXxx的方法给Account的属性赋值。
3. 在TestAccount中测试

Account

package com.edu.encap;/*** com.edu.encap: AccountTest.java和Account.java* 创建程序在其中定义两个类: Account和AccountTest类体会Java的封装性。* 1.Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须> 20)、* 密码(必须是六位) , 如果不满足，则给出提示信息，并给默认值* 2.通过setXxx的方法给Account的属性赋值。* 3.在AccountTest中测试*/public class Account {private String name;private int balance;private String pwd;public Account() {}public Account(String name, int balance, String pwd) {this.setName(name);this.setBalance(balance);this.setPwd(pwd);}public String getName() {return name;}public void setName(String name) {if (name.length() >= 2 && name.length() <= 4) {this.name = name;} else {System.out.println("名字长度应该在2-4个字符之间，默认名字为：无名");this.name = name;}}public int getBalance() {return balance;}public void setBalance(int balance) {if (balance > 20) {this.balance = balance;} else {System.out.println("余额必须要大于20，默认余额为：0");this.balance = 0;}}public String getPwd() {return pwd;}public void setPwd(String pwd) {this.pwd = pwd;}public void getInfo() {System.out.println("账户信息：姓名：" + name + " 余额：" + balance + " 密码：" + pwd);}}

TestAccount

package com.edu.encap;public class TestAccount {public static void main(String[] args) {Account account = new Account();account.setName("fickler");account.setBalance(670);account.setPwd("123456");account.getInfo();}}

4. 继承

1. 为什么需要继承

我们编写了两个类，一个是Pupil类（小学生），一个是Graduate（大学毕业生）。
问题：两个类的属性和方法有很多相同的，怎么办？
继承（代码复用性）

2. 继承基本介绍和示意图

继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

3. 继承的基本语法

class 子类 extends 父类 {}

1. 子类就会自动拥有父类定义的属性和方法
2. 父类又叫超类、基类
3. 子类又叫派生类

4. 继承带来的遍历

1. 代码的复用性提高了
2. 代码的扩展性和维护性提高了

5. 继承的细节

1. 子类继承所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性不能在子类直接访问，要通过公共的方法区访问。

2. 子类必须调用父类的构造器，完成父类的初始化。

3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的那个构造器完成对父类的初始化工作，否则，编译不会通过。

4. 如果希望指定去调用父类的某个构造器，则显式的调用一下。

5. super在使用时，必须放在构造器的第一行。

6. super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器中。

7. java所有类都是Object类的子类，Object是所有类的基类。

8. 父类构造器的调用不限于直接父类！将一直往上追溯到Object类（顶级父类）。

9. 子类最多只能继承一个父类（指直接继承），即java中是单继承机制。
   10.不能滥用继承，子类和父类之间必须满足is-a的逻辑条件。

6. 继承本质的分析

查找关系

1. 首选看子类是否有该属性
2. 如果子类有这个属性，并且可以访问，则返回信息
3. 如果子类没有这个属性，就看父类有没有这个属性（如果父类有该属性，并且可以访问，就返回信息…）
4. 如果父类没有就按照3的规则，继续找上级父类，直到Object…

7. 案例

案例 ExtendsExercise03.java
编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回
Computer的详细信息
编写PC子类，继承Computer类，添加特有属性[品牌brand
编写NotePad子类，继承Computer类，添加特有属性[color]
编写Test类，在main方法中创建PC和NotePad对象， 分别给对象中特有的属性
赋值，以及从Computer类继承的属性赋值，并使用方法并打印输出信息。

测试类

package com.edu.extend_.improve_;/***案例 ExtendsExercise03.java* 编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回* Computer的详细信息* 编写PC子类，继承Computer类，添加特有属性[品牌brand* 编写NotePad子类，继承Computer类，添加特有属性[color]* 编写Test类，在main方法中创建PC和NotePad对象， 分别给对象中特有的属性* 赋值，以及从Computer类继承的属性赋值，并使用方法并打印输出信息。*/public class ExtendsExercise03 {public static void main(String[] args) {PC pc = new PC("Intel", 16, 500, "dell");System.out.println(pc.getPcDetails());NotePad notePad = new NotePad("Intel", 16, 500, "red");System.out.println(notePad.getNotePadDetails());}}

Computer类

package com.edu.extend_.improve_;//编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回public class Computer {public String CPU;public int memory;public int disk;public Computer(String CPU, int memory, int disk) {this.CPU = CPU;this.memory = memory;this.disk = disk;}public String getCPU() {return CPU;}public void setCPU(String CPU) {this.CPU = CPU;}public int getMemory() {return memory;}public void setMemory(int memory) {this.memory = memory;}public int getDisk() {return disk;}public void setDisk(int disk) {this.disk = disk;}public String getDetails() {return "CPU:" + getCPU() + " 内存：" + getMemory() + " 硬盘：" + getDisk();}}

PC类

package com.edu.extend_.improve_;//编写PC子类，继承Computer类，添加特有属性[品牌brandpublic class PC extends Computer{public String brand;public PC(String CPU, int memory, int disk, String brand) {super(CPU, memory, disk);this.brand = brand;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public String getPcDetails() {return getDetails() + " 品牌：" + brand;}
}

NotePad

package com.edu.extend_.improve_;//编写NotePad子类，继承Computer类，添加特有属性[color]public class NotePad extends Computer{public String color;public NotePad(String CPU, int memory, int disk, String color) {super(CPU, memory, disk);this.color = color;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public String getNotePadDetails() {return getDetails() + " 颜色：" + color;}
}

5. super关键字

1. 基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

2. 基本语法

1. 访问父类的属性，但不能访问父类的private属性

super.属性名;

1. 访问父类的方法，不能访问父类的private方法

super.方法名(参数列表);

1. 访问父类的构造器

super(参数列表);
//只能放在构造器的第一句，只能出现一句！

3. super带来的便利

1. 调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）
2. 当子类中有何父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问时一样的效果！
3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。A->B->C

4. super和this的比较

6. 方法重写/覆盖（override）

1. 基本介绍

简单的说，方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法

2. 注意事项

1. 子类的方法的参数，方法名称，要和父类方法的参数，方法名称完全一样。
2. 子类方法的返回类型和父类返回类型一样，或者是父类返回类型的子类。例如：父类返回类型是Object，子类方法返回类型是String
3. 子类方法不能缩小父类方法的访问权限。

3. 重写和重载的比较

4. 案例

1. 编写一个Person类，包括属性/private (name、age) ，构造器、方法say(返回自我介绍的字符串)
2. 编写一个Student类，继承Person类，增加id、score属性/private, 以及构造器，定义say方法(返回自我介绍的信息)。
3. 在main中，分别创建Person和Student对象，调用say方法输出自我介绍。

test类

package com.edu.override_;/*** 1. 编写一个Person类，包括属性/private (name、age) ，构造器、方法say(返回自我介绍的字符串)* 2. 编写一个Student类，继承Person类，增加id、score属性/private, 以及构造器，定义say方法(返回自我介绍的信息)。* 3. 在main中，分别创建Person和Student对象，调用say方法输出自我介绍。*/public class OverrideExercise {public static void main(String[] args) {Person person = new Person("jack", 10);System.out.println(person.say());Student student = new Student("tom", 20, 0001, 80);System.out.println(student.say());}}

Person类

package com.edu.override_;//编写一个Person类，包括属性/private (name、age) ，构造器、方法say(返回自我介绍的字符串)public class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String say() {return "name= " + name + " age= " + age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

Student类

package com.edu.override_;//编写一个Student类，继承Person类，增加id、score属性/private, 以及构造器，定义say方法(返回自我介绍的信息)。public class Student extends Person{private int id;private double score;public Student(String name, int age, int id, double score) {super(name, age);this.id = id;this.score = score;}public String say() {return super.say() + " id= " + id + " score= " + score;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}
}

7. 多态

1. 基本介绍

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承继承之上的。

2. 对象的多态

1. 一个对象的编译类型和运行类型可以不一致
2. 编译类型在定义对象时，就确定了，不能改变
3. 运行类型是可以变化的
4. 编译类型看定义时 = 号的左边，运行类型看 = 号右边

Animal animal = new Dog();//animal的编译类型是Animal，运行类型是Dog
animal = new Cat();//animal的运行类型变成了Cat，编译类型任然是Animal

3. 多态的细节

多态的前提是：两个对象（类）存在继承关系

多态的向上转型

1. 本质：父类的引用指向了子类的对象
2. 语法：父类类型 引用名 = new 子类类型();
3. 特点：编译类型看左边，运行类型看右边
   可以调用父类中的所有成员（需要遵守访问权限）
   不能调用子类中特有成员
   最终运行效果看子类的具体实现

多态的向上转型

1. 语法：子类类型 引用名 = （子类类型） 父类引用;
2. 只能强转父类的引用，不能强转父类的对象
3. 要求父类的引用必须指向的是当前目标类型的对象
4. 当向下转型后，可以调用子类类型中所有的成员

属性没有重写之说！属性的值看编译类型（= 号的左边）
instanceOf比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

4. 多态的应用

多态数组
数组的定义类型为父类类型，里面保存的实际元素类型为子类类型。

应用实例：现有一个继承结构如下：要求创建1个Person对象，2个Student对象和2个Teacher对象，同一放在数组中，并调用每个对象say方法。

PloryArry类

package com.edu.poly_.polyarry_;public class PloryArray {public static void main(String[] args) {Person[] person = new Person[5];person[0] = new Person("jack", 20);person[1] = new Student("jack", 19, 100);person[2] = new Student("smith", 18, 59);person[3] = new Teacher("scott", 30, 20000);person[4] = new Teacher("king", 50, 25000);for (int i = 0; i < person.length; i ++ ) {System.out.println(person[i].say());}}}

Person类

package com.edu.poly_.polyarry_;public class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String say() {return name + "/t" + age;}
}

Teacher类

package com.edu.poly_.polyarry_;public class Teacher extends Person {private double salary;public Teacher(String name, int age, double salary) {super(name, age);this.salary = salary;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}@Overridepublic String say() {return super.say() + " salary=" + salary;}
}

Student类

package com.edu.poly_.polyarry_;public class Student extends Person{private double score;public Student(String name, int age, double score) {super(name, age);this.score = score;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}@Overridepublic String say() {return super.say() + " score=" + score;}
}

应用实例升级:如何调用子类特有的方法，比如Teacher有一个teach，Student有一个study怎么调用?

     for (int i = 0; i < person.length; i ++ ) {System.out.println(person[i].say());if (person[i] instanceof Student) {((Student) person[i]).study();} else if (person[i] instanceof Teacher) {((Teacher) person[i]).teach();} else {System.out.println("出现错误！！！");}}

多态参数
方法定义的形参类型为父类类型，实参类型运行为子类类型

定义员工类Employee,包含姓名和月工资[private]，以及计算年工资getAnnual的方法。普通员工和经理继承了员工，经理类多了奖金bonus属性和管理manage方法，普通员工类多了work方法，普通员工和经理类要求分别重写getAnnual方法
测试类中添加一一个方法showEmpAnnal(Employee e),实现获取任何员工对象的年工资，并在main方法中调用该方法[e.getAnnual()]
测试类中添加一个方法，testWork 如果是普通员工，则调用work方法，如果是经理，则调用manage方法

package com.edu.poly_.polyarameter;public class Polyarameter {public static void main(String[] args) {Worker tom = new Worker("tom", 2500);Manager milan = new Manager("milan", 5000, 200000);Polyarameter polyarameter = new Polyarameter();polyarameter.showEmpAnnual(tom);polyarameter.showEmpAnnual(milan);polyarameter.testWork(tom);}public void showEmpAnnual(Employee e) {System.out.println(e.getAnnual());}public void testWork(Employee e) {if (e instanceof Worker) {((Worker) e).work();} else if (e instanceof Manager) {((Manager) e).manage();} else {System.out.println("不做处理！");}}}

8. Object类的详解

1. equals方法

1. ==：既可以判断基本类型，又可以判断引用类型
2. ==：如果判断基本类型，判断的是值是否相等
3. ==：如果判断引用类型，判断的是地址是否相等，即判断是不是同一个对象
4. equals：是Object类中的方法，只能判断引用类型
5. 默认判断是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

2. hashcode方法

返回该对象的哈希值，提高哈希表的效率。

1. 提高具有哈希结构的容器的效率。
2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的。
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的。
4. 哈希值主要是根据地址号来的，但不能完全将哈希值等价于地址。

案例

3. toString方法

返回该对象的字符串表示

基本介绍
默认返回：全类名+@+哈希值的十六进制


当直接输出一个对象的时候，toString会默认调用

4. finalize方法

1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作。
2. 什么时候被回收：当某个对象没用任何引用时，则jvm就认为直观对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。（此时，程序员可以在finalize方法中写一些业务逻辑，来再对象销毁之前执行 ---- 释放资源）
3. 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动触发垃圾回收机制。

Java 第一阶段建立编程思想 【面向对象编程（中级部分）】相关推荐

1. Java 第一阶段建立编程思想 【房屋出租系统】

   Java 第一阶段建立编程思想 [房屋出租系统] 1. 项目需求说明 2. 项目界面 1. 主菜单 2. 新增房源 3. 查找房源 4. 删除房源 5. 修改房源 6. 房屋列表 7. 退出系统 3. ...

2. java第一阶段（day05）面向对象

   回顾 方法 为什么使用方法?1. 都放在一个方法中 代码量过多 一个方法里面代码量<=802. 提取重复的代码 封装成一个单独的方法 直接多次调用方法即可3. 方法中 调用很多小的方法方法组成部 ...

3. Java基础学习——第六章 面向对象编程(下)

   Java基础学习--第六章 面向对象编程(下) 一.关键词:static 1. static关键字的引入 当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象,只有通过new ...

4. 高阶函数||编程范式: 命令式编程/声明式编程 || 编程范式: 面向对象编程(第一公民:对象)/函数式编程(第一公民:函数)

   编程范式: 命令式编程/声明式编程 编程范式: 面向对象编程(第一公民:对象)/函数式编程(第一公民:函数) 高阶函数 filter/map/reduce filter中的回调函数有一个要求: 必须返 ...

5. Java函数式编程和面向对象编程

   文章目录 什么是函数式编程? 什么是面向对象编程? 函数式编程和面向对象编程的优缺点 什么是函数式编程? 函数式编程的核心:在思考问题时,使用不可变对象和函数,函数将一个值经过处理,映射成另一个值. ...

6. java - 第一阶段总结

   java - 第一阶段总结 递归 递归:能不用就不用,因为效率极低 package over; //递归 public class Fi {public static void main(String ...

7. pthon_函数式编程与面向对象编程的比较

   函数式编程作为结构化编程的一种,正在受到越来越多的重视.工程中不在只是面向对象编程,更多的人尝试着开始使用函数式编程来解决软件工程中遇到的问题. 什么是函数式编程?在维基百科中给出了详细的定义,函数式 ...

8. JavaScript 的函数式编程与面向对象编程区别在哪？

   本文通过代码来看一看JavaScript中函数式编程和面向对象编程的差异. 作者 | Jesse Warden 译者 | 弯月,责编 | 郭芮 出品 | CSDN(ID:CSDNnews) 以下为译文 ...

9. 函数式编程与面向对象编程的优劣

   函数式编程作为结构化编程的一种,正在受到越来越多的重视.工程中不在只是面向对象编程,更多的人尝试着开始使用函数式编程来解决软件工程中遇到的问题. 什么是函数式编程?在维基百科中给出了详细的定义,函数式 ...

10. php控制器面向对象编程,PHP 面向对象编程（2）

    一些内建方法: class Person { public $isAlive = true; function __construct($name) { //这里我们创建了一个name的属性 $thi ...

最新文章

1. git操作手册_基本的Git手册
2. Attention is All You Need？LSTM提出者：我看未必
3. 【排序算法】图解桶排序
4. os.chdir 的作用是什么_为什么宝宝有事都愿意找妈妈？爸爸也要尽到责任才行
5. Python 69个内置函数分8类总结，这样记更方便！
6. 如何衡量两个词的相关度
7. 前端学习（1923）vue之电商管理系统电商系统之说明角色要完成的功能
8. 操作系统内存管理问题集锦
9. ubuntu 使用apt-get install安装特定版本
10. sql server 登录与用户绑定
11. tensorboard 使用
12. 被封杀4年的看片神器终于解禁了，要跟百度网盘抢生意？
13. OpenDDS典型idl举例（系统）
14. 嵌入式硬件：电子元器件(1)电阻电容电感
15. word批量修改图片的大小
16. 宝塔一键安装部署tipask登录出现错误：The email must be at least 8 characters怎么回事
17. Eclipse超棒的主题，你不能错过！
18. 中秋节活动中奖名单公布啦！！
19. 用Python每天自动给女朋友免费发短信，谁说程序员不懂浪漫？
20. MagikEye将在CES上展示Invertible Light™图像传感器技术

热门文章

1. 全基因组关联分析学习资料（GWAS tutorial）20210313更新版
2. 办公软件的安装，简单操作进行安装office操作步骤。
3. 阿里云云安全理工程师认证 部分题目 ACA
4. 网络安全笔记-99-渗透-业务安全
5. 计算机工程好发论文么,计算机工程期刊发表论文有什么要求
6. 《计算机工程》投稿经验分享
7. 嘟嘟噜~~~第一次写博，纪念一下
8. 婚姻生活，艰难困苦中，水深火热中
9. bootstrap table合并单元格
10. strut2的学习笔记