SELECT 语句

SELECT 语句用于从数据库中选取数据。

结果被存储在一个结果表中，称为结果集。

SELECT 语法

SELECT column_name,column_name
FROM table_name;

与

SELECT * FROM table_name;

SELECT DISTINCT 语句

在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。

DISTINC 关键词用于返回唯一不同的值。

SELECT DISTINCT 语法

SELECT DISTINCT column_name,column_name
FROM table_name;

WHERE 子句

WHERE 子句用于提取那些满足指定标准的记录。

WHERE 语法

SELECT column_name,column_name
FROM table_name
WHERE column_name operator value;

AND & OR 运算符

AND & OR 运算符用于基于一个以上的条件对记录进行过滤。

AND & OR 运算符

如果第一个条件和第二个条件都成立，则 AND 运算符显示一条记录。

如果第一个条件和第二个条件中只要有一个成立，则 OR 运算符显示一条记录。

SELECT * FROM Customers
WHERE Country='Germany'
AND City='Berlin';

SELECT * FROM Customers
WHERE City='Berlin'
OR City='München';

SELECT * FROM Customers
WHERE Country='Germany'
AND (City='Berlin' OR City='München');

ORDER BY 关键字

ORDER BY 关键字用于对结果集按照一个列或者多个列进行排序。

ORDER BY 关键字默认按照升序对记录进行排序。如果需要按照降序对记录进行排序，您可以使用 DESC 关键字。

ORDER BY 语法

SELECT column_name,column_name
FROM table_name
ORDER BY column_name,column_name ASC|DESC;

INSERT INTO 语句

INSERT INTO 语句用于向表中插入新记录。

INSERT INTO 语法

INSERT INTO 语句可以有两种编写形式。

• 第一种形式无需指定要插入数据的列名，只需提供被插入的值即可：

    INSERT INTO table_name
    VALUES (value1,value2,value3,...);
  

• 第二种形式需要指定列名及被插入的值：

    INSERT INTO table_name (column1,column2,column3,...)
    VALUES (value1,value2,value3,...);
  

UPDATE 语句

UPDATE 语句用于更新表中已存在的记录。

UPDATE 语法

table_name
SET column1=value1,column2=value2,...
WHERE some_column=some_value;

请注意 SQL UPDATE 语句中的 WHERE 子句！ WHERE 子句规定哪条记录或者哪些记录需要更新。如果您省略了 WHERE 子句，所有的记录都将被更新！

DELETE 语句

DELETE 语句用于删除表中的行。

DELETE 语法

DELETE FROM table_name
WHERE some_column=some_value;

请注意 SQL DELETE 语句中的 WHERE 子句！ WHERE 子句规定哪条记录或者哪些记录需要删除。如果您省略了 WHERE 子句，所有的记录都将被删除！

一些最重要的 SQL 命令

• SELECT - 从数据库中提取数据
• UPDATE - 更新数据库中的数据
• DELETE - 从数据库中删除数据
• INSERT INTO - 向数据库中插入新数据
• CREATE DATABASE - 创建新数据库
• ALTER DATABASE - 修改数据库
• CREATE TABLE - 创建新表
• ALTER TABLE - 变更（改变）数据库表
• DROP TABLE - 删除表
• CREATE INDEX - 创建索引（搜索键）
• DROP INDEX - 删除索引

Tutorial

这一节主要讲在家里怎么也能运行Java，了解它怎么执行的

如果你要创建一个简单的程序并打印在屏幕，那么你需要编译你的代码并运行它。

你不用管你用的是Linux, Mac 或者 Windows. 你需要一个命令处理界面执行如下的命令来编译运行Java

• java (or java.exe)
• javac (or javac.exe)

你首先需要下载安装一个JDK(Java Development Kit).

如果你使用前面章节的代码你可以创建一个这个文件 MyFirstClass.java, 然后编译执行它:

javac MyFirstClass.java

这会生成一个叫 MyFirstClass.class 的文件，它保存了编译后的代码.

然后执行它, 使用它的类名做参数 (不是文件名!)

错误的写法

java MyFirstClass.class

正确的写法!

java MyFirstClass

参数化

main方法可以传入一个字符串数组, 可以通过命名行传入.

数组有个长度length的属性（可以打印出来 数组包含了几个东西）.

例如

public class Arguments {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

然后编译 并 运行（含参数）:

javac Arguments.java
java Arguments arg0 arg1 arg2

Exercise

造一个打印我们自己参数的代码. 写在注释部分

Tutorial Code

public class Arguments { public static void main(String[] args) { // 注释部分 你的代码写在这

}

}

Expected Output

// The following is sample terminal output that // displays the contents of the .java file // we have written (使用 cat 命令), // compiles and runs it with arguments.

$ cat Arguments.java public class Arguments { public static void main(String[] args) { for (int i = 0; i < args.length; i++) { System.out.println(args[i]); } } } $ javac Arguments.java $ java Arguments arg0 arg1 arg2 arg0 arg1 arg2 $

Solution

Tutorial

在Java中一切都包含在类和对象中. Java对象持有状态，状态是该对象内一起保存的变量，我们称他们为字段或成员变量。

让我们从一个例子开始：

class Point {
    int x;
    int y;
}

这个类定义一个点 （拥有x和y属性值）

如果要实例化一个类, 需要使用关键字 new.

Point p = new Point();

在这个列子中, 我们使用了默认构造器 (这个构造器没有参数) 创建这个类. 所有的类不需要显示的定义不干任何事情的默认构造器.

我们可以定义一个自己的构造器:

class Point {
    int x;
    int y;
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

这意味着我们不适用默认的构造器 new Point(). 我们现在只能够使用这个构造器 new Point(4, 1).

我们也可以定义多个构造器, Point 对象可以多种方式创建.下面，我们重新定义默认构造器.

class Point {
    int x;
    int y;
    Point() {
        this(0, 0);
    }
    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

注意关键字 this 的使用. 我们可以在构造器中调用其他的构造器 (避免代码重复)，但只能写在构造方法的第一行.

在运行这个类时，我们也可以使用 this 关键字作为当前对象的使用 .

定义了对象p后 p 可以定义它的属性 x 和 y .

p.x = 3;
p.y = 6;

方法

我们可以在类 Point 中定义方法。

class Point {
    ... // Our code previously
    void printPoint() {
        System.out.println("(" + x + "," + y + ")");
    }
    Point center(Point other) {
        // 返回中心点
        // 因为我们使用的是integer, 这会得到一个约值
        return new Point((x + other.x) / 2, (y + other.y) / 2);
    }

Public公共 and Private私有

我们后面会讨论修饰符, 一定要理解 变量 和 方法前的 private 和 public 修饰符的作用 .

当我们使用关键字 private 定义在变量和方法前时, 是指只用类本事才能方法到变量和方法, 当使用 public 时，指所有的类都可以方法到它。 我们常常看到构造器定义为公共的public,定义私有变量 和定义方法是分开的，他们可以不同。

Exercise

在类Point中写一个scale方法，求中心点。比如 point (8, 4) 经过 scale 方法处理后 变为 (4, 2).

Tutorial Code

class Point {
    private double x;
    private double y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public void print() {
        System.out.println("(" + x + "," + y + ")");
    }
    // 你的代码写在这
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(32, 32);
        for (int i = 0; i < 5; i++) {
            p.scale();
            p.print();
        }
    }
}

Expected Output

(16.0,16.0)
(8.0,8.0)
(4.0,4.0)
(2.0,2.0)
(1.0,1.0)

Solution

class Point {
    private double x;
    private double y;
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public void print() {
        System.out.println("(" + x + "," + y + ")");
    }

    public void scale(){
        x = x/2;
        y = y/2;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(32, 32);
        for (int i = 0; i < 5; i++) {
            p.scale();
            p.print();
        }
    }
}

Tutorial

在Java中方法（或者叫做功能函数）都是定义在内的内容 如下：

public class Main {
    public static void foo() {
        // Do something here
    }
}

foo 是我们在类Main中定义的方法. 下面是需要主要方法 foo 的一些事

• static 意思是这个方法属于类Main 而不是属于类Main实例化的某个对象 . 也就是说我们可以在另外一个类里面像这样 Main.foo() 一样直接用。
• void 意思是这个方法没有返回值。 在Java中也可以给方法定义一个 返回值 ，这个需要在方法声明。
• 现在这个方法没有任何参数, 但是在其他场景Java方法可以有一个或多个参数，稍后我们会看到。

带参的方法 Arguments

我们通常的Java方法的参数是值传递, 但是可能有人不会同意我的这个词汇 或讲法, 最好的解释办法是实际操作，了解它到底是怎么执行的，结果是什么.

值传递表示 当方法运行时，将会拷贝参数，然后在方法内使用。下面是我们定义的方法

public void bar(int num1, int num2) {
    ...
}

这是在另外一个地方调用这个方法

int a = 3;
int b = 5;
bar(a, b);

当 bar(a, b 运行时，你可以想象运行 bar 的后两行加上一个这样的代码 :

int num1 = a;
int num2 = b;

然后在执行方法其余的部分

这意味着 a 的值拷贝到 num1 and b 的值拷贝到 num2. 在方法内改变 num1 and num2不会影响 a and b.

如果参数是对象,规则时一样的,但是执行时有一点点区别. 如下:

public void bar2(Student s1, Student s2) {
    ...
}

现在我们使用这个方法

Student joe = new Student("joe");
Student jack = new Student("jack");
bar2(joe, jack);

同样我们开始运行bar2时相当于加入这两句话

Student s1 = joe;
Student s2 = jack;

但是我们在赋值对象时, 和赋值基本对象的值有一点区别. s1 和joe 是两个不同的引用指向同一个对象 . s1 == joe 是true，这意味着我们运行方法时改变 s1 同时会改变joe . 但是我们改变s1引用指向到其他值， 那么不会影响到索引 joe.

s1.setName("Chuck"); // joe 的 name 也会变为 Chuck 
s1 = new Student("Norris"); //  s1 是一个新的 student对象 , 已经和 joe指向的对象不同了
// s1 == joe    这个时候s1 和 joe 已经不想等了 为false

非静态方法

非静态方法在Java中比静态方法用得多得多。非静态方法只能通过对象调用，而不像静态方法可以直接通过类调用（整个类都能用，不需实例化类）

非静态方法可以访问和修改该对象的field变量 如下的 name 值。

public class Student {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

调用方法需要 Student 类的对象 如下

Student s = new Student();
s.setName("Danielle");
String name = s.getName();

Student.setName("Bob"); // Will not work!不能执行 这是静态方法的方式
Student.getName(); // Will not work!

总结

-每个Java方法必须在类中 -静态方法属于类，而非静态方法属于对象 -所有函数的参数是按值传递，基本类型的内容被复制，而对象不会被复制，有些人会说“按引用传递”

Exercise

在student类中写一个叫 printFullName 的方法，打印student的全名.

Tutorial Code

class Student { private String firstName; private String lastName; public Student(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } // Your code goes here }

public class Main { public static void main(String[] args) { Student[] students = new Student[] { new Student("Morgan", "Freeman"), new Student("Brad", "Pitt"), new Student("Kevin", "Spacey"), }; for (Student s : students) { s.printFullName(); } } }

Expected Output

Morgan Freeman Brad Pitt Kevin Spacey

Solution

class Student { private String firstName; private String lastName; public Student(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; }

public void printFullName() {
    System.out.println (this.firstName+" "+this.lastName);
}

}

public class Main { public static void main(String[] args) { Student[] students = new Student[] { new Student("Morgan", "Freeman"), new Student("Brad", "Pitt"), new Student("Kevin", "Spacey"), }; for (Student s : students) { s.printFullName(); } } }

Tutorial

在java中有两种循环语句, for 和 while.

For

for循环有三个部分，用分号隔开：

for (int i = 0; i < 3; i++) {}

第一部分在我们进入这段话（循环体）时执行 .

第二部分是一个判断语句, 当返回 true, 我们就执行括号里（循环体）的内容, 如果返回 false, 我们就退出循环. 他第一次运行在第一部分运行结束后， 然后等括号内代码运行后以及第三部运行后，再次运行。

第三部分会在每次循环运行的末尾运行.

示例, 这个循环运行 3 次. 分解操作:

int i = 0;
i < 3 // 0 < 3 = true
      //  运行括号内容
i++ // i 现在是 1
i < 3 // 1 < 3 = true
      // 运行括号内容
i++ // i 现在是 2
i < 3 // 2 < 3 = true
      // 运行括号内容
i++ // i 现在是 3
i < 3 // 3 < 3 = false
      // 判断语句返回false 跳出循环...

我们去掉第一第三部分(虽然很奇怪), 他们还是会执行循环(需事先定义了变量i 如 int i = 0;):

for (;i < 5;) {}

下面我们用 while 做循环操作

While

语法很类似我们先前看到的:

while (条件语句) {}

条件语句会在第一次时执行，然后在括号内容执行完 也就是每个循环结束后 再次执行 。当条件语句返回false时跳出循环.

如果我们想要至少循环一次（也就是至少括号内代码执行一次）

do {

} while(condition);

注意 ; 在do-while后面

Foreach

另一个版本的 for语句是 foreach. 关键字还是for, 但是在变量元素集合数组时，可以简单的写成这样，会循环集合或数组大小的次数

int[] arr = {2, 0, 1, 3};
for (int el : arr) {
    System.out.println(el);
}

相等于:

int[] arr = {1, 9, 9, 5};
for (int i = 0; i < arr.length; i++) {
    int el = arr[i];
    System.out.println(el);
}

请注意，如果您要使用循环内的元素的索引，你必须使用较长的版本，不能使用的foreach。

break 和 continue

这两个关键字帮助我们控制内部循环. break 将导致循环停止，循环结束后会立即进入下一个语句：:

int i;
for (i = 0; i < 5; i++) {
    if (i >= 2) {
        break;
    }
    System.out.println("Yuhu");
}
System.out.println(i);
// Output:
// Yuhu
// Yuhu
// 2

continue 将停止当前迭代，并移动到下一个。注意i最后的值为3

int i;
for (i = 0; i < 5; i++) {
    if (i >= 3) {
        break;
    }
    System.out.println("Yuhu");
    if (i >= 1) {
        continue;
    }
    System.out.println("Tata");
}
System.out.println(i);
// Output
// Yuhu
// Tata
// Yuhu
// Yuhu
// 3

Exercise

遍历打印数组中所有的偶数，直到遇到237，就停止打印。

Tutorial Code

public class Main {
    public static void main(String[] args) {
        int[] numbers = {
            951, 402, 984, 651, 360, 69, 408, 319, 601, 485, 980, 507, 725, 547, 544, 
        615, 83, 165, 141, 501, 263, 617, 865, 575, 219, 390, 984, 592, 236, 105, 942, 941, 
        386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345, 
        399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217, 
        815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717, 
        958, 609, 842, 451, 688, 753, 854, 685, 93, 857, 440, 380, 126, 721, 328, 753, 470, 
        743, 527};

        // Your code goes here
    }
}

Expected Output

402 984 360 408 980 544 390 984 592 236 942 386 462 418 344 236 566 978 328 162 758 918

Solution

public class Main {
    public static void main(String[] args) {
        int[] numbers = {
            951, 402, 984, 651, 360, 69, 408, 319, 601, 485, 980, 507, 725, 547, 544, 
            615, 83, 165, 141, 501, 263, 617, 865, 575, 219, 390, 984, 592, 236, 105, 942, 941, 
            386, 462, 47, 418, 907, 344, 236, 375, 823, 566, 597, 978, 328, 615, 953, 345, 
            399, 162, 758, 219, 918, 237, 412, 566, 826, 248, 866, 950, 626, 949, 687, 217, 
            815, 67, 104, 58, 512, 24, 892, 894, 767, 553, 81, 379, 843, 831, 445, 742, 717, 
            958, 609, 842, 451, 688, 753, 854, 685, 93, 857, 440, 380, 126, 721, 328, 753, 470, 
            743, 527};


        for (int i=0; i < numbers.length; i++) {

            int el = numbers[i];
            if (el == 237) break;
            if (el % 2 == 0)           // 使用取余操作符 %
            System.out.print(el+" ");  // 像这样打印!
        }
    }
}