Satoshi

通过Spring和JDBC征服数据库

2019-07-13T00:00:00+08:00

定义 Spring 对数据库访问的支持
配置数据库资源
使用 Spring 的 JDBC 模板

定义 Spring 对数据库访问的支持

Spring 的数据访问异常

配置数据库资源

使用JNDI数据源
使用数据源连接池
基于 JDBC 驱动的数据源
使用嵌入式的数据源
使用 profile 选择数据源

使用 Spring 的 JDBC 模板

简化了 JDBC 代码

JdbcTemplate
NamedParameterJdbcTemplate
SimpleJdbcTemplate

Class And Object

2019-04-25T00:00:00+08:00

类
对象
- 1. 创建对象
- 2. 使用对象

类

1.创建类

下面定义一个简单类:

class MyClass {
    // field, constructor, and
    // method declarations
}

声明一个类需要注意以下几点

需要修饰符，像public这样的
类名首字母要大写
继承父类需要使用关键字 extends ，一个子类只能继承一个父类
实现一个类需要使用关键字 implements ，一个类可以实现多个类，类名之间用逗号隔开
类的主体被大括号包围

1.1 声明成员变量

字段的声明由三部分组成

修饰符：比如public
字段类型
字段名称

1.1.1 修饰符访问权限

public 所有类都可以访问
private 只有类自己可以访问
default 类自己和同包下的其他类

1.1.2 类型
成员变量必须有一个类型，可以使基础类型，也可以是引用对象（数组，对象等）

1.1.3 变量名
遵循变量命名规则，除此之外还要遵循以下规则：

类名首字母大写
方法名第一个词为动词

1.2 定义方法

public double calculateAnswer(double wingSpan, int numberOfEngines,
                              double length, double grossTons) {
    //do the calculation here
}

上面代码定义一个简单的方法，一个方法拥有以下组件：

修饰符，private等
返回类型，方法返回值的类型，如果没有可以使用void
方法名，字段名的命名规则也适用方法名的命名
参数列表，如果没有则为空
异常类型列表，可以不加
方法体

方法声明需要方法名和参数列表：

demo(parameter1,parameter2);

1.2.1 方法名命名建议使用动词或者第一个单词为动词之后可以使用其他类型单词

1.2.3 方法重载方法重载是方法名相同，但是参数列表不一样

1.3 构造器构造器的定义和定义一个方法类似，但是没有返回类型，且名称和类名一样
构造器可以重载
如果一个类无法调用另一个类的构造器，则就无法创建该方法对象

1.4 传递信息给方法和构造器

1.4.1 参数类型
基本类型和引用类型

1.4.2 可变参数

public Polygon polygonFrom(Point... corners) {
    int numberOfSides = corners.length;
    double squareOfSide1, lengthOfSide1;
    squareOfSide1 = (corners[1].x - corners[0].x)
                     * (corners[1].x - corners[0].x)
                     + (corners[1].y - corners[0].y)
                     * (corners[1].y - corners[0].y);
    lengthOfSide1 = Math.sqrt(squareOfSide1);

    // more method body code follows that creates and returns a
    // polygon connecting the Points
}

上述Point为一个有x和y字段的类
在方法内，将可变参数当成一个数组进行处理
我们平时使用的printf就是一个使用可变参数的方法

1.4.3 参数名
1.参数名在方法类必须唯一
2.参数名可以类的字段名称相同，在方法使用相同名称的类的字段需要加上 this 关键字

1.4.4 传递的参数类型
可以是基础类型和引用类型，但是需要注意
使用基本类型，在方法结束返回后，对于参数的修改将消失
使用引用类型，可以保留对参数的修改

2.方法返回值

当出现以下情况时，调用方法时会返回：

执行完方法所有语句
遇到关键字 return
抛出异常

方法的声明类型如果不是 void 则需要有返回语句，返回值的类型必须与声明类型一致
声明类型为 void 的方法需要 return 语句，则可以这样使用

public void methodDemo(){
  //Statement
  return;
}

3关键字 this

使用关键字 this 表示调用当前类的字段或方法

public class Point {
    public int x = 0;
    public int y = 0;

    //constructor
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

使用关键字 this 还可以代指调用构造参数，但是只能在构造函数第一行调用其他构造函数

public class Rectangle {
    private int x, y;
    private int width, height;

    public Rectangle() {
        this(0, 0, 1, 1);
    }
    public Rectangle(int width, int height) {
        this(0, 0, width, height);
    }
    public Rectangle(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
    }
    ...
}

对象

1. 创建对象

创建一个对象有三个部分组成

声明
实例化
初始化

1.1 声明对象
声明对象只需对象类型(Object)和变量名称(objName)
声明一个类不等于创建一个对象，在创建之前无法使用该变量

Object objName

1.2 实例化
使用关键字 new 来实例化一个类，为新对象分配内存并返回该对象的引用

1.3 初始化一个对象
每个类至少有一个构造函数，如果在创建类时没有创建构造函数，在编译时，java编译器会默认提供一个无参构造函数
初始化一个对象需要使用关键字 new 根据参数类型和数量来调用类的构造函数

2. 使用对象

创建对象后，我们可以：

引用对象的字段
调用对象的方法

Java Language Basics

2019-04-23T00:00:00+08:00

变量
运算符
控制语句

变量

变量种类

实例变量：独立方法之外的非static变量
类变量：独立方法之外的static变量
局部变量：方法中的变量
参数：方法后面括号类的参数

命名规则

变量名区别大小写，以字母、$、_ 开头，后面为字母，数字，$和_。人们习惯以字母开头命名变量
变量名不能包含关键字和保留字段
建议命名遵循驼峰式命名规则，一个单词时变量全部小写，两个单词以上组成，第二个开始首字母大写；常量建议全部大写，每个单词以下划线隔开

基本数据类型

Java共有八中基础数据类型

类型	字节	取值范围	默认值
byte	8	-2^7 ~ 2^7-1	0
short	16	-2^15 ~ 2^15-1	0
int	32	-2^31 ~ 2^31-1	0
long	64	-2^63 ~ 2^63-1	0L
float	32	/	0.0f
double	64	/	0.0d
char	16	\u0000 ~ \uffff	‘\u0000’
boolean	/	true/false	false

Java SE 7及以上的版本可以在数字之间加上下划线，但需要遵守以下规则

在数字的开头和结尾不能使用
于浮点类型的小数点附件
在F、L等尾缀之前
在需要一串数字的地方

数组

数组是一个对象容器，类型相同，个数固定
下列代码演示创建一个数组，给数组复制，打印数组

public class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];

        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        for (int i = 0 ; i < anArray.length ; i++) {
            System.out.println("Element at index "+i+":"+
            + anArray[i]);
        }
    }
}

输出如下图所示

声明一个数组需要使用[],该符号可以放在类型后面，也可以放在变量后面

float[] anArray;
float anArray[];

声明只是声明一个数组，并不是创建一个数组
创建一个数组需要使用new关键字，例如ArrayDemo中创建一个int数组
数组的初始化既可以如ArrayDemo一个一个赋值，也可以以如下方式赋值

int[] anArray = {
    100, 200, 300,
    400, 500, 600,
    700, 800, 900, 1000
};

数组的大小由大括号内的逗号相隔的值的数量决定

复制数组

public static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length)

从src的第srcPos个元素开始复制（length-destPos）个元素到数组dest的destPos和length

public class ArrayCopyDemo {
    public static void main(String[] args) {
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
                'i', 'n', 'a', 't', 'e', 'd' };
        char[] copyTo = new char[7];

        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        System.out.println(new String(copyTo));
    }
}

输出如下图所示

数组操作

复制数组copyOfRange
获取数组中特定值的位置binarySearch
比较两个数组 equals
用特定值填充数组 fill
按升序进行排序sort，Java SE

运算符

优先级（由高到低）

运算符	优先度
postfix	expr++ expr–
unary	++expr –expr +expr -expr ~ !
multiplicative	* / %
additive	+ -
shift	« » »>
relational	< > <= >= instanceof
equality	== !=
bitwise AND	&
bitwise exclusive OR	^
bitwise inclusive OR	\|
logical AND	&&
logical OR	\|\|
ternary	? :
assignment	= += -= *= /= %= &= ^= \|= «= »= »>=

赋值、算术、一元运算

赋值运算“=”:将右边的值赋值给左边

int i = 0;
boolean b = false;

算术运算“+、-、*、/、%”，用法如下所示

class ArithmeticDemo {

    public static void main (String[] args) {

        int result = 1 + 2;
        // result is now 3
        System.out.println("1 + 2 = " + result);
        int original_result = result;

        result = result - 1;
        // result is now 2
        System.out.println(original_result + " - 1 = " + result);
        original_result = result;

        result = result * 2;
        // result is now 4
        System.out.println(original_result + " * 2 = " + result);
        original_result = result;

        result = result / 2;
        // result is now 2
        System.out.println(original_result + " / 2 = " + result);
        original_result = result;

        result = result + 8;
        // result is now 10
        System.out.println(original_result + " + 8 = " + result);
        original_result = result;

        result = result % 7;
        // result is now 3
        System.out.println(original_result + " % 7 = " + result);
    }
}

’=’其他用法: 和其他运算符结合,比如上述代码可以改写成:

class ArithmeticDemo {

    public static void main (String[] args) {

        int result = 1 + 2;
        // result is now 3
        System.out.println("1 + 2 = " + result);
        int original_result = result;

        result -= 1;
        // result is now 2
        System.out.println(original_result + " - 1 = " + result);
        original_result = result;

        result *= 2;
        // result is now 4
        System.out.println(original_result + " * 2 = " + result);
        original_result = result;

        result /= 2;
        // result is now 2
        System.out.println(original_result + " / 2 = " + result);
        original_result = result;

        result += 8;
        // result is now 10
        System.out.println(original_result + " + 8 = " + result);
        original_result = result;

        result %= 7;
        // result is now 3
        System.out.println(original_result + " % 7 = " + result);
    }
}

’+’其他用法: 拼接字符串

class ConcatDemo {
    public static void main(String[] args){
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}

输出结果为:

This is a concatenated string.

一元运算符

’+’一元加运算符，表示正值
’-‘一元减运算符，对一个数值取反值
’++(–)’自增(减)运算符，讲一个数值加(减)1
’!’布尔值反转，和逻辑补运算

class UnaryDemo {

    public static void main(String[] args) {

        int result = +1;
        // result is now 1
        System.out.println(result);

        result--;
        // result is now 0
        System.out.println(result);

        result++;
        // result is now 1
        System.out.println(result);

        result = -result;
        // result is now -1
        System.out.println(result);

        boolean success = false;
        // false
        System.out.println(success);
        // true
        System.out.println(!success);
    }
}

++x(–x)和x++(x–)的区别
这两者的区别体现在复合表达式当中，++x(–x)先加(减)1,在参与运算；x++(x–)先参与运算，在改变值

class PrePostDemo {
    public static void main(String[] args){
        int i = 3;
        i++;
        // prints 4
        System.out.println(i);
        ++i;			   
        // prints 5
        System.out.println(i);
        // prints 6
        System.out.println(++i);
        // prints 6
        System.out.println(i++);
        // prints 7
        System.out.println(i);
    }
}

关系运算符

条件运算符

&&，逻辑与，表示两边都为true才为true
||，逻辑或，表示两边其中一个为true就为true
布尔类型表达式 ? 表达式1 : 表达式2，布尔类型表达式为true去表达式1否则为2

类型比较运算符 instanceof

instanceof可以将对象与指定类型进行比较，可以用来测试对象是否为类或子类的实例，以及接口的实现类的实例

位操作符和位移操作符

操作符为 ~ « » »> & ^ |

控制语句

if-then-else 和 if-then 语句

if-then语句只有在条件为true时，才会执行特定的代码段

void testIf() {
    boolean testEvaluates = true;
    if (testEvaluates){
        System.out.println("testEvaluates is true");
    }
}

if-then-else语句，在条件为true时执行if后面的代码段，否则执行else后面的代码段

void testIfElse() {
    boolean testEvaluates = true;
    if (testEvaluates){
        System.out.println("testEvaluates is true");
    } else {
      System.out.println("testEvaluates is not true");
    }
}

上面代码只是if-then-else的基本应用
该控制条件还可以像下面示例一样
下面代码在满足适合条件，就不会执行其他语句

class IfElseDemo {
    public static void main(String[] args) {

        int testscore = 76;
        char grade;

        if (testscore >= 90) {
            grade = 'A';
        } else if (testscore >= 80) {
            grade = 'B';
        } else if (testscore >= 70) {
            grade = 'C';
        } else if (testscore >= 60) {
            grade = 'D';
        } else {
            grade = 'F';
        }
        System.out.println("Grade = " + grade);
    }
}

switch

switch语句目前支持byte、short、char、int、Enum Type、String、Character,、Byte、Short以及Integer
具体用法如下

public class SwitchDemo {
    public static void main(String[] args) {

        int month = 8;
        String monthString;
        switch (month) {
            case 1:  monthString = "January";
                     break;
            case 2:  monthString = "February";
                     break;
            case 3:  monthString = "March";
                     break;
            case 4:  monthString = "April";
                     break;
            case 5:  monthString = "May";
                     break;
            case 6:  monthString = "June";
                     break;
            case 7:  monthString = "July";
                     break;
            case 8:  monthString = "August";
                     break;
            case 9:  monthString = "September";
                     break;
            case 10: monthString = "October";
                     break;
            case 11: monthString = "November";
                     break;
            case 12: monthString = "December";
                     break;
            default: monthString = "Invalid month";
                     break;
        }
        System.out.println(monthString);
    }
}

最终输出

August

每个case后面都有一个break，这样可以在执行适合条件的语句块后跳出switch语句块，如果不加break，则在执行适合的语句块后一直执行语句

while 和 do-while

while如下所示，当expression为true时会一直执行while代码块知道expression为false

while (expression) {
     statement(s)
}

do-while如下所示，他先执行代码块，在判断expression，为true继续执行代码块，知道expression为false

do {
     statement(s)
} while (expression);

他们两个区别在于，do-while至少会执行一次

for语句

for语句现在有两种方式

//通常for循环
for (initialization; termination;
     increment) {
    statement(s)
}

//增强型for循环
for（元素类型  元素名称 : 遍历数组（集合）（或者能进行迭代的））{
  statement(s)
}

上述两种方式都可以实现for循环，推荐第二种实现方式

class ForDemo {
    public static void main(String[] args){
      int[] numbers = {1,2,3,4,5,6,7,8,9,10};
      for(int i=1; i<numbers.length; i++){
        System.out.println("Count is: " + numbers[i]);
      }
      for (int item : numbers) {
        System.out.println("Count is: " + item);
      }
    }
}

分支语句break和continue

break跳出当前循环 continue忽略本次循环，继续执行下一次循环标签，可以让break跳出循环到标签位置，结束迭代；continue跳过用给定标签标记的外部循环的当前迭代，开始下次迭代

class ContinueWithLabelDemo {
    public static void main(String[] args) {

        String searchMe = "Look for a substring in me";
        String substring = "sub";
        boolean foundIt = false;

        int max = searchMe.length() -
                  substring.length();

    test:
        for (int i = 0; i <= max; i++) {
            int n = substring.length();
            int j = i;
            int k = 0;
            while (n-- != 0) {
                if (searchMe.charAt(j++) != substring.charAt(k++)) {
                    continue test;
                }
            }
            foundIt = true;
                break test;
        }
        System.out.println(foundIt ? "Found it" : "Didn't find it");
    }
}

return

return 退出当前方法

Java 面向对象编程的概念

2019-04-22T00:00:00+08:00

What Is an Object?
What Is a Class?
What Is Inheritance?
What Is an Interface?
What Is a Package?

What Is an Object?

对象是由相关状态和行为组成的

将代码块放到对象的好处
1. 模块化
2. 信息隐藏
3. 代码重复利用
4. 可插入和可调式

What Is a Class?

类是创建对象的蓝图或原型
在现实世界中，你会发现有许多相同特征的个体。比如:
所有的自行车都是按照一个蓝图进行设计，以下是自行车一种可能实现的类

class Bicycle {

    int cadence = 0;

    int speed = 0;

    int gear = 1;

    void changeCadence(int newValue) {
        cadence = newValue;
    }

    void changeGear(int newValue) {
        gear = newValue;
    }

    void speedUp(int increment) {
        speed = speed + increment;
    }

    void applyBrakes(int decrement) {
        speed = speed - decrement;
    }

    void printStates() {
        System.out.println("cadence:" +
                cadence + " speed:" +
                speed + " gear:" + gear);
    }
}

字段cadence、speed和gear表示自行车的状态
方法changeCadence、changeGear等表示他和外界的交互

下面是一个BicycleDemo，创建对象并调用他的方法

class BicycleDemo {
    public static void main(String[] args) {

        // Create two different
        // Bicycle objects
        Bicycle bike1 = new Bicycle();
        Bicycle bike2 = new Bicycle();

        // Invoke methods on
        // those objects
        bike1.changeCadence(50);
        bike1.speedUp(10);
        bike1.changeGear(2);
        bike1.printStates();

        bike2.changeCadence(50);
        bike2.speedUp(10);
        bike2.changeGear(2);
        bike2.changeCadence(40);
        bike2.speedUp(10);
        bike2.changeGear(3);
        bike2.printStates();
    }
}

运行结果截图

What Is Inheritance?

继继承为组织和构造软件提供了一种强大的机制
在面向对象编程语言中，一个父类可以拥有许多子类，但只允许继承一个父类
创建子类的关键字为extends,如下列代码所示

class MountainBike extends Bicycle {

    // new fields and methods defining
    // a mountain bike would go here

}

What Is an Interface?

接口是连接类与外部的桥梁
接口是抽象方法的集合，下面声明了一个自行车的接口

interface Bicycle {

    //  wheel revolutions per minute
    void changeCadence(int newValue);

    void changeGear(int newValue);

    void speedUp(int increment);

    void applyBrakes(int decrement);
}

实现接口需要使用关键字implements,一个类可以实现多个接口
下面为实现上面接口的一个类

class ACMEBicycle implements Bicycle {

    int cadence = 0;
    int speed = 0;
    int gear = 1;

   // The compiler will now require that methods
   // changeCadence, changeGear, speedUp, and applyBrakes
   // all be implemented. Compilation will fail if those
   // methods are missing from this class.

    void changeCadence(int newValue) {
         cadence = newValue;
    }

    void changeGear(int newValue) {
         gear = newValue;
    }

    void speedUp(int increment) {
         speed = speed + increment;
    }

    void applyBrakes(int decrement) {
         speed = speed - decrement;
    }

    void printStates() {
         System.out.println("cadence:" +
             cadence + " speed:" +
             speed + " gear:" + gear);
    }
}

What Is a Package?

包是以逻辑的方式组织类和接口
Java Platform API Specification ,Java SE平台提供的所有包、接口、类、字段和方法的完整清