面向对象

面向对象

面向对象思想：面向对象是基于面向过程的编程思想。

​ 面向过程：强调的是每一个功能的步骤

​ 面向对象：强调的是对象，然后由对象去调用功能

面向对象特点：是一种更符合我们思想习惯的思想；可以将复杂的事情简单化；将我们从执行者变为指挥者。

面向对象开发：就是不断创建对象，使用对象，指挥对象做事情。

面向对象设计：管理和维护对象之间的关系。

面向对象特征：

  1. 封装（encapsulation）

  2. 继承(inheritance)

  3. 多态(polymorphism)

完成某个需求时：

  1. 分析有哪些类：UML（统一建模语言），名词提取法。

  2. 每个类都有哪些东西：属性，方法

  3. 类与类之间的关系是什么：耦合

类与对象的关系

java中最基本的单位是类。

类：一组相关的属性和行为的集合，是一个抽象的概念。

事物就是通过类来体现出来。事物是由属性（该事务的描述信息）和行为（该事务能做什么）组成。

对应类中为：成员变量和成员方法。

对象：是该类事物的具体实现形式，具体存在的个体。

​ 成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外。

​ 成员方法：和以前的方法定义是一样的格式，但是把static去掉。

如何使用类及类中的属性和行为呢：创建该类的一个对象使用。

格式： 类名 对象名=new 类名（）;

如何使用成员变量： 对象名.变量名

如何使用成员方法： 对象名.方法名(参数…)

匿名对象：就是没有名字的对象。

应用场景：

A：调用方法：仅仅只调用一次的时候（若多次调用，不适合）

优点：匿名对象调用是在堆内存中，调用完毕就是垃圾，可以被垃圾回收器回收

B：匿名对象可以作为实际参数传递。（当方法中的形式参数是一个引用类型比如类的时候，实际参数可以用匿名对象当作该类的一个对象）

封装

通过对象给成员变量赋值，可以赋值一些非法的数据，这是不合理的。

在赋值之前，应该先对数据进行判断。怎么进行判断呢？就是写一个方法对数据进行校验。但是不用方法就起不到作用了。所以要求必须使用方法，不能直接调用成员变量。

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式。

原则：将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

优点：隐藏实现细节，提供公共的访问方式；提高了代码的复用性；提高安全性。

private：私有的，是一个权限修饰符，可以修饰成员变量和成员方法。

被private修饰的成员只能在本类中访问。

最常见的应用：把成员变量用private修饰，提供对应的getXxx（）/setXxx（）方法以使外界可以访问

this关键字：this代表所在当前类的一个对象引用。

方法被哪个对象调用，this就代表那个对象。

用this的场景：当局部变量隐藏成员变量时，成员变量可能被局部变量覆盖无意义，所以要用this。 super

构造方法

作用：给对象的数据进行初始化

格式：方法名和类名相同。没有返回值，连void都没有。没有具体的返回值。

注意事项：如果不提供构造方法，系统会给出默认的构造方法

如果提供了构造方法，系统将不再提供默认的构造方法。如果还想使用无参构造方法，就必须自己给出，建议永远自己给出无参构造方法。

构造方法也可以重载。

给成员变量赋值有2种方法：

A. 无参构造方法+setXxx();

B. 带参构造方法

类中包含有：成员变量、成员方法、构造方法。

成员方法

根据返回值可以分为：void类型和非void类型。

根据形式参数：空参方法和非空参方法。

Student s=new Student();在内存中发生了什么？

  1. 加载Student.class文件进内存

  2. 在栈内存为s开辟空间

  3. 在堆内存为学生对象开辟空间

  4. 对学生对象的成员变量进行默认初始化。null 0 0.0 \u0000

  5. 对学生对象的成员变量进行显式初始化

  6. 通过构造方法对学生对象的成员变量赋值

  7. 学生对象初始化完毕，把对象地址赋值给s变量。

当一个变量是用来描述类的信息时，这个变量就应该被定义为成员变量。（成员变量不要瞎定义）

变量的范围是越小越好，因为能及时的被回收。

当多个对象有共同的成员变量值的时候，java就提供了一个关键字来修饰：static。

static可以修饰成员变量和成员方法。

static关键字的特点：随着类的加载而加载；优先于对象存在；被类的所有对象共享（这也是我们判断是否使用静态关键字的条件）；可以通过类名调用（其实本身也可以通过对象名调用，推荐使用类名调用）静态修饰的内容我们一般称为与类相关的，类成员

注意事项：在静态方法中是没有this关键字的（因为静态是随着类的加载而加载，而this是随着对象的创建而存在，静态比对象先存在）

静态方法只能访问静态的成员变量和静态的成员方法。(main方法是静态方法，不能调用非静态方法，如果想调用的话，可以先在main方法中创建一个对象，通过这个对象来调用非静态方法)

非静态方法可以访问静态的成员变量和成员方法，也可以访问非静态的成员变量和成员方法。

静态变量和成员变量的区别：

所属不同：静态变量属于类，也被称为类变量

​ 成员变量属于对象，也被称为实例变量（对象变量）

内存中的位置不同：静态变量存储于方法区的静态区

​ 成员变量存储于堆内存中

内存出现的时间不同：静态变量随着类的加载而加载，随着类的消失而消失

​ 成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同：静态变量可以通过类名调用，也可以通过对象名调用

​ 成员变量只能通过对象名调用

main方法的格式讲解：

public:公共的，访问权限是最大的。由于main方法是被jvm调用的，所以权限要够大。

static:静态的，不需要创建对象，通过类名就可以调用，方便jvm的调用。

void:方法的返回值是返回给调用者，而main方法是被jvm调用的，返回给jvm无意义。

main：是一个常见的方法入口，所有语言都是以main方法为入口

String[] args:这是一个字符串数组。这个东西早期是为了接收键盘录入的数据的。

eg：java 类名 hello world java 遍历args就会发现是 hello world java

后来用java.util.Scanner代替了

测试类的作用：创建其他类的对象，调用其他类的功能。

在同一个文件夹下，类定义在两个文件中和定义在一个文件中其实一样的。

静态的一种用法：在工具类中，将构造方法私有化，这样外界无法创建该类的对象，然后将要调用的方法static静态化，这样main方法调用时候只能通过类名.方法名调用。

项目提供的都是class文件，无从得知class文件内都有哪些方法哪些属性。所以需要加说明书。

说明书的制作：

A：写一个工具类

B：对这个类加文档注释：

/**

*@author

*@version

*@param

*return

*/

C:用工具解析文档注释：javadoc工具

D：格式：

javadoc -d (文件夹的路径) -author -version (类名).java

制作帮助文档出错：找不到可以文档化的公共或受保护的类。告诉我们类的权限不够。（若想权限够，在class前加public）

所以以后开发可以利用工具类加说明书，对该类中实现的方法的static、返回值、方法名、参数注意然后就可以调用使用，对怎么实现的方法不用在意，这就是面向对象思想。

.html转换为帮助文档就是.chm文档

使用帮助文档API（Application Progaramming Interface,应用程序编程接口）：

  1. 打开帮助文档

  2. 点击显示，找到索引，找到输入框

  3. 明确要找什么

  4. 在输入框内输入要查找的类，回车

  5. 看包，java.lang包下的类不需要导入，其他的都需要全部导入

  6. 再简单的看看类的解释和说明，类的版本信息

  7. 看类的结构

    成员变量：字段摘要

    构造方法：构造方法摘要

    成员方法：方法摘要

  8. 学习构造方法

    有构造方法：创建对象

    无构造方法：成员可能都是静态的

  9. 看成员方法：

    静态、返回值类型、方法名、参数列表。

代码块：在java中使用｛｝括起来的代码称为代码块，根据其声明和位置不同，可以分为局部代码块，构造代码块，静态代码块和同步代码块。

局部代码块：局部位置，在方法中出现，限定变量生命周期，及早释放，提高内存利用率。

构造代码块：在类中成员位置出现（直接｛｝括起来），每次调用构造方法都执行，并且在构造方法前执行。

作用：可以把多个构造方法方法中相同的代码存放到一起。

静态代码块：在类中成员位置出现（直接｛｝括起来），｛前面加了static修饰。在加载的时候就执行，且只执行一次。

作用：用于给类进行初始化。

一个类中的执行顺序：与书写顺序无关，执行时都是这个顺序

静态代码块（只执行一次，加载类的时候就执行）–构造代码块（每次调用构造方法都执行）–构造方法

Math类：是针对数学进行操作的类，没有构造方法，成员都是静态的。

产生随机数：public static double random(): [0.0,1.0)

产生1-100的随机数：int number=(new)(Math.random()*100)+1;

继承

多个类的成员变量，成员方法等都是相同的。每一次定义的时候都需要重新定义一遍，所以要考虑改进，提高代码的复用性，用继承。

多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可。

格式：

class 子类名 extends 父类名{}

单独的这个类称为父类，基类，超类。

多个类称为子类，派生类。

优点：提高了代码的复用性：多个类相同的成员可以放到同一个类中

提高了代码的维护性：如果功能的代码需要修改，修改一处即可。

让类与类之间产生了关系，是多态的前提。（也是继承的弊端：类的耦合性很强）

开发的原则：低耦合，高内聚。

耦合：类与类的关系

内聚：自己完成某件事情的能力

继承的特点：

\1. java中只支持单继承，不支持多继承。（C++支持多继承，格式：extends 类1，类2…）

\2. java支持多层继承（继承体系）

继承的注意事项：

\1. 子类只能继承父类所有非私有的成员（成员方法和成员变量），也体现了继承的一个弊端：打破了封装性

\2. 子类不能继承父类的构造方法，但是可以通过super关键字来访问父类的构造方法

\3. 不要为了部分功能而去继承（当类与类之间的关系是“is a”的关系时使用继承）子类is父类的a

子类中的成员变量和父类中的成员变量如果一样的话，再调用时候遵循就近原则。

在子类方法中访问一个变量的查找顺序：1.在子类方法的局部范围找，有就用

2.在子类的成员范围找，有就用

\3. 在父类的成员范围找（不可能在父类的方法局部范围找，因为方法不调用不执行，相当于没有）

super关键字：super代表父类存储空间的标识（父类引用，可以操作父类的成员，但不是父类的一个对象，只是父类的一个存储空间）

this代表本类对象的引用

用法：

A. 调用成员变量：

this.成员变量：调用本类的成员变量

super.成员变量：调用父类的成员变量

B. 调用构造方法：

this（…）：调用本类的构造方法

super（…）：调用父类的构造方法

C. 调用成员方法：

this.成员方法：调用本类的成员方法

super.成员方法：调用父类的成员方法

继承中构造方法的关系：子类中所有的构造方法默认都会先访问父类中空参数的构造方法。

因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化。每一个构造方法的第一条语句默认都是super（）;

如果父类没有无参构造方法，那么子类的构造方法会出现报错。（这就是为什么建议构造方法永远手动给个无参的构造方法）

解决方法：A.在父类中加一个无参构造方法

B.子类通过super(…)去显示调用父类其他的带参的构造方法。

C. 子类通过this去调用本类的其他构造方法,但是一定会有一个去访问了父类的构造方法。

子类中一定要有一个去访问了父类的构造方法，否则父类的数据就没有初始化。

注意事项：this（）或者super（）必须出现在第一条语句上。如果 不是放在第一条语句上，就可能会对父类数据进行了多次初始化。

一个类的初始化过程：成员变量进行初始化（默认初始化，显示初始化），构造方法初始化

子父类的初始化（分层初始化）先进行父类初始化，再进行子类初始化。虽然子类中构造方法默认有一个super() ，但是初始化的时候不是按照那个顺序的，而是按照分层初始化进行的。super()只是表示要先初始化父类数据在初始化子类数据。

继承中成员方法的关系：通过子类对象去访问一个方法，首先在子类中找，然后在父类中找，如果没有就报错（不会去父类的父类中找）

方法重写（方法覆盖，方法复写）：子类中出现了和父类中方法声明一模一样的方法。

方法重载：本类中出现的方法名一样，参数列表不同的方法，与返回值无关。

方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父类中的方法（重写是完全重写，如果还想用父类中的方法内容，可以用super调用），这样，既沿袭了父类的功能，又定义了子类特有的功能。

注意事项：父类中私有方法不能被重写。（其实父类中私有方法子类根本就无法继承，更谈不上重写）

子类重写父类方法时，访问权限不能更低。（最好就一致）

父类是静态方法，子类也必须通过静态方法进行重写。（其实不算方法重写）

父类不是静态，子类用static静态，会报错。

所以，子类重写父类方法的时候，最好声明一模一样。

由于继承中方法有一个方法重写，所以父类的功能会被子类覆盖，当不想让覆盖的时候，java提供了一个关键字：final

final：最终的意思。可以修饰类、方法、变量。

final可以修饰类：该类不能被继承

final可以修饰方法：该方法不能被重写

final可以修饰变量：该变量不能被重新赋值。这个变量其实是常量。

final修饰局部变量（一般权限修饰符修饰局部变量无意义，但是final特殊）：在方法内部，该变量不能被改变。

在方法声明上，基本类型是值不能被改变。引用类型是地址值不能被改变，但是该对象的堆内存的值还可以改变，注意区别。

final修饰变量的初始化时机：

1.被final修饰的变量只能赋值一次

2.在初始化时就给值（建议）或者在构造方法完毕前给值（非静态的常量）。

*多态*

多态：同一个对象，在不同时刻体现出不同的状态。

判断多态可以从左往右念：子是父？是的话可以多态，不是的话不能。

多态的前提：

A. 要有继承或者实现关系。

B. 要有方法重写。（如果没有方法重写也是可以的，但是就没有了意义）

C. 要有父类或者父接口引用指向子类对象。

父 f=new 子();

多态中的成员访问特点：

A. 成员变量：编译看左边（父类），运行看左边。

B. 构造方法：创建子类对象的时候，访问父类的构造方法，并对父类的数据进行初始化。

C. 成员方法：编译看左边（父类），运行看右边（方法重写相当于覆盖了）。

D. 静态方法：编译看左边（父类），运行看左边。（所以说静态方法的重写根本不算是重写）

由于成员方法存在方法重写，所以只有它运行的时候看右边。

多态的好处：

A. 提高了代码的维护性（继承保证）

B. 提高了代码的扩展性（由多态保证，以后如果在添加父类的子类，可以使用父类的引用调用工具类，便于代码的扩展性）

多态的弊端：不能使用子类的特有功能。

如果非要调用子类的这些功能：

A. 创建子类的对象调用方法。（可以，但是不合理，太占内存）

B. 把父类的引用强制转换为子类的引用。（向下转型）

Fu f=new Zi(); (向上转型，从子到父，父类引用指向子类对象)

Zi z=(Zi)f; （向下转型，从父到子，父类引用转为子类对象） 要求f必须是能够转换为Zi的。

ClassCastException：类型转换异常，一般在多态的向下转型中容易出现。

当一个类中的东西特别多时，我们可以把这个类分成几个小类：基本类、操作类等。

分包：A.功能划分

B.模块划分

C.先按模块划分，再按功能划分

集合实现，IO实现，GUI实现，数据库实现。

如果一个方法传的参数是三个以上，建议传个对象。

如果多个地方用到了某个变量，可以把这个变量定义为成员变量，定义在成员方法外。

能小范围尽量不大范围，因为用完最好回收。

让多个对象共享同一个成员变量，用static修饰。

循环里面如果有switch，并且在其中有break，结束的不是循环，而是switch语句，如果想结束整体，可以用 System.exit(0);

展开全文 >>

关于null

开发原则：只要是对象，我们就要判断对象是否为null。

java空指针异常：java.lang.NullPointException

java中的null

null是Java中一个很重要的概念。null设计初衷是为了表示一些缺失的东西，例如缺失的用户、资源或其他东西。但是，一年后，令人头疼的空指针异常给Java程序员带来不少的骚扰。

null是java中的关键字，因此，它不能写成NULL，Null，只能是null。

null是所有引用类型的默认值，如果没有让一个引用指向一个实际存在的对象，它的默认值就是null。null本质上是一个值，这跟int的默认值是0，boolean的默认值是false一样。现在，我们通常都使用像eclipse等的集成开发环境进行开发，一般在定义变量的时候都会进行初始化（这也是写代码的一个良好的习惯），如果没有进行初始化，系统会进行提示。

报空指针异常的原因有以下几种：

1.字符串变量未初始化；

初始化或赋值后则不会报错了
2.接口类型的对象没有用具体的类初始化，比如：
List it；会报错
List it = new ArrayList()；则不会报错了
3.当一个对象的值为空时，你没有判断为空的情况。你可以试着把下面的代码前加一行代码：
if(rb!=null && rb!=””)
改成：
if(rb == null) 或者 if(“”).equals(rb))
空指针的解决办法：
重点关注报错发生的所在行，通过空指针异常产生的两条主要原因诊断具体的错误。同时为了避免空指针的发生，最好在做判断处理时将“null”或者空值放于设定的值之前。
常见空指针异常的简要分析：
（1）空指针错误
Java中的8种基本数据类型，变量的值可以有其默认值，假如没有对其正常赋值，java虚拟机是不能正确编译通过的，因此使用基本的Java数据类型一般是不会引起空指针异常的。实际开发中，大多数的空指针异常主要与对象的操作相关。
下面列出可能发生空指针异常的几种情况及相应解决方案：
代码段1：
　　out.println(request.getParameter(“username”));
分析：代码段1的功能十分简单，就是输出用户输入”username”的值。
说明：看上去，上面的语句找不出什么语法错误，而且在大多数情况下也遇不到什么问题。但是，如果某个用户在输入数据时并没有提供表单 域”username” 的值，或通过某种途径绕过表单直接输入时，此request.getParameter(“username”)的值为空（注意不是空字符串，是空对象 null。），out对象的println方法是无法直接对空对象操作的，因此代码段1所在的JSP页面将会抛出 “Java.lang.NullPointerException”异常。而且即使对象可能为空时，也调用Java.lang.Object或 Object对象本身的一些方法如toString()， equal(Object obj)等操作。
代码段2：
　　String userName = request.getParameter(“username”);
　　If (userName.equals(“root”))
　　{….}
分析：代码段2的功能是检测用户提供的用户名，如果是用户名称为”root”的用户时，就执行一些特别的操作。
说明：在代码段2中，如果有用户没有提供表单域”username”的值时，字符串对象userName为null值，不能够将一个null的对象与另一 个对象直接比较，同样，代码段2所在的JSP页面就会抛空指针错误。

一个小技巧：如果要把某个方法的返回值与常量做比较，把常量放在前面，可以避免调用null对象的equals方法。譬如：
If (“root”.equals(userName))
　 {….}
即使userName对象返回了null对象，这里也不会有空指针异常，可以照常运转。
代码段3：
　　String userName = session.getAttribute(“session.username”).toString();
分析：代码段3的功能是将session中session.username的值取出，并将该值赋给字符串对象userName。
说明：在一般情况下，如果在用户已经进行某个会话，则不会出现什么问题；但是，如果此时应用服务器重新启动，而用户还没有重新登录，（也可能是用户关闭浏 览器，但是仍打开原来的页面。）那么，此时该session的值就会失效，同时导致session中的session.username的值为空。对一个 为 null的对象的直接执行toString()操作，就会导致系统抛出空指针异常。
代码段4：
public static void main(String args[]){
Person p=null;
p.setName(“张三”)；
System.out.println(p.getName());
}
分析：声明一个Person对象，并打印出该对象的中的Name名字。
说明：这个时候你的p就出现空指针异常，因为你只是声明了这个Person类型的对象并没有创建对象，所以它的堆里面没有地址引用，切忌你要用对象调用方法的时候一定要创建对象。

为了避免空指针调用，我们经常会看到这样的语句

1
2
...if (someobject != null) {
    someobject.doCalc();}...

最终，项目中会存在大量判空代码，多么丑陋繁冗！如何避免这种情况？我们是否滥用了判空呢？

在方法中返回null，在调用这些方法时，也不得不去判空。另外，也许受此习惯影响，他们总潜意识地认为，所有的返回都是不可信任的，为了保护自己程序，就加了大量的判空

进行判空前，请区分以下两种情况：

1、null 是一个有效有意义的返回值(Where null is a valid response in terms of the contract)

2、null是无效有误的(Where it isn’t a valid response)

先说第2种情况

null就是一个不合理的参数，就应该明确地中断程序，往外抛错误。这种情况常见于api方法。例如你开发了一个接口，id是一个必选的参数，如果调用方没传这个参数给你，当然不行。你要感知到这个情况，告诉调用方“嘿，哥们，你传个null给我做甚”。

相对于判空语句，更好的检查方式有两个

(1)assert语句，你可以把错误原因放到assert的参数中，这样不仅能保护你的程序不往下走，而且还能把错误原因返回给调用方，岂不是一举两得

(2)也可以直接抛出空指针异常。上面说了，此时null是个不合理的参数，有问题就是有问题，就应该大大方方往外抛。

第1种情况会更复杂一些。

这种情况下，null是个”看上去“合理的值，例如，我查询数据库，某个查询条件下，就是没有对应值，此时null算是表达了“空”的概念。

这里给一些实践建议：

1、假如方法的返回类型是collections，当返回结果是空时，你可以返回一个空的collections（empty list),而不要返回null，这样调用侧就能大胆地处理这个返回，例如调用侧拿到返回后，可以直接print list.size()，又无需担心空指针问题。（什么？想调用这个方法时，不记得之前实现该方法有没按照这个原则？所以说，代码习惯很重要！如果你养成习惯，都是这样写代码（返回空collections而不返回null)，你调用自己写的方法时，就能大胆地忽略判空）

2、返回类型不是collections，又怎么办呢？

那就返回一个空对象（而非null对象），下面举个“栗子”，假设有如下代码

1
2
3
4
5
public interface Action {
  void doSomething();}

public interface Parser {
  Action findAction(String userInput);}

其中，Parse有一个接口FindAction，这个接口会依据用户的输入，找到并执行对应的动作。假如用户输入不对，可能就找不到对应的动作（Action），因此findAction就会返回null，接下来action调用doSomething方法时,就会出现空指针。

解决这个问题的一个方式，就是使用Null Object pattern（空对象模式）

我们来改造一下

类定义如下，这样定义findAction方法后，确保无论用户输入什么，都不会返回null对象

1
2
3
4
5
6
7
8
9
10
11
public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* do nothing */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* we can't find any actions */ ) {
      return DO_NOTHING;
    }
  }}

对比下面两份调用实例

1、冗余:每获取一个对象，就判一次空

1
2
3
4
5
6
7
8
9
10
11
Parser parser = ParserFactory.getParser();
if (parser == null) {
  // now what?
  // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
  // do nothing
} else {
  action.doSomething();
}

2、精简

1
ParserFactory.getParser().findAction(someInput).doSomething();

因为无论什么情况，都不会返回空对象，因此通过findAction拿到action后，可以放心地调用action的方法。

其他回答精选：

1、如果要用equal方法，请用object<不可能为空>.equals(object<可能为空>))

例如：

使用

1
"bar".equals(foo)

而不是

1
foo.equals("bar")

2、Java8或者guava lib中，提供了Optional类，这是一个元素容器，通过它来封装对象，可以减少判空。不过代码量还是不少。不爽。

3、如果你想返回null，请挺下来想一想，这个地方是否更应该抛出一个异常

null与””的区别

null是没有地址
“”是有地址但是里面的内容是空的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
问题一：
null和""的区别
String s=null;
string.trim()就会抛出为空的exception   
String s="";   
string.trim()就不会抛,为什么? 
答：
NULL代表声明了一个空对象，根本就不是一个字符串。   
""代表声明了一个对象实例，这个对象实例的值是一个长度为0的空字符串。

NULL代表声明了一个空对象,对空对象做任何操作都不行的,除了=和==   
""是一个字符串了,只是这个字符串里面没有内容了

String s=null;只是定义了一个句柄，也就是说你有了个引用，但是这个引用未指向任何内存空间   
String s="";这个引用已经指向了一块是空字符串的内存空间，是一个实际的东东了，所以你可以对它操作，而不用担心什么了

你说数字0和没有是不是一种概念啊？？道理一样的

而且,null可以赋值给任何对象.""就不行了.

这里""和NULL绝对是两个概念   
""代表一个字符串存在，它的值就是“”   
NULL代表字符串根本没有实际的值，你并不知道它是什么。。。

哦,我明白了,意思就是String   string   =   null   跟String   string;是一回事儿

null是空对象     ""是空字符串
String s=null;//null是未分配堆内存空间   
String   a;//分配了一个内存空间,没存入任何对象   
String   a="";//分配了一个内存空间,存了一个字符串对象



问题二：
String s;和String s=null;和String s="a";有什么区别？   
针对这三种情况，使用out.println(s);的时候，第一个会出现异常，第二个会输出null.第三个则会输出a.   
这是为什么呢？这三句声明语句，各自作了什么呢？

答：
第一个只是定义了一个String类型变量s，并没有给它赋初值，在Java中，默认在使用一个变量的时候必须赋予它初值（降低风险）。 
第二个和第三个都定义了String类型变量s，并赋予它初值，只不过第二个赋予的值为null（空）罢了

主要要理解的是String s; s为一个引用～～它不是对象   
第一个是没有初始化的引用；   
第二个为空引用；
第三个是在字符串池里写入一个字符'a',然后用s指向它。
另外，   
String s="a"和String s=new String("a");是有本质上的区别的   
前者是在字符串池里写入一个字符'a',然后用s指向它；
后者是在堆上创建一个内容为"a"的字符串对象。
String   str="aaa";                    //于栈上分配内存
String   str=new   String("aaa");      //于堆上分配内存

String s; 系统会自动赋值null

String s;只是给s分配一个内存空间   
String s=null;是分配的空间中存储的值为空值   
String s="a";是分配的空间的值为字符a



问题三：
声明了一个string a;变量    
在以后的判断中，a==""和a==null有何不同?   

答：
如果没有给a赋过值，a==""会导致异常。     
在实际处理时，往往认为""和null代表相同的含义，即都代表无值。   
此时建议用如下语法：   
if(a==null   ||   a=="")   
{   
}   
如果a为null，就不会执行后面的判断，直接返回true。   

null是用来判断引用类型是否分配了存储空间   
""是针对字符串的；   
string类型实际上是字符串指针，也即是一个引用类型   
所以如果没有给a赋过值，a==""会导致异常   
所以if(a==null   ||   a==""){}这种写法也是正确的


问题四：
String abc=null;String abc="";String abc;三种写法有什么区别？ 

答：
1：创建一个空字符串对象，   
2：创建一个字符串为空的字符串对象。   
3：声明一个字符串对象，但并没有分配内存，而1，2已经分配了内存   
对于最后一种表示,你不能if(abc==null),或者int   length   =   abc.length();编译的时候会提示可能没有初始化.


String   abc=null;   
String   abc="";   
一般推荐使用第二种   
第一种abc指向null，很多时候要判断字符串是否为空时，容易漏掉这种情况，在调用String的相关方法的时候就会出错   
第二种则相对简单，String的方法都可以用，判断的时候也不会出错

1) String   abc=null;   
2) String   abc;    
3）String   a="";   
4) String   b="";   
5) String   c=new String("");   
6) String   d=new String(""); 
//1)等于2），和C语言不同，JAVA为安全原因不允许一个悬挂引用，没有赋值的引用地址一律自动赋值为NULL，以防止访问到任意内存   
//3)和4)中,变量a和b将会指向同一内存地址(""的地址)   
//5)和6)中，变量c和d不会指向同一地址,而是两个""内容的地址,并且和a,b不同,实际上,3)和4)相当于new String("").intern().   
//String类维护着一个字符串池,对于像3)和4)这样的赋值方法,String会在这个池中查找字符串是否已经在池中,如果在,就直接指向该地址,

如果不在,生成一个实例放入池中再指向那个地址,可见对于同样内容的字符串多次引用时3)4)的方法要比5)6)的方法剩内存,之所以这样做,是

因为String是一个内容不可变的量,运用的是设计模式GOF.FlyWeight   




但有个关键的一点,没有人说到，这就是:   
String s;在什么情况下可以等同于String s=null;而在什么情况下又不等同？！
考虑下面的代码:   
//StringTest.java   
public   class   StringTest   {      
    static   String   s;     //*   
    public   static   void   main(String[]   args)   {   
        //String   s;         //**   
        System.out.println(s);   
    }   
}     
编译并运行上面的代码,将打印null。
可见标有*号的行是自动初始化了的(s被自动初始化为null)。   
而如果把标有**号的行取消注释,代码将不能通过编译,这是因为这行定义的是本地变量,而本地变量是不会自动初始化的。
由此得出结论：
在成员变量的定义中,String s;等同于String s=null;
而在本地变量(方法变量)的定义中,String s;不等同于String s=null;,这时要使用s必须显式地赋值。
这些虽然是小知识点,但在实际应用中很重要,也很容易被一些人忽视,特此提出。
还有一点要说明的是：
只要是在方法在中定义变量都要显示赋初值，main()方法也不例外，而在方法之外编译器回自动赋初值

spring的判空

Spring-core中提供了大量的工具类，常用的有StringUtils、ObjectUtils、NumberUtils、Base64Utils等，Spring工具类在spring-core.jar中的org.springframework.util包下。

1.isEmpty 没有忽略空格参数，是以是否为空和是否存在为判断依据。
2.isBlank 是在 isEmpty 的基础上进行了为空（字符串都为空格、制表符、tab 的情况）的判断。（一般更为常用）

这里推荐使用isBlank方法，因为可能会存在“ ”的情况，当这种情况下，需要根据自己的业务判断是不是为null的情况，避免出现错误，影响业务。

1
2
3
4
5
6
7
StringUtils.isEmpty("yyy") = false
StringUtils.isEmpty("") = true
StringUtils.isEmpty("   ") = false
 
StringUtils.isBlank("yyy") = false
StringUtils.isBlank("") = true
StringUtils.isBlank("   ") = true

null只有=和==方法可以使用，如果使用其他方法会报空指针异常的错误。

总结：

1.null==判断的对象：只判断null的情况

2.StringUtils.isEmpty(判断的对象)：判断null和””的情况

3.StringUtils.isBlank(判断的对象)：判断null和””和” “的情况

判空方法：

1.字符串与已知值进行比较，已知值放在前面

1
“123”.equals(value)

2.两个字符串比较，不确定是否有空值，使用Object.equals() 方法

1
boolean r = Objects.equals(a,b);

3.使用 java8 中的 Optional 类代替显示判空：Java 8中，每当一个函数需要返回 null，应该返回 Optional

1
Optional.ofNullable(null).orElse("0")

首先，创建第二个getter返回 Optional：

1
public Optional getMemberCardOpt() {   return Optional.ofNullable(memberCard); }

其次，更改原始的getter以委托给新的getter：

1
public String getMemberCard() {   return getMemberCardOpt().orElse(null); }
  1. 经典 if 判断
  2. 使用Java 8的检查 java.util.Objects -在当今开发中的项目中使用最广泛
  3. Lombok @NonNull 导致将 if 检查添加到生成的字节码中。
  4. assert关键字：我个人不喜欢它，因为可以通过JVM参数全局禁用断言

写业务代码的时候，通常会遇到数据库POJO对象转换为前端需要的VO对象，这时经常会遇到烦人的空指针问题，Java 8之前，我们可能这么写：

对于对象field复制风格:
a.setCreateTime(b.getCreateTime().getTime());
a.setAmount(b.getPayed()+b.getVoucher());
1
2
对于装饰器风格：
public Long getCreateTime() {
return b.getCreateTime().getTime();
}
public Long getAmount() {
return b.getPayed()+b.getVoucher()
}
1
2
3
4
5
6
很明显，这些代码会有空指针异常的风险.一般我们会这么修改：

对于对象field复制风格:
if (b.getCreateTime()!= null) {
a.setCreateTime(b.getCreateTime().getTime());
}
if (b.getPayed() != null) {
a.setAmount(b.getPayed();
} else {
a.setAmount(0L);
}
if (b.getVoucher() != null) {
a.setAmount(a.getAmount()+b.getVoucher());
}
1
2
3
4
5
6
7
8
9
10
11
对于装饰器风格：
public Long getCreateTime() {
if (b.getCreateTime()!= null) {
return b.getCreateTime().getTime();
} else {
return null;
}
}
public Long getAmount() {
Long result = 0L;
if (b.getPayed() != null) {
result += b.getPayed();
}
if (b.getVoucher() != null) {
result += b.getVoucher();
}
return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Java8引入的Optional写法：

对于对象field复制风格:
Optional.ofNullable(b.getCreateTime()).ifPresent(timestamp -> a.setCreateTime(timestamp.getTime()));
a.setAmount(Optional.ofNullable(b.getPayed()).orElse(0L) + Optional.ofNullable(b.getVoucher()).orElse(0L));
1
2
对于装饰器风格：
public Long getCreateTime() {
Optional createTime = Optional.ofNullable(b.getCreateTime());
if (createTime.isPresent()) {
return createTime.get();
} else {
return null;
}
}
public Long getAmount() {
return Optional.ofNullable(b.getPayed()).orElse(0L) + Optional.ofNullable(b.getVoucher()).orElse(0L)
}
1
2
3
4
5
6
7
8
9
10
11
这样依然很复杂，尤其是嵌套多层之后。
更进一步，有没有通用简便的方法呢？联想到Java8的Functional Interface以及我们需要处理的异常只有空指针异常，可以写工具类：

import java.util.function.Supplier;

public class OptionalUtil {
/**
* 忽略NullPointerException的获取
* @param supplier
* @param
* @return 如果有空指针，返回null
*/
public static T orNull(Supplier supplier) {
try {
return supplier.get();
} catch (NullPointerException e) {
return null;
}
}

/**
* 忽略NullPointerException的获取
*
* @param supplier
* @param or
* @param
* @return 如果有空指针，返回or
*/
public static T or(Supplier supplier, T or) {
try {
T t = supplier.get();
if (t != null) {
return t;
}
return or;
} catch (NullPointerException e) {
return or;
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
这样，我们的代码就变得简洁多了：

对于对象field复制风格:
a.setCreateTime(OptionalUtil.orNull(() -> b.getCreateTime().getTime()));
a.setAmount(OptionalUtil.or(() -> b.getPayed(), 0L) + OptionalUtil.or(() -> b.getAmount(), 0L));
1
2
对于装饰器风格：
public Long getCreateTime() {
return OptionalUtil.orNull(() -> b.getCreateTime().getTime());
}
public Long getAmount() {
return OptionalUtil.or(() -> b.getPayed(), 0L) + OptionalUtil.or(() -> b.getAmount(), 0L);
}

展开全文 >>

JDBC

jdbc（Java数据库连接）是一种用于执行SQL语句的Java API，由一组用Java语言编写的类和接口组成。

驱动：两个设备（应用）之间通信的桥梁。

SUN公司提供一套统一的规范（接口）。然后各个数据库生产商提供这套接口的实现。这套接口规范就是JDBC的规范。

JDBC的环境准备：

\1. 创建数据库和表

\2. 创建项目，引入jar包

JDBC的开发步骤：

1.加载驱动：Class.forname

2.获得连接：DriverManager

\3. 基本操作：执行SQL：

获得执行SQL语句的对象：createStatement()方法，返回值是Statement

编写SQL语句：String sql = “select * from user”;

执行SQL：executeQuery(sql)方法，返回值是ResultSet

遍历该set集合

\4. 释放资源：集合、执行SQL语句的对象、获得的连接都要释放资源

DriverManager：驱动管理类

作用：1.注册驱动：DriverManager.registerDriver(Driver driver);

这个方法可以完成驱动的注册，但是实际开发中一般不会使用这个方法完成驱动的注册，而是使用Class.forname(“com.mysql.jdbc.Driver”);

因为如果需要注册驱动，就会使用DriverManager.registerDriver(new Driver());，但是查看Driver源代码发现，在代码中有一段静态代码块，静态代码块已经调用了注册驱动的方法，如果再手动调用该方法注册驱动，就会导致驱动被注册两次

2.获得连接：DriverManager.getConnection(String url, String username, String password);

url：与数据库连接的路径

user ：与数据库连接的用户名

password：与数据库连接的密码

url的写法：jdbc:mysql://localhost:3306/web_test3

jdbc :连接数据库的协议

mysql:是jdbc的子协议

localhost:连接的MySQL数据库服务器的主机地址。（连接是本机就可以写成localhost），如果连接不是本机的，就需要写上连接主机的IP地址。

3306:MySQL数据库服务器的端口号

web_test3:数据库名称

url如果连接的是本机的路径，可以简化为：jdbc:mysql:///web_test3

Connection：与数据库连接对象

作用：1.创建执行SQL语句的对象：

Statement:执行SQL Statement createStatement()

CallableStatement:执行数据库中存储过程 CallableStatement prepareCall(String sql)

PreparedStatement:（主要用这个）执行SQL.对SQL进行预处理。解决SQL注入漏洞 PreparedStatement preparedStatement (String sql)

\2. 管理事务

void setAutoCommit(boolean autoCommit):将此连接的自动提交模式改为给定状态

void commit():将所有上一次提交/回滚后进行的更改变为永久性更改，并释放此Connection对象当前持有的所有数据库锁

void rollback():取消在当前事务中进行的所有更改，并释放此Connection对象当前持有的所有数据库锁

Statement：执行SQL

作用：1.执行SQL

boolean execute(String sql); 执行查询，修改，添加，删除的SQL语句 （如果第一个结果为ResultSet对象，则返回true；如果是更新计数或者不存在任何结果，返回false）

ResultSet executeQuery(String sql); 执行查询（执行select语句）

int executeUpate(String sql);执行修改，添加，删除的SQL语句 （SQL DDL语句也可以）（返回的是影响的行数）

2.执行批处理

void addBatch(String sql) 将给定的sql命令添加到此Statement对象的当前命令列表中

void clearBatch() 清空此Statement对象的当前SQL命令列表

int[] executeBatch() 将一批命令交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组

ResultSet：结果集，通过select语句的查询结果（只有select语句才有结果集）

结果集的遍历：

boolean next（）； 将光标从当前位置向下移一行（刚开始是在第一行之前的空白，调用了该方法之后会移动到第一行）

结果集的获取：

结果集获取可以使用结果集中的: getXXX(); 方法通常都会有一个重载的方法（int、long、String，Object就比较通用）

传递的参数可以是列号也可以是列名：

getXXX(int columnIndex);

getXXX(String columnName); （一般传的参数是列名，因为查询的话，有可能结果的列号不一样）

资源释放：

JDBC程序执行结束后，将与数据库进行交互的对象释放掉，通常是ResultSet,Statement,Connection

这几个对象中尤其是Connection对象是非常稀有的。这个对象一定要做到尽量晚创建，尽早释放掉。

将资源释放的代码写入到finally的代码块中，确保资源会释放。但是资源释放的时候仍可能出现异常，所以资源释放的代码应该写的标准：再用trycatch语句进行判空，判完之后要将对象赋值为null：因为可以让垃圾回收器尽快的将资源回收。

JDBC的CRUD操作：

添加、删除、修改操作：

\1. 创建Connection和Statement并赋值为null

\2. try语句中进行：注册驱动，获得连接，创建执行SQL语句对象，编写相应的SQL语句，执行SQL（excuteUpdate(sql)方法），对返回值进行判断。

\3. 释放资源（判空，抛异常，赋值为null）

查询操作：查询多条记录和查询一条记录

1.创建Connection和Statement和ResultSet并赋值为null

2.try语句中进行：注册驱动，获得连接，创建执行SQL语句对象，编写相应的SQL语句，执行SQL（excuteQuery（sql）方法）。多条语句进行遍历while，一条语句进行判断if，并输出

3.释放资源（判空，抛异常，赋值为null）

JDBC的工具类的抽取：因为注册驱动，获得连接，释放资源的代码都是相同的，所以可以抽取成一个工具类。

/**

* JDBC的工具类

* *@author* swx

*/

*public* *class* JDBCUtils {

​ *private* *static* *final* String ****driverClassName****;

​ *private* *static* *final* String ****url****;

​ *private* *static* *final* String ****username****;

​ *private* *static* *final* String ****password****;

​ *static*{

​ ****driverClassName****=”com.mysql.jdbc.Driver”;

​ ****url****=”jdbc:mysql:///web_test3”;

​ ****username****=”root”;

​ ****password****=”abc”;

​ }

​ /**

​ * 注册驱动的方法

​ */

​ *public* *static* *void* loadDriver(){

​ *try* {

​ Class.forName(****driverClassName****);

​ } *catch* (ClassNotFoundException e) {

​ e.printStackTrace();

​ }

​ }

​

​ /**

​ * 获得连接的方法

​ */

​ *public* *static* Connection getConnection(){

​ Connection conn = *null*;

​ *try*{

​ // 将驱动一并注册:

​ loadDriver();

​ // 获得连接

​ conn = DriverManager.getConnection(*url****,*username****, ****password****);

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }

​ *return* conn;

​ }

​

​ /**

​ * 释放资源的方法

​ */

​ *public* *static* *void* release(Statement stmt,Connection conn){

​ *if*(stmt != *null*){

​ *try* {

​ stmt.close();

​ } *catch* (SQLException e) {

​ e.printStackTrace();

​ }

​

​ stmt = *null*;

​ }

​ *if*(conn != *null*){

​ *try* {

​ conn.close();

​ } *catch* (SQLException e) {

​ e.printStackTrace();

​ }

​ conn = *null*;

​ }

​ }

​

​ *public* *static* *void* release(ResultSet rs,Statement stmt,Connection conn){

​ // 资源释放：

​ *if*(rs != *null*){

​ *try* {

​ rs.close();

​ } *catch* (SQLException e) {

​ e.printStackTrace();

​ }

​

​ rs = *null*;

​ }

​ *if*(stmt != *null*){

​ *try* {

​ stmt.close();

​ } *catch* (SQLException e) {

​ e.printStackTrace();

​ }

​

​ stmt = *null*;

​ }

​ *if*(conn != *null*){

​ *try* {

​ conn.close();

​ } *catch* (SQLException e) {

​ e.printStackTrace();

​ }

​ conn = *null*;

​ }

​ }

}

静态代码块可以写成配置文件

配置文件：两种

\1. 属性文件：扩展名为.properties 内容是key=value

\2. XML文件

定义一个配置文件：写好键值对的相应配置，修改文件扩展名为.properties

img

在工具类中解析属性文件：依然在静态代码块中进行解析：

img

SQL注入漏洞：通过知道用户名，然后进行sql语句查询就可以进行登录。

img

“+username+”和“+password+” 是字符串拼接

img

当用户名输入为aaa’ or ‘1=1 ，密码随意写，就能登录成功：

select * from user where username = ‘ aaa’ or ‘ 1=1 ‘ and password = ‘ asdafaf ’

因为先进行and运算，true and false 结果为false 。再进行or运算， true or false 结果为true，所以可以成功。

当用户名输入为aaa’ or ‘1=1 ，密码随意写，也能登录成功：

select * from user where username = ‘ aaa’ – ‘ and password = ‘ asdafaf ’

因为– 代表注释，相当于aaa后面的都没了，结果为true，所以可以成功。

出现漏洞的原因就是因为 or 和 – 都是SQL的关键字

解决方案：得在后台，后端解决。（因为可以绕过前端）

需要采用PreparedStatement对象解决SQL注入漏洞。这个对象将SQL预先进行编译，使用?作为占位符。?所代表内容是SQL所固定。再次传入变量（包含SQL的关键字）。这个时候也不会识别这些关键字。

*public* *class* UserDao {

​ *public* *boolean* login(String username,String password){

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ ResultSet rs = *null*;

​ // 定义一个变量:

​ *boolean* flag = *false*;

​ *try*{

​ // 获得连接:

​ conn = JDBCUtils.getConnection();

​ // 编写SQL语句:

​ String sql = “select * from user where username = ? and password = ?”;

​ // 预编译SQL

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ pstmt.setString(1, username); //1代表第一个问号

​ pstmt.setString(2, password); // 2代表第二个问号

​ // 执行SQL语句:

​ rs = pstmt.executeQuery();

​ *if*(rs.next()){

​ // 说明根据用户名和密码可以查询到这条记录

​ flag = *true*;

​ }

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(rs, pstmt, conn);//这里传的pstmt实际是stmt的子类，实际上用的是多态

​ }

​ *return* flag;

​ }

所以以后的Statement都最好用PreparedStatement

增加操作：String sql = “insert into user values (null,?,?,?,?)”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ pstmt.setString(1, “eee”);

​ pstmt.setString(2, “abc”);

​ pstmt.setString(3, “旺财”);

​ pstmt.setInt(4, 32);

​ // 执行SQL

​ *int* num = pstmt.executeUpdate();

​ *if*(num > 0){

​ System.****out****.println(“保存成功！”);

​ }

修改操作：String sql = “update user set username = ?,password =?,nickname=?,age = ? where id = ?”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ pstmt.setString(1, “abc”);

​ pstmt.setString(2, “1234”);

​ pstmt.setString(3, “旺旺”);

​ pstmt.setInt(4, 23);

​ pstmt.setInt(5, 6);

​ // 执行SQL：

​ *int* num = pstmt.executeUpdate();

​ *if*(num > 0){

​ System.****out****.println(“修改成功！”);

​ }

删除操作：String sql = “delete from user where id = ?”;

​ // 预编译SQL

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ pstmt.setInt(1, 4);

​ // 执行SQL:

​ *int* num = pstmt.executeUpdate();

​ *if*(num > 0){

​ System.****out****.println(“删除成功！”);

​ }

查找操作：String sql = “select * from user”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ // 执行SQL:

​ rs = pstmt.executeQuery();

​ // 遍历结果集:

​ while(rs.next()){

​ System.out.println(rs.getInt(“id”)+” “+rs.getString(“username”)+” “+rs.getString(“password”)+” “+rs.getString(“nickname”));

}

JDBC的批处理：之前进行JDBC的操作的时候，都是一条SQL语句执行。现在如果使用批处理，可以将一批SQL一起执行。

用Statement进行批处理：@Test

​ /**

​ * 批处理基本操作

​ */

​ *public* *void* demo1(){

​ Connection conn = *null*;

​ Statement stmt = *null*;

​ *try*{

​ // 获得连接:

​ conn = JDBCUtils.getConnection();

​ // 创建执行批处理对象:

​ stmt = conn.createStatement();

​ // 编写一批SQL语句：

​ String sql1 = “create database test1”;

​ String sql2 = “use test1”;

​ String sql3 = “create table user(id int primary key auto_increment,name varchar(20))”;

​ String sql4 = “insert into user values (null,’aaa’)”;

​ String sql5 = “insert into user values (null,’bbb’)”;

​ String sql6 = “insert into user values (null,’ccc’)”;

​ String sql7 = “update user set name = ‘mmm’ where id = 2”;

​ String sql8 = “delete from user where id = 1”;

​ // 添加到批处理

​ stmt.addBatch(sql1);

​ stmt.addBatch(sql2);

​ stmt.addBatch(sql3);

​ stmt.addBatch(sql4);

​ stmt.addBatch(sql5);

​ stmt.addBatch(sql6);

​ stmt.addBatch(sql7);

​ stmt.addBatch(sql8);

​ // 执行批处理:

​ stmt.executeBatch();

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(stmt, conn);

​ }

​ }

使用PreparedStatement进行批量插入：

@Test

​ /**

​ * 批量插入记录:

​ * * 默认情况下MySQL批处理没有开启的，需要在url后面拼接一个参数即可：

?rewriteBatchedStatements=true

​ */

​ *public* *void* demo2(){

​ // 记录开始时间:

​ *long* begin = System.currentTimeMillis();

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ *try*{

​ // 获得连接:

​ conn = JDBCUtils.getConnection();

​ // 编写SQL语句：

​ String sql = “insert into user values (null,?)”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ *for*(*int* i=1;i<=10000;i++){

​ pstmt.setString(1, “name”+i);

​ // 添加到批处理

​ pstmt.addBatch();

​ // 注意问题：

​ // 执行批处理：每1000次进行一次批量处理和清空，以防止内存溢出

​ *if*(i % 1000 == 0){

​ // 执行批处理:

​ pstmt.executeBatch();

​ // 清空批处理:

​ pstmt.clearBatch();

​ }

​ }

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(pstmt, conn);

​ }

​ *long* end = System.currentTimeMillis();

​ System.****out****.println((end-begin));

​ }

JDBC的事务：

事务指的是逻辑上的一组操作，组成这组操作各个逻辑单元要么全都成功，要么全都失败。

如果写一个转账代码，没有加事务的话，可能会出现扣钱了，但是另一个账户没有加钱的情况，所以需要加事务。

@Test

​ /**

​ * 完成转账的案例

​ */

​ *public* *void* demo1(){

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ *try*{

​ /**

​ * 完成转账代码：

​ * * 扣除某个账号的钱

​ * * 给另外一个账号加钱

​ */

​ // 获得连接：

​ conn = JDBCUtils.getConnection();

​ *// 开启事务*

​ *conn.setAutoCommit(*****false**);**//设置为false是需要手动提交，设为true的话，写一条sql语句就会提交一句****

​ // 编写SQL语句：

​ String sql = “update account set money = money + ? where name = ?”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ // 用aaa账号给bbb账号转1000元

​ pstmt.setDouble(1, -1000);

​ pstmt.setString(2, “aaa”);

​ // 执行SQL：扣除aaa账号1000元

​ pstmt.executeUpdate();

​

​ *int* i = 1 / 0; //假设这里出现了异常，结果账户的钱也不会发生改变

​

​ // 给bbb账号加1000

​ pstmt.setDouble(1, 1000);

​ pstmt.setString(2, “bbb”);

​ pstmt.executeUpdate();

​

​ *// 提交事务:*

​ *conn.commit();*

​ }*catch*(Exception e){

​ *// 回滚事务:*

​ *try* *{*

​ *conn.rollback();*

​ *}* *catch* *(SQLException e1) {*

​ *e1.printStackTrace();*

​ *}*

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(pstmt, conn);

​ }

​ }

*连接池*

连接池是装有连接的容器，线程使用连接的话，可以从连接池中进行获取，使用完成之后将连接归还给连接池。

连接对象创建和销毁是需要耗费时间的，在服务器初始化的时候就初始化一些连接。把这些连接放入到内存中，使用的时候可以从内存中获取，使用完成之后将连接放入连接池中。从内存中获取和归还的效率要远远高于创建和销毁的效率。（提升性能）

自定义连接池：

\1. 编写一个类实现DataSource接口

\2. 重写getConnection方法

\3. 初始化多个连接在内存中

\4. 编写归还连接的方法

img

测试：

img

但是这个自定义连接池也存在两个问题：

使用接口的实现类完成的构造：

MyDataSource dataSource = new MyDataSource(); 这种写法不利于程序的扩展：

应该用这样的DataSource dataSource = new MyDataSource(); （多态）

但是这样的话，因为DataSource下没有addBack方法所以下面的调用会出错；同时因为调用了addBack方法，会对使用连接池的用户增加难度（因为要理解什么是addBack方法，额外提供了方法归还连接）

解决：不提供自定义的方法addBack就可以解决这个问题，所以需要改写一个方法解决归还的问题。

在Connection中是有一个close方法的，colse方法完成了连接的销毁。现在需要写一个方法，将原有的连接的close方法改为归还。

增强一个类中的方法：

\1. 采用继承：是最简单的一种增强某个类中的方法的方式。

条件：需要控制这个类的构造才能进行继承。

\2. 采用装饰者模式：比如：BufferedInputStream（InputStream）

条件：增强的类和被增强的那个类要实现同样的接口；在增强的类中要有被增强的那个类的引用。

\3. 动态代理

使用装饰者模式增强Connection中的close方法：（因为接口内的方法需要全部重写，而继承的话，可以只重写某一个或几个方法）

为了简化编程，提供一个模板类（模板类原封不动的将接口中的所有方法都实现，但是都没有增强）。编写一个装饰类继承模板类。在装饰类中只需要增强某一个方法即可。

img

连接池的代码：

*public* *class* MyDataSource *implements* DataSource {

​ // 将一些连接存入到内存中，可以定义一个集合，用于存储连接对象。

​ *private* List connList = *new* ArrayList();

​

​ // 在初始化的时候提供一些连接

​ *public* MyDataSource() {

​ // 初始化连接：

​ *for*(*int* i = 1;i<=3;i++){

​ // 向集合中存入连接:

​ connList.add(JDBCUtils.getConnection());

​ }

​ }

​

​ // 从连接池中获得连接的方法

​ @Override

​ *public* Connection getConnection() *throws* SQLException {

​ Connection conn = connList.remove(0);

​ *// 增强连接：*

​ *MyConnectionWrapper connWrapper =* *new* *MyConnectionWrapper(conn, connList);*

​ *return* connWrapper;

​ }

​

​ *// 编写一个归还连接的方法:*

​ */*public void addBack(Connection* *conn*****){****

​ *connList.add(*****conn*****);*

​ *}*/*

}

测试：

img

*Druid开源连接池*

Druid是阿里旗下开源连接池产品，使用非常简单，可以与Spring框架进行快速整合。

在项目下新建一个文件夹folder名为lib，复制mysql的驱动包，druid的jar包到lib中，添加buid path。

/可以直接添加工具类，配置文件。然后直接获得连接，执行SQL语句，释放资源。（但是最好用连接池，不用这个）/

使用这个druid连接池可以去百度搜索它的帮助文档查看相关的API。核心类：DruidDataSource

利用这个核心类可以创建对象，然后手动设置数据库连接的参数：setXxx的方法，（也可以使用配置文件进行获取参数）获得连接：getConnection方法。最后释放资源中conn的释放不是销毁而是归还到连接池中（Druid连接池底层一定重写了这个方法变成了归还）

@Test

​ /**

​ * Druid的使用:

​ * * 手动设置参数的方式

​ */

​ *public* *void* demo1(){

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ ResultSet rs = *null*;

​ *try*{

​ // 使用连接池：

​ DruidDataSource dataSource = *new* DruidDataSource();

​ // 手动设置数据库连接的参数:

​ dataSource.setDriverClassName(“com.mysql.jdbc.Driver”);

​ dataSource.setUrl(“jdbc:mysql:///web_test4”);

​ dataSource.setUsername(“root”);

​ dataSource.setPassword(“abc”);

​ // 获得连接：

// conn = JDBCUtils.getConnection();

​ conn = dataSource.getConnection();

​ // 编写SQL:

​ String sql = “select * from account”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ // 执行SQL:

​ rs = pstmt.executeQuery();

​ *while*(rs.next()){

​ System.****out****.println(rs.getInt(“id”)+” “+rs.getString(“name”)+” “+rs.getDouble(“money”));

​ }

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(rs, pstmt, conn);

​ }

​ }

也可以用配置文件进行参数的获取：

@Test

​ /**

​ * Druid的使用:

​ * * 配置文件方式设置参数

​ * Druid配置方式可以使用属性文件配置的。

​ * * 文件名称没有规定但是属性文件中的key要一定的。

​ */

​ *public* *void* demo2(){

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ ResultSet rs = *null*;

​ *try*{

​ // 使用连接池：

​ // 从属性文件中获取：

​ Properties properties = *new* Properties();

​ properties.load(*new* FileInputStream(“src/druid.properties”));

//这里()内需要传一个InputStream，现在可以这样子传，在WEB中是另一种。

​ DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

​ // 获得连接：

// conn = JDBCUtils.getConnection();

​ conn = dataSource.getConnection();

​ // 编写SQL:

​ String sql = “select * from account”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 设置参数:

​ // 执行SQL:

​ rs = pstmt.executeQuery();

​ *while*(rs.next()){

​ System.****out****.println(rs.getInt(“id”)+” “+rs.getString(“name”)+” “+rs.getDouble(“money”));

​ }

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(rs, pstmt, conn);

​ }

​ }

虽然可以在这里进行配置文件的配置，但是不太好，可以放在JDBC的工具类中。

*C3P0开源连接池*

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。

C3P0的核心类是：ComboPooledDataSource

手动设置参数：

@Test

​ /**

​ * 手动设置参数的方式:

​ */

​ *public* *void* demo1(){

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ ResultSet rs = *null*;

​ *try*{

​ // 获得连接：从连接池中获取：

​ // 创建连接池：

​ ComboPooledDataSource dataSource = *new* ComboPooledDataSource();

​ // 设置连接参数:

​ dataSource.setDriverClass(“com.mysql.jdbc.Driver”);

​ dataSource.setJdbcUrl(“jdbc:mysql:///web_test4”);

​ dataSource.setUser(“root”);

​ dataSource.setPassword(“abc”);

​ // 从连接池中获得连接:

​ conn = dataSource.getConnection();

​ // 编写SQL：

​ String sql = “select * from account”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 执行SQL：

​ rs = pstmt.executeQuery();

​ *while*(rs.next()){

​ System.****out****.println(rs.getInt(“id”)+” “+rs.getString(“name”)+” “+rs.getDouble(“money”));

​ }

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(rs, pstmt, conn);

​ }

​ }

配置文件设置参数：

默认情况下，c3p0会在类加载的resource路径下查找一个配置文件“/c3p0-config.xml”。所以XML文件应该在应用的CLASSPATH下的一个文件夹或者jar包中，如果是WEB的话会在WEB-INF/classes下，其他的话也是类似的路径。c3p0不仅支持xml文件，也支持properties文件（以后的重点）。

配置连接池：

在src下新建一个xml文件，设置名为c3p0-config.xml，可以在帮助文档中找到xml的配置代码:

…… 默认配置

<named-config name=” ”> …… 自定义配置

可以修改其中的配置key，value。

img

使用连接池：

@Test

​ /**

​ * 采用配置文件的方式：

​ */

​ *public* *void* demo2(){

​ Connection conn = *null*;

​ PreparedStatement pstmt = *null*;

​ ResultSet rs = *null*;

​ *try*{

​ // 获得连接：从连接池中获取：

​ // 创建连接池：//创建连接池默认去类路径下查找c3p0-config.xml，并且将其中的各种参数加载好

​ ComboPooledDataSource dataSource = *new* ComboPooledDataSource();

//()里面可以传递配置的名称从而加载不同的参数。如果名称没有匹配的，会加载默认的配置参数

​ // 从连接池中获得连接:

​ conn = dataSource.getConnection();

​ // 编写SQL：

​ String sql = “select * from account”;

​ // 预编译SQL:

​ pstmt = conn.prepareStatement(sql);

​ // 执行SQL：

​ rs = pstmt.executeQuery();

​ *while*(rs.next()){

​ System.****out****.println(rs.getInt(“id”)+” “+rs.getString(“name”)+” “+rs.getDouble(“money”));

​ }

​ }*catch*(Exception e){

​ e.printStackTrace();

​ }*finally*{

​ JDBCUtils.release(rs, pstmt, conn);

​ }

​ }

参数可以设置很多个，很多种，所以其应用很灵活。

以上的代码都不规范，因为每次都会创建一个新的连接池，会浪费资源，所以需要对工具类进行改写和完善

img

*DBUtils*

Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。

因为JDBC手写比较麻烦，而且有非常多的代码是类似的。比如获得连接，预编译SQL，释放资源等..那么可以将这些代码抽取出来放到工具类中。将类似的代码进行抽取。大大简化JDBC的编程。

API

QueryRunner对象：核心运行类

构造方法：

无参构造

img

带参构造

img

方法：

增删改的方法

img

img

查找的方法

img

img

在一般情况下如果执行CRUD的操作：

构造：

QueryRunner(DataSource ds);

方法：

int update(String sql,Object… args);

T query(String sql,ResultSetHandler rsh,Object… args);

如果有事务管理的话使用另一套完成CRUD的操作

构造：

QueryRunner();

方法:

int update(Connection conn,String sql,Object… args);

T query(Connection conn,String sql,ResultSetHandler rsh,Object… args);

批量处理的方法

img

还有一个类：DbUtils

提交事务的方法：（这里的close不是销毁而是归还）

img

回滚事务的方法：

img

添加DBUtils的构建路径

DBUtils的添加操作：

​ @Test

​ /**

​ * 添加操作

​ */

​ *public* *void* demo1() *throws* SQLException{

​ // 创建核心类：QueryRunner:

​ QueryRunner queryRunner = *new* QueryRunner(JDBCUtils2.getDataSource());

​ queryRunner.update(“insert into account values (null,?,?)”, “ddd”,10000);

​ }

DBUtils的修改操作：

​ @Test

​ /**

​ * 修改操作

​ */

​ *public* *void* demo2() *throws* SQLException{

​ // 创建核心类:

​ QueryRunner queryRunner = *new* QueryRunner(JDBCUtils2.getDataSource());

​ queryRunner.update(“update account set name=?,money=? where id =?”, “eee”,20000,4);

​ }

DBUtils的删除操作：

@Test

​ /**

​ * 删除操作

​ */

​ *public* *void* demo3() *throws* SQLException{

​ // 创建核心类:

​ QueryRunner queryRunner = *new* QueryRunner(JDBCUtils2.getDataSource());

​ queryRunner.update(“delete from account where id = ?”, 3);

​ }

DBUtils的查询操作：

查询一条记录：

创建一个对象：Account（这个对象实例其实就是javabean）

img

也要重写toString方法

查询的代码实现：T query(String sql,ResultSetHandler rsh,Object… args);

img

查询多条语句：

img

ResultSetHandler接口的实现类：

\1. ArrayHandler和ArrayListHandler

ArrayHandler：将查询到的一条记录封装到一个数组当中，这个数组应该是Object[]

img

ArrayListHandler：将多条记录封装到一个装有Object[]的List集合中。

img

\2. BeanHandler和BeanListHandler（重要）

BeanHandler：将一条记录封装到一个JavaBean中。

img

必须保证Acoount中的变量和SQL中的列名一致

BeanListHandler：将多条记录封装到一个装有JavaBean的List集合中。

img

\3. MapHandler和MapListHandler

MapHandler：将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值。

img

MapListHandler：将多条记录封装到一个装有Map的List集合中。

img

\4. ColumnListHandler、ScalarHandler、KeyedHandler

ColumnListHandler：将数据库中的某列的值封装到List集合中。

img

ScalarHandler：将单个值封装。

img

KeyedHandler（了解即可，用的很少）：将一条记录封装到一个Map集合中。将多条记录封装到一个装有Map集合的Map集合中。而且外面的Map的key是可以指定的（可以指定为数据库中的某一列名）。

img

因为可能是不同的类型，为了通用性，一般都用Object类型。

展开全文 >>

泛型

JDK5以后出现了自动装箱，所以在需要引用类型的时候如果是个基本类型也是可以的，是因为有自动装箱。

当我们往集合中存储了String和Integer两种类型时的数据时，而在遍历时都进行String类型的转化时，就会报错。但这个报错在编译期间不会出现，在编译的时候只有警告，只有执行的时候才会出现。于是集合也开始在创建对象的时候明确元素的数据类型，这就是泛型。泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型

泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

格式：<数据类型> 此处的数据类型只能是引用类型

好处：

1.运行时期的问题提取到了编译期间

2.避免了强制类型转换

3.简化了程序设计，解决了黄色警告线

在API中，如果类，接口，抽象类中出现了<E>，就说明要使用泛型。一般来说就是在集合中使用。

JDK7的新特性：泛型推断。

早期我们使用Object类型可以接收任意的对象类型。但是在实际的使用中，会有类型转换的问题（向上转型是没有任何问题的，但是在向下转型的时候隐含了类型转换的问题），也就存在着隐患，这样的程序是不安全的，所以在JDK5以后Java提供了泛型来解决这个问题，提高程序的安全性。

应用：

1.泛型类：把泛型定义在类上

格式:public class 类名<泛型类型1,…>

注意:泛型类型必须是引用类型

2.泛型方法：把泛型定义在方法上

格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

方法可以接收任意的类型

3.泛型接口：把泛型定义在接口上

格式:public interface 接口名<泛型类型1…>

实现类在实现接口的时候：

1.已经知道是什么类型的了：

public class InterImpl implements Inter{}

\2. 还不知道是什么类型：(这种情况用的比较多)

public class InterImpl implements Inter{}

泛型通配符：泛型如果写的时候，前后必须一致（ArrayList array=new ArrayList(); 这里的前后两个T必须一致，？可以表示任意）

\1. <?>:任意类型，如果没有明确，那么就是Object以及任意的Java类了

\2. <? extends E>：向下限定，E及其子类

\3. <? super E>：向上限定，E及其父类

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class GlmapperGeneric<T> {
  	private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }


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


  /**
    * 不指定类型
    */
  public void noSpecifyType(){
    GlmapperGeneric glmapperGeneric = new GlmapperGeneric();
    glmapperGeneric.set("test");
    // 需要强制类型转换
    String test = (String) glmapperGeneric.get();
    System.out.println(test);
  }

  /**
    * 指定类型
    */
  public void specifyType(){
    GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric();
    glmapperGeneric.set("test");
    // 不需要强制类型转换
    String test = glmapperGeneric.get();
    System.out.println(test);
  }
}
 specifyType 方法中省去了强制转换，可以在编译时候检查类型安全，可以用在类，方法，接口上

通配符 T，E，K，V，？

  • ？表示不确定的 java 类型
  • T (type) 表示具体的一个java类型
  • K V (key value) 分别代表java键值中的Key Value
  • E (element) 代表Element

？无界通配符

一个父类 Animal 和几个子类，如狗、猫等，现在我需要一个动物的列表，我的第一个想法是像这样的：

1
List<Animal> listAnimals

但是老板的想法确实这样的：

1
List<? extends Animal> listAnimals

为什么要使用通配符而不是简单的泛型呢？通配符其实在声明局部变量时是没有什么意义的，但是当你为一个方法声明一个参数时，它是非常重要的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
static int countLegs (List<? extends Animal > animals ) {
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

static int countLegs1 (List< Animal > animals ){
    int retVal = 0;
    for ( Animal animal : animals )
    {
        retVal += animal.countLegs();
    }
    return retVal;
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
  // 不会报错
    countLegs( dogs );
 // 报错
    countLegs1(dogs);
}

当调用 countLegs1 时，就会飘红，提示的错误信息如下：

图片

所以，对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?> ），表示可以持有任何类型。像 countLegs 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

上界通配符 < ? extends E>

上届：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

  • 如果传入的类型不是 E 或者 E 的子类，编译不成功
  • 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用
1
2
3
4
5
6
private <K extends A, E extends B> E test(K arg1, E arg2){
    E result = arg2;
    arg2.compareTo(arg1);
    //.....
    return result;
}

类型参数列表中如果有多个类型参数上限，用逗号分开

下界通配符 < ? super E>

下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private <T> void test(List<? super T> dst, List<T> src){
    for (T t : src) {
        dst.add(t);
    }
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = new ArrayList<>();
    new Test3().test(animals,dogs);
}
// Dog 是 Animal 的子类
class Dog extends Animal {

}

dst 类型 “大于等于” src 的类型，这里的“大于等于”是指 dst 表示的范围比 src 要大，因此装得下 dst 的容器也就能装 src 。

？和 T 的区别

图片

？和 T 都表示不确定的类型，区别在于我们可以对 T 进行操作，但是对 ？不行，比如如下这种 ：

1
2
3
4
5
// 可以
T t = operate();

// 不可以
？car = operate();

简单总结下：

T 是一个 确定的 类型，通常用于泛型类和泛型方法的定义，？是一个 不确定 的类型，通常用于泛型方法的调用代码和形参，不能用于定义类和泛型方法。

区别1：通过 T 来 确保 泛型参数的一致性
1
2
3
4
5
6
7
// 通过 T 来 确保 泛型参数的一致性
public <T extends Number> void
test(List<T> dest, List<T> src)

//通配符是 不确定的，所以这个方法不能保证两个 List 具有相同的元素类型
public void
test(List<? extends Number> dest, List<? extends Number> src)

像下面的代码中，约定的 T 是 Number 的子类才可以，但是申明时是用的 String ，所以就会飘红报错。

图片

不能保证两个 List 具有相同的元素类型的情况

1
2
3
4
GlmapperGeneric<String> glmapperGeneric = new GlmapperGeneric<>();
List<String> dest = new ArrayList<>();
List<Number> src = new ArrayList<>();
glmapperGeneric.testNon(dest,src);

上面的代码在编译器并不会报错，但是当进入到 testNon 方法内部操作时（比如赋值），对于 dest 和 src 而言，就还是需要进行类型转换。

区别2：类型参数可以多重限定而通配符不行

图片

使用 & 符号设定多重边界（Multi Bounds)，指定泛型类型 T 必须是 MultiLimitInterfaceA 和 MultiLimitInterfaceB 的共有子类型，此时变量 t 就具有了所有限定的方法和属性。对于通配符来说，因为它不是一个确定的类型，所以不能进行多重限定。

区别3：通配符可以使用超类限定而类型参数不行

类型参数 T 只具有 一种 类型限定方式：

1
T extends A

但是通配符 ? 可以进行 两种限定：

1
2
? extends A
? super A

Class<T>和 Class<?>区别

前面介绍了 ？和 T 的区别，那么对于，Class<T>和 <Class<?>又有什么区别呢？Class<T>和 Class<?>

最常见的是在反射场景下的使用，这里以用一段发射的代码来说明下。

1
2
3
4
// 通过反射的方式生成  multiLimit
// 对象，这里比较明显的是，我们需要使用强制类型转换
MultiLimit multiLimit = (MultiLimit)
Class.forName("com.glmapper.bridge.boot.generic.MultiLimit").newInstance();

对于上述代码，在运行期，如果反射的类型不是 MultiLimit 类，那么一定会报 java.lang.ClassCastException 错误。

对于这种情况，则可以使用下面的代码来代替，使得在在编译期就能直接 检查到类型的问题：

图片

Class<T>在实例化的时候，T 要替换成具体类。Class<?>它是个通配泛型，? 可以代表任何类型，所以主要用于声明时的限制情况。比如，我们可以这样做申明：

1
2
3
4
// 可以
public Class<?> clazz;
// 不可以，因为 T 需要指定类型
public Class<T> clazzT;

所以当不知道定声明什么类型的 Class 的时候可以定义一 个Class<?>。

图片

那如果也想 public Class<T> clazzT;这样的话，就必须让当前的类也指定 T ，

1
2
3
4
public class Test3<T> {
    public Class<?> clazz;
    // 不会报错
    public Class<T> clazzT;

展开全文 >>

枚举

枚举：是有限个值的集合。

是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内

如果没有枚举类，我们自己定义一个类的话，会非常麻烦。（//需要用到构造方法私有，静态方法调用，对象调用方法，匿名类重写方法等）

格式：

public enum 枚举类名 {

​ 枚举项1，枚举项2，枚举项3…;

}

public String toString(): 返回枚举常量的名称，它包含在声明中（枚举重写了toString方法，返回的是枚举项的名字）

注意事项

定义枚举类要用关键字enum

所有枚举类都是Enum的子类

枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略

枚举类可以有构造器，但必须是private的，它默认的也是private的。枚举项的用法比较特殊：枚举(“”);

枚举类也可以有抽象方法，但是枚举项必须重写该方法

枚举在switch语句中的使用

枚举类中的几个常见方法

int compareTo(E o) 比较此枚举与指定对象的顺序，枚举中隐含数字 1 2 3 …

String name() 返回此枚举常量的名称，在其枚举声明中对其进行声明

int ordinal() 返回枚举常量的序数（它在枚举声明中的位置，初始常量序数为0）

String toString() 返回枚举常量的名称，它包含在声明中

T valueOf(Class type,String name) 静态方法，返回带指定名称的指定枚举类型的枚举常量

values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

展开全文 >>

JVM

Java语言是跨平台的，jvm不是跨平台的。

虚拟机（Virture Machine）指通过软件的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统。

Java的源代码经过编译后生成的不是特定CPU使用的本地代码，而是名为字节代码的程序。直接代码的运行环境就叫做java虚拟机（JVM），边转换边运行。

java中的内存分配：java程序在运行时，需要在内存中的分配空间。

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

1.栈：

存储局部变量（加载的变量、方法）

结构：先进后出

特点：栈内存的数据用完（脱离数据域）就释放掉。（堆内存的数据可能要使用多次。）

2.堆：

存储new出来的东西（里面含有该new类的成员变量、静态标记、方法标记）

特点：每一个new出来的东西都有地址值；每个变量都有默认值：

byte,short,int,long 0

float,double 0.0

char \u000

boolean false

引用类型 null

使用完毕就变成了垃圾，但是并没有立即回收，会在垃圾回收器空闲时候回收。

C++中用析构函数来回收释放空间。

栈内存的两个引用指向同一个堆内存空间，无论是它们谁的操作，都是针对同一个地方。

3.方法区：

class类区（包括类的成员变量和成员方法）、静态区（static）、常量池

4.本地方法区：

和系统相关

5.寄存器：

CPU使用

展开全文 >>

反射和注解

类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象。

连接

验证 是否有正确的内部结构，并和其他类协调一致

准备 负责为类的静态成员分配内存，并设置默认初始化值

解析 将类的二进制数据中的符号引用替换为直接引用

初始化

就是我们以前讲过的初始化步骤

类初始化时机：

1.创建类的实例

2.访问类的静态变量，或者为静态变量赋值

3.调用类的静态方法

4.使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

5.初始化某个类的子类

6.直接使用java.exe命令来运行某个主类

类加载器

负责将.class文件加载到内在中，并为之生成对应的Class对象。

虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行

类加载器的组成

Bootstrap ClassLoader 根类加载器

也被称为引导类加载器，负责Java核心类的加载。比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

Extension ClassLoader 扩展类加载器

负责JRE的扩展目录中jar包的加载。在JDK中JRE的lib目录下ext目录

Sysetm ClassLoader 系统类加载器

负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

反射，一种计算机处理方式。是程序可以访问、检测和修改它本身状态或行为的一种能力。

反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种****动态获取****的信息以及动态调用对象的方法的功能称为java语言的反射机制

//要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象

对于我们学习反射，我们在操作中一般会获取类的成员 Constructor Field Method。但是要想获取这些对象，必须首先得到其Class,通过Class再来获得其它对象

Java反射常用API

img

Java中的Class可以代表任意的类或接口类型

在java.lang.reflect包下有三个类

img

三种获取Class对象的方式

1:如果持有一个对象，可以直接从Object类继承的getClass()方法获取

Person p = new Person();

Class c = p.getClass();

img

2:可以直接通过类包(接口)直接调用其静态属性.class获取

Class c2 = Person.class;

img

任意数据类型都具备一个class静态属性,看上去要比第一种方式简单.

3:可以通过Class类中提供的forName方法获取（将类名作为字符串传递给Class类中的静态方法forName即可）：

public static Class forName(String className) 这个类名必须是全路径：包名.类名（可以在外面写，会提示是否出错，没错的话沾过去；也可以点击类名下的类名右击copy Qualified name ）

Class c3 = Class.forName(“Person”);

img

第三种和前两种的区别 ：前两种你必须明确Person类型；后面是一个字符串就行，而不需要是一个具体的类名.这种扩展更强.我不需要知道你的类.我只提供字符串,将这样的字符串配置到配置文件中，按照配置文件加载就可以了

所以开发中一般用第三种方法

Class类：

成员变量 Field

构造方法 Constructor

成员方法 Method

通过反射获取构造方法并使用：

获取构造方法：

img

getConstructor它获取的是类的public构造

getConstructors它获取的是类的所有的public构造

img

这两个方法不仅可以获取public，也可以获取其它权限的

获取单个构造方法

public Constructor getConstructor(Class<?>… parameterTypes) 参数表示的是你要获取的构造方法的构造参数个数及数据类型的****class字节码****文件对象。…表示可以是0个（无参）一个（一个参数）多个（多个参数）

/*获取的单个构造方法实际上是一个对象，通过这个对象可以创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例

public T newInstance(Object… initargs)

反射可以获取私有的构造方法，成员方法，成员变量：

获取的如果是私有的构造方法，要用public Constructor getDeclaredConstructor(Class<?>… parameterTypes),但是会显示非法的访问异常。所以还要用暴力访问：.setAccessible(true); 值为true指示反射的对象在使用时应该取消java语言访问检查 （XJAD软件就用到了反射）*/

我们得到构造器，就可以实例化对象

img

如果不是public，那么我们需要构造器对象的实例调用AccessibleObject中的

img

来取消语言检查

Reflect类继承于AccessibleObject类继承于Object类

通过反射获取成员变量并使用：Java.lang.reflect.Field它描述的属性对象

1.获取一个Field

获取所有成员

getFields 公共的

getDeclaredFields 所有的

获取单个成员

getField

getDeclaredField

img

img

2.Field的操作

（1）对Field进行赋值

img

赋值或修改成员的值

set(Object obj,Object value)
将指定对象变量上此 Field 对象表示的字段设置为指定的新值。此处的obj需要通过构造方法创建一个obj对象，也可以直接通过Class的实例的newInstance方法直接获得obj对象（这个方法的底层就是使用了Class类额无参构造来实例化）

（2）对Field进行取值

img

通过反射获取成员方法并使用：Java.lang.reflect.Method它描述的是类或接口中的方法

获取所有方法

​ getMethods 获取自己的包括父亲的公共方法

​ getDeclaredMethods 获取自己的所有方法

获取单个方法

​ getMethod（String name，Class<?>… parameterTypes）

​ getDeclaredMethod（String name，Class<?>… parameterTypes）

第一个参数是方法的名称，第二个参数是一个可变参数Class[]，它描述的是方法的参数Class

img

img

Method的使用：public Object invoke (Object obj , Object… args) 返回值是Object接收，第一个参数表示对象是谁，第二个参数表示调用该方法的实际参数

img

Method的invoke使用时注意事项?

\1. 如果方法是static，我们怎样调用？

如果方法是静态的，在通过invoke调用时不需要传递对象，传递null

img

\2. 如果方法的参数是一个数组类型，怎样处理?

img

为什么不能直接传args：因为数组也是object类型。在传递时，底层的invoke方法认为要调用的参数有四个。

为什么int[]直接传递args不报错，而Integer[]会报错：因为int[]数组中的每一个元素不是Object，只是基本数据类型，int[]被认为是一个对象。而Integer[]数组中的每一个元素都是Object

/*反射的调用和正常类的调用是恰好相反的。

正常类：p.show() p.show(参数)

反射：show.invoke(p) show.invoke(p，参数)

*/

案例：（这个案例可以帮助我们把集合中的值通过反射赋到一个类中）

img

并提供get/set方法

img

使用java中的反射技术将类中的属性与map中的key相同名称的，使用反射技术将key对应的value值赋值给属性.

采用两种方式完成操作：

1.直接操作属性 Field来完成操作（不常用）

img

2.通过属性对应的setXxx方法来完成操作

img

优点：

1、反射提高了程序的灵活性和扩展性。

2、降低耦合性，提高自适应能力。

3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。
缺点：
1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。

2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，因而会带来维护的问题，反射代码比相应的直接代码更复杂。

反射：需要配置文件配合使用。

配置文件是键值对。必须要有键，代码获取键；然后可以自己通过改变值，来使代码中的对象改变，从而获得不同的运行效果。

反射可以越过泛型检查。

真实的需求应该是在你调用方法后，每次操作前，都需要进行权限校验，在进行操作后，必须留下日志记录。

代理即Proxy Pattern，23种常用的面向对象软件的设计模式之一

代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

组成：

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

真实角色(目标对象)：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

分类：

静态代理：是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

动态代理：是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

优点：

(1).职责清晰，真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。

(2).代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。

(3).高扩展性

动态代理

代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。

动态代理：在程序运行过程中产生的这个对象

而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib（框架中学到，这个代理不仅仅是针对接口）

注意：在java中使用Proxy来完成动态代理对象的创建，只能为目标实现了接口的类创建代理对象。

Proxy类中的方法创建动态代理类对象：

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

ClassLoader loader 是对象的字节码文件的类加载器：.getClass().getClassLoader()

Class<?>[] interfaces是对象的字节码文件的接口：.getClass().getInterfaces()

动态代理是在内存中直接生成代理对象。

img

通过这个方法可以直接创建一个代理对象。

img

//InvocationHandler应用了观察者模式，因为代理类没有实例，所以需要监听代理对象调用时，其底层实现的是目标行为

InvocationHandler h是一个接口，这里需要的是这个接口的实现类对象，所以需要创建一个类实现InvocationHandler接口。这个类中再重写InvocationHandler方法：public Object invoke(Object proxy,Method method,Object[] args)

img

Invoke方法，它是在代理对象调用行为时，会执行的方法，而invoke方法上有三个参数：

proxy:代表动态代理对象

method:要访问的目标行为，代表要调用的方法对象

args:目标行为，代表调用目标方法时传入的实参

这个方法的主要作用是：当我们通过代理对象调用行为时，来控制目标行为是否可以被调用（可以自己写代码控制，return null 不让调，return method.invoke(target,args)控制目标对象的方法执行）。

img

Proxy.newProxyInstance

创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。

System.out.println(u.getClass().getName());

案例:测试addUser方法的运行时间

img

在开发中，在代理中通过目标来调用真实行为，我们使用动态代理可以完成性能监控（如上，进行时间的记录来监控性能），权限控制（在调用目标行为之前先判断是否有权限），日志记录（在调用方法之前，进行日志记录一些信息）等操作

注释（先写注释在写程序）

作用：用于解释说明程序的文字，提高程序的阅读性；可以帮助我们调试程序。

注释分类格式：

单行注释// 可以嵌套

多行注释/* */ 不能嵌套

文档注释/** */

对于单行和多行注释，被注释的文字是不会被JVM解释执行

对于文档注释 是java特有的注释，其中的注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。

/*

需求：

分析：

实现：

*/

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的

它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。你可以在编译时选择代码里的注解是否只存在于源代码级，或者它也能在class文件、或者运行时中出现（SOURCE/CLASS/RUNTIME）。

作用：如果要对于元数据的作用进行分类，还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类：

编写文档：通过代码里标识的元数据生成文档。

代码分析：通过代码里标识的元数据对代码进行分析。

编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查

在现在开发中使用注解，一般是用于将注解替换配置文件。（xml配置文件）

Java中基本内置注解:

1.@Override

它的作用是对覆盖超类中方法的方法进行标记，如果被标记的方法并没有实际覆盖超类中的方法，则编译器会发出错误警告。

注意事项:

​ 对于接口中的方法重写，在jdk1.5时@Override它是会报错.

​ 在jdk1.6后的版本就可以描述接口与类之间的重写

2.@Deprecated

它的作用是对不应该再使用的方法添加注解，当编程人员使用这些方法时，将会在编译时显示提示信息

问题:什么时候方法是过时的?

当前版本中这个方法存在隐患，在后续版本中对其进行了补充，这时前一个版本中的方法就会标注成过时的。

3.@SuppressWarnings

它的作用是去掉程序中的警告.

其参数有：

deprecation，使用了过时的类或方法时的警告

unchecked，执行了未检查的转换时的警告

fallthrough，当 switch 程序块直接通往下一种情况而没有 break 时的警告

path，在类路径、源文件路径等中有不存在的路径时的警告

serial，当在可序列化的类上缺少serialVersionUID 定义时的警告

finally ，任何 finally 子句不能正常完成时的警告

all，关于以上所有情况的警告

可以在方法之前加@SuppressWarnings（“rawtype”）

当一个类中出现了很多，可以在类上加@SuppressWarnings（“all”），一劳永逸

自定义注解

1.注解声明：声明一个注解格式： 修饰符 @interface 注解名{}

2.注解本质分析

分析一下注解的本质:将其.class文件找到，反编译. (可以使用javap命令或反编译工具)

@interface MyAnnoation{}

反编译后的结果

interface MyAnnotation extends Annotation

{

}

结论:注解本质上就是一个接口。它扩展了java.lang.annotation.Annotation接口;

在java中所有注解都是Annotation接口的子接口。

3.注解成员

注解本质上就是一个接口，那么它也可以有属性和方法。

但是接口中的属性是 public static final的，在注解中注解没有什么意义。

在开发中注解中经常存在的是方法（这个方法的返回值类型有要求）。而在注解中接口的方法叫做注解的属性.

4.自定义注解-属性操作

注解属性类型：

1.基本类型 byte short int long float double char boolean

​ 2.String

​ 3.枚举类型：可以自己创建一个枚举类，然后类名 方法名();

​ 4.注解类型

​ 5.Class类型

​ 6.以上类型的一维数组类型

注解属性的使用

1.如果一个注解有属性，那么在使用注解时，要对属性进行赋值操作.

​ 例如:@MyAnnotation(st = “aaa”)

2.如果一个注解的属性有多个，都需要赋值，使用”,”分开属性.

​ @MyAnnotation(st = “aaa”,i=10)

3.也可以给属性赋默认值

​ double d() *default 1.23*;

​ 如果属性有默认值，在使用注解时，就可以不用为属性赋值。

4.如果属性是数组类型

​ 1.可以直接使用 属性名={值1,值2,。。。}方式,例如

​ @MyAnnotation(st = “aaa”,i=10,sts={“a”,”b”})

​ 2.如果数组的值只有一个也可以写成下面方式

​ @MyAnnotation(st = “aaa”,i=10,sts=”a”)

​ 注意sts属性它是数组类型，也就是说，只有一个值时，可以省略”{}”

​

5.对于属性名称 value的操作.

​ 1.如果属性名称叫value,那么在使用时，可以省略属性名称

​ @MyAnnotation(“hello”)

​ 2.如果有多个属性，都需要赋值，其中一个叫value,这时，必须写属性名称

​ @MyAnnotation(value=”hello”,i=10)

​

​ 3.如果属性名称叫value,它的类型是数组类型.

​ 1.只有这个value属性

​ 可以直接赋值，不能写属性名称,但是，如果只有一个值

​ @MyAnnotation({“abc”})或 @MyAnnotation(“abc”)

​ 但是如果有多个值

​ @MyAnnotation({“abc”,”def”})

​ 2.如果有多个属性，属性名称叫value

​ 所有属性都需要赋值，那么必须写属性名称.

5.自定义注解-元注解

元注解及其作用：用于修饰注解的注解，可以描述注解在什么范围及在什么阶段使用等

四个元注解介绍：

@Retention

指定注解信息在哪个阶段存在 Source Class Runtime

img

SOURCE它对应着编译阶段，可以帮助我们进行检查。

CLASS 它对应解析执行阶段

RUNTIME 它对应着在JVM中,在运行时结合反射技术，可以使注解具有一些功能

@Target

指定注解修饰目标对象的类型

TYPE 类、接口 FIELD 成员变量 METHOD 方法

img

在接口的定义中前面进行元注解@Target(ElementType.TYPE)标注后，这个自定义注解只能用在TYPE即类、接口上，不能用于方法上。

如果要求自定义的注解需要用在多个地方。可以@Target({ElementType.TYPE,ElementType.METHOD})

@Documented

使用该元注解修饰，该注解的信息可以生成到javadoc 文档中

@Inherited

如果一个注解使用该元注解修饰，应用注解目标类的子类会自动继承该注解

@Retention @Target 是自定义注解必须使用两个元注解，并且，@Retention它的值应该是RUNTIME,因为我们会结合反射技术来使用。 @Target我们一般使用TYPE或METHOD

案例-获取Connection连接数据库

目的：让注解具有功能，必须结合反射技术来应用。

注解它可以替换配置文件。

第一步:创建注解

img

第二步:使用注解

在方法上进行注解标注：

@JdbcProperty（driverClass=””,url=””,user=””,password=””）

我们可以通过getAnnotation()方法（这个方法在Class，Method。Field中都有）来获取注解对象

img

通过jp.driverClass jp.url 等就可以得到注解的值，然后在数据库连接中使用，进行数据库连接

这里的操作实际上相当于是以前在配置文件中写这些属性值，在代码中从配置文件中取。

问题:使用注解可以替换配置文件，为什么要替换?

​ 配置文件中的信息，它会随着程序的变大，配置信息越来越多，不利于开发。而将配置信息通过注解来替换，便于开发与阅读。

缺点：如果需要更改，需要在源代码上修改注解。

展开全文 >>

GUI编程

GUI(图形用户界面)

Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中

GUI：Graphical User Interface(图形用户接口)。

用图形的方式，来显示计算机操作的界面，这样更方便更直观。

CLI：Command line User Interface (命令行用户接口）

就是常见的Dos命令行操作。

需要记忆一些常用的命令，操作不直观。

java.awt：Abstract Window ToolKit (抽象窗口工具包)，需要调用本地系统方法实现功能。属重量级控件。

javax.swing：在AWT的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件。

javax是java扩展包

和本地系统相关的，就是重量级控件，因为移植性很差。完全由java实现的，移植性就很好，属于轻量级控件。（这里的轻重是与操作系统的关系）

img

Component（组件）

Container：为容器，是一个特殊的组件，该组件中可以通过add方法添加其他组件进来。

Window：窗体 没有边界和标题

Panel：面板

Frame：框架 有边界和标题

Dialog：对话框

FileDialog：文件对话框

Button：按钮

Label：标签

Checkbox：复选框

TextComponent：文本组件

TextArea：文本域 多行多列

TextField：文本框 单行多列

Frame f = new Frame(“my window”);//构造方法命名 setTile是方法命名

f.setLayout(new FlowLayout());//设置为流式布局

f.setSize(300,400);//设置窗体大小 Dimension

f.setLocation(300,200);//设置窗体出现在屏幕的位置 Point

f.setVisible(true);//设置窗体是否可见

一个方法：setBounds（int x,int y,int width,int height）

前后是有顺序关系的，如果f.setVisible(true);在前面就会先显示再加载到指定位置。一般是这个步骤：创建窗体对象；设置窗体属性；设置窗体可见

事件监听机制

事件源：事件发生的地方

事件：要发生的事情

事件处理：针对发生的事情做出的处理方案

事件监听器：就是把事件源和事件关联起来

窗体布局：窗体中组件的排列方式

流式布局FlowLayout：从上到下，从左到右。

边界布局BorderLayout：东西南北中

网格布局GridLayout：网格状，标准n行n列

网格包布局GridBagLayout：可以将任意个相连的网格状连在一起当一个

卡片布局CardLayout：类似于卡片，点一个卡片会在主界面加载一个

展开全文 >>

网络编程

计算机网络：是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

网络编程：就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换。

网络模型：

OSI（Open System Interconnection开放系统互连）参考模型

TCP/IP参考模型

img

网络模型7层概述：

1.物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

  1. 数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机，数据通过交换机来传输。

  2. 网络层：主要将从下层接收到的数据进行IP地址（例192.168.0.1)的封装与解封装。在这一层工作的设备是路由器，常把这一层的数据叫做数据包。

  3. 传输层：定义了一些传输数据的协议和端口号（WWW端口80等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。 主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。

  4. 会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）

6.表示层：主要是进行对接收的数据进行解释、加密与解密、压缩与解压缩等（也就是把计算机能够识别的东西转换成人能够能识别的东西（如图片、声音等）。

7.应用层： 主要是一些终端的应用，比如说FTP（各种文件下载），WEB（IE浏览），QQ之类的（可以把它理解成我们在电脑屏幕上可以看到的东西．就是终端应用）。

网络应用程序：网络编程、IO流、多线程组成。集合

网络通信三要素：

1.IP地址:InetAddress（找到电脑）

​ 网络中设备的标识，不易记忆，可用主机名

2.端口号：（区分电脑的程序）

​ 用于标识进程的逻辑地址，不同进程的标识

3.传输协议：（怎么交流传输）

​ 通讯的规则，常见协议：TCP，UDP

IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接受数据的计算机和识别发送的计算机，在TCP/IP协议中，这个标识号就是IP地址

所谓IP地址就是给每个连接在Internet上的主机分配的一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，比特换算成字节，就是4个字节。例如一个采用二进制形式的IP地址是“00001010000000000000000000000001”，这么长的地址，人们处理起来也太费劲了。为了方便人们的使用，IP地址经常被写成十进制的形式，中间使用符号“.”分开不同的字节。于是，上面的IP地址可以表示为“10.0.0.1”。IP地址的这种把IP地址的每一个字节的数据换算成十进制，然后用.分开来表示的方法叫做“点分十进制表示法”，这显然比1和0容易记忆得多。

IP地址的组成：IP地址 = 网络号码+主机地址

A类 1.0.0.1—127.255.255.254

(1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)

(2)127.X.X.X是保留地址，用做循环测试用的。

B类 128.0.0.1—191.255.255.254

172.16.0.0—172.31.255.255是私有地址。

169.254.X.X是保留地址。

C类 192.0.0.1—223.255.255.254 192.168.X.X是私有地址

D类 224.0.0.1—239.255.255.254

E类 240.0.0.1—247.255.255.254

DOS命令 ipconfig:查看本机IP地址

ping+IP地址：测试本机与指定的ip地址间的通信是否有问题

127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1

xxx.xxx.xxx.0 网络地址

xxx.xxx.xxx.255 广播地址

A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码

B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码

C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码

//A类大部分在美国，中国可能有几个。B类一般是校园网之类的。C类是平常我们用的。DE类是保留地址，不用。

为了方便我们对IP地址的获取和操作，java提供了一个类InetAddress 供我们使用。但是这个类没有构造方法

如果一个类没有构造方法：

A：成员全部是静态的（Math，Arrays，Collections）

B：单例设计模式（Runtime）

C：类中有静态方法返回该类的对象（InetAddress）

class Demo{

private Demo(){}

public static Demo getXxx(){

return new Demo();

}

}

成员方法：

public static InetAdress getByName(String host):根据主机名或者ip地址的字符串表示得到IP地址对象

主机名：getHostName

主机Ip地址：getHostAddress

端口号：正在运行的程序的标识

物理端口 网卡口

逻辑端口 我们指的就是逻辑端口

​ A:每个网络程序都会至少有一个逻辑端口

​ B:用于标识进程的逻辑地址，不同进程的标识

​ C:有效端口：065535，其中01024系统使用或保留端口。

​ 通过一些应用程序就可以查看端口号

协议

UDP：将数据源和目的封装成数据包中，不需要建立连接；每个数据报的大小在限制在64k；因无连接，是不可靠协议；不需要建立连接，速度快

TCP：建立连接，形成传输数据的通道；在连接中进行大数据量传输；通过三次握手完成连接，是可靠协议；必须建立连接，效率会稍低

Socket套接字

网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

Socket原理机制：

通信的两端都有Socket。

网络通信其实就是Socket间的通信。

数据在两个Socket间通过IO传输。

原则上是先存在接收端。

UDP协议发送数据：

A：创建发送端Socket对象

B：创建数据，并把数据打包

C：调用Socket对象的发送方法发送数据包

D：释放资源

UDP协议接收数据：

A：创建接收端Socket对象

B：创建一个数据包（接收容器）

C：调用Socket对象的接收方法接收数据 阻塞式方法

D：解析数据包，并显示在控制台

E：释放资源

运行的时候先运行接收端，在运行发送端。第二次运行接收端会报错：该端口已经被占用

TCP协议发送数据：

A：创建发送端的Socket对象

B：获取输出流，写数据

C：释放资源

运行的话会出现连接被拒绝的错误。所以TCP协议一定要先开服务器

TCP协议发送数据：

A：创建接收端的Socket对象 ServerSocket

B：监听客户端连接，返回一个对应的Socket对象 阻塞式方法

C：获取输入流，读取数据显示在控制台

D：释放资源

TCP传输容易出现的问题：

客户端连接上服务端，两端都在等待，没有任何数据传输：

因为read方法或者readLine方法是阻塞式。

解决办法：A：再多写一条数据告诉服务器，读到这条就结束（不推荐）

B：Socket提供了一个终止功能：public void shutdownOutput()

shutdownInput（）方法

HTTP协议

超文本传输协议，是一个基于请求与响应，无状态的，应用层的协议，常基于TCP/IP协议传输数据，互联网上应用最为广泛的一种网络协议,所有的WWW文件都必须遵守这个标准。设计HTTP的初衷是为了提供一种发布和接收HTML页面的方法。

报文格式

图片

特点：

  1. 无状态：协议对客户端没有状态存储，对事物处理没有“记忆”能力，比如访问一个网站需要反复进行登录操作
  2. 无连接：HTTP/1.1之前，由于无状态特点，每次请求需要通过TCP三次握手四次挥手，和服务器重新建立连接。比如某个客户机在短时间多次请求同一个资源，服务器并不能区别是否已经响应过用户的请求，所以每次需要重新响应请求，需要耗费不必要的时间和流量。
  3. 基于请求和响应：基本的特性，由客户端发起请求，服务端响应
  4. 简单快速、灵活
  5. 通信使用明文、请求和响应不会对通信方进行确认、无法保护数据的完整性

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一起加油吧！