JAVASE总结笔记

代码下载地址：http://download.csdn.net/download/sinat_25926481/9567455

day1

1：面向对象(理解)
(1)面向对象是相对应面向过程而言的一种编程思想，是基于面向过程的。
(2)思想特点：
A:是一种更符合我们思考习惯的思想。
B:把复杂的事情简单化。
C:让我们从执行着变成了指挥者。
(3)案例：
A:买电脑
B:吃饭，洗衣服
C:我要喝水
(4)把大象装进冰箱，让大家对面向对象有一点点的了解。
面向过程：
class Demo {
public static void main(String[] args) {
open();
in();
close();
}

            public static void open() {
                System.out.println("开门");
            }

            public static void in() {
                System.out.println("我要进去");
            }

            public static void close() {
                System.out.println("关门");
            }
        }

    面向对象：
        如何让我们的代码更符合面向对象思想
            A:有哪些类
            B:类有哪些功能
            C:类与类的关系

        class 大象 {
            public void in() {
                System.out.println("我要进去");
            }
        }

        class 冰箱 {
            public void open() {
                System.out.println("开门");
            }

            public void close() {
                System.out.println("关门");
            }
        }

        class Test {
            public static void main(String[] args) {
                冰箱 b = new 冰箱();
                大象 d = new 大象();

                b.open();
                d.in();
                b.close();
            }
        }

2：类与对象的关系(掌握)
(1)现实世界的事物：
属性：事物的特征
行为：事物的功能
(2)java中最基本的单位是类。所以，我们要把事物转换为对应的类。
(3)如何转换呢：
类 事物
成员变量 属性
成员方法 行为

    成员变量：属性，字段
    成员方法：函数，方法
(4)类与对象的概念
    类：是一组相关的属性和行为的抽象的集合体。
    对象：是该类事物的具体存在的个体。

    类：学生
    对象：林青霞

3：类与对象的使用(掌握)
(1)学生类的制作和使用
(2)手机类的制作和使用

4：内存图(理解)
(1)一个对象的内存图：
一个对象的基本初始化过程。
(2)二个对象的内存图：
方法的共用。
(3)三个对象的内存图：
两个引用变量指向同一个对象。

5：成员变量和局部变量的区别?
(1)在类中的位置不同：
成员变量：类中方法外。
局部变量：方法中或者方法声明上。
(2)在内存中的位置不同：
成员变量：堆中。
局部变量：栈中。
(3)生命周期不同：
成员变量：随着对象的存在而存在，随着对象的消失而消失。
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
(4)初始化值不同；
成员变量：有默认初始化值。
局部变量：没有默认初始化值。

问题：
    成员变量和名称可以不可和局部变量一样呢?
        可以。

    class Demo {
        int x = 10;

        public void show() {
            int x = 20;
            System.out.println(x);
        }

        public void method() {
            System.out.println(x);
        }
    }

---

day2

1:变量什么时候该定义成员变量(掌握)
(1)如果变量和类之间存在这描述性的关系，就该定义为成员变量。
(2)注意：
变量的定义范围越小越好。

2:引用类型作为形式参数和返回值(掌握)
(1)顾客点菜案例。
顾客–服务员–厨师
(2)引用类型作为参数和返回值的问题：
A:如果一个方法的形式参数是一个类名，那么，这里肯定需要的是该类的对象。
B:如果一个方法的返回值是一个类名，那么，这里返回的肯定是该类的对象。

    class Demo {
        public void printStudent(Student s) {
            s.show();
        }

        public Student getStudent() {
            Student s = new Student();
            return s;
        }
    }

3:匿名对象(理解)
(1)就是没有名字的对象。
(2)应用场景：
A:调用方法。但是仅仅只调用一次的时候使用。
B:作为实际参数传递。
Demo d = new Demo();
d.printStudent(new Student());

4:封装(理解)
(1)隐藏实现细节，提供公共的访问方式。
(2)体现有哪些呢?
A:类
B:方法体
C:private修饰成员变量
(3)private关键字：
是私有的意思。可以修饰类中的成员变量和成员方法。
注意：被它修饰的成员只能在本类中被访问。
(4)标准代码：
class Student {
private String name;
private int age;

        public void setName(String n) {
            name = n;
        }

        public String getName() {
            return name;
        }

        public void setAge(int a) {
            age = a;
        }

        public int getAge() {
            return age;
        }
    }

5:构造方法(掌握)
(1)创建对象，并对对象的内容进行初始化。
(2)特点：
A:方法名和类名相同。
B:没有返回值类型。
C:没有返回值。
(3)注意事项：
A:如果我们没给构造方法，系统给出一个默认构造。无参构造。
B:如果我们给出了构造方法，系统将不再提供构造方法。
这个时候，要么我们不使用无参构造方法。
要么，自己定义一个，然后使用。

        推荐：自己给出无参构造方法。
(4)给成员变量赋值的方式：
    A:无参+setXxx()
    B:带参
(5)获取值：
    getXxx()
(6)标准代码：
    class Student {
        private String name;
        private int age;

        public Student() {}

        public Student(String n,int a) {
            name = n;
            age = a;
        }

        public void setName(String n) {
            name = n;
        }

        public String getName() {
            return name;
        }

        public void setAge(int a) {
            age = a;
        }

        public int getAge() {
            return age;
        }
    }

6：this关键字。(掌握)
(1)代表当前类的一个对象。谁调用代表谁。
(2)应用场景：
A:使用本类的成员变量(掌握)
this.变量名;
B:使用本类其他构造方法
this(…)
C:使用本类的其他成员方法
this.方法名();
(3)标准代码：
class Student {
private String name;
private int age;

        public Student() {}

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

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public int getAge() {
            return age;
        }
    }

    测试类：
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(27);
        System.out.println(s.getName()+"---"+s.getAge());

        Student ss = new Student("林青霞",27);
        System.out.println(ss.getName()+"---"+ss.getAge());
(4)案例：
    A:手机标准代码案例及测试。
    B:长方形标准代码案例及测试。

7：static关键字(理解)
(1)是静态的意思，可以修饰类中成员变量和成员方法。
(2)静态的特点：
A:随着类的加载而加载。
B:优先于对象存在。
C:被所有对象共享的数据。
这个也被我们作为为什么要使用静态的一个判断条件。
举例：饮水机和水杯。
D:让我们的调用多了一种方式：
a:非静态的数据，必须创建对象访问。
b:静态的数据，可以通过对象访问，也可以通过类名访问。
(3)静态的访问问题：
A:非静态方法
非静态成员变量
静态成员变量
非静态成员方法
静态成员方法
B:静态方法
静态成员变量
静态成员方法

    总之：静态只能访问静态。

    称呼：
        静态的成员被成为类成员。跟类相关。
        非静态的成员被称为实例成员。跟对象相关。
(4)main方法的解释以及如何接收键盘录入数据：
    public:权限最大
    static:静态，不用创建对象。
    void:返回没有意义。
    main:大家都是这样做的。
    String[] args:接收键盘录入数据。
    接收键盘录入的格式：
        java HelloWorld hello world java
        java HelloWorld 10 20 30

8：代码块(理解)
(1)用{}括起来的代码。
(2)分类：
A:局部代码块。
方法内。
作用：限定变量的生命周期，提高效率。
B:构造代码块。
类中，方法外。
作用：把所有构造方法中相同的代码定义到一处。
C:静态代码块。
类中，方法外，加static。
作用：在整个系统运行过程中只执行一次的内容。
(3)面试题：
构造方法，构造代码块，静态代码块的执行流程?
静态代码块 – 构造代码块 – 构造方法。

    特点：
        静态代码块只执行一次。
        构造代码块每次调用构造方法都执行。

9：一个类的实例化过程(理解)
Person p = new Person();

A:把Person.class加载到内存。
B:在栈内存为p变量开辟空间。
C:在堆内存为Person对象开辟空间。
D:对成员变量进行默认初始化。
E:对成员变量进行显示初始化。
F:如果有构造代码块，通过构造代码块对成员变量进行初始化。
G:通过构造方法对成员变量进行初始化。
I:对象初始化完毕，把堆内存的地址给p变量。

---

day3

1：制作工具类和API。(了解)
(1)静态的使用场景：
A:被所有对象共享的数据。
B:工具类一般成员都是静态修饰。
(2)如何通过javadoc命令制作帮助文档呢?
A:写一个java源程序。
B:对java源程序加入文档注释。
C:通过javadoc命令生成即可。
javadoc -d doc -author -version ArrayTools.java

2：使用API(掌握)
(1)使用API的步骤：
参照：day08\code\02_如何使用API和Math类的学习\如何使用API.txt
(2)通过Math类的学习来实践。
A:绝对值
B:向上/下取整
C:最大/小值
D:四舍五入
E:平方根
F:次幂
G:随机数
(3)案例：
猜数字小游戏。

3：继承(掌握)
(1)把多个类中相同的内容提取出来，定义到一个类中。
然后让这多个类和这个类产生一个关系，这多个类就具备该类的数据了。
这种关系叫：继承。
(2)表现形式：
class SonClass extends FuClass {}

    SonClass: 子类,派生类
    FuClass: 父类，基类，超类
(3)继承的好处：
    A:提高了代码的复用性。
    B:让类与类之间产生了一个关系，是多态的前提。
(4)Java中继承的特点：
    A:Java中类只支持单继承。
    B:Java中类可以多层(重)继承。
(5)继承间的成员关系：
    A:成员变量
        在子类方法中使用变量：
            局部范围
            成员范围
            父类成员范围
    B:构造方法
        a:子类构造方法中默认去访问父类的无参构造方法。
            原因：因为子类要使用父类的数据，父类的数据必须先初始化。
        b:假如父类没有构造方法
            要么，使用super(...)调用带参
            要么，使用this(...)访问本类其他构造，本类至少有一个构造方法访问了父类构造方法。
    C:成员方法
        通过子类对象使用成员方法：
            子类
            父类

4：方法重写(掌握)
(1)子类中出现了和父类中方法声明一模一样的方法。
复写，覆盖。
(2)注意事项：
A:子类方法的权限不能低于父类方法的权限
B:父类私有的不能被重写
C:静态只能重写静态。(多态中讲解一个问题)

5：面试题：(理解)
(1)程序分析题中的所有题目。
(2)方法重载和方法重写的区别?
(3)this和super的区别?

6：案例：(掌握)
(1)猫狗案例使用继承和不使用继承的实现。
(2)学生和老师的案例。

---

day4

1：final(掌握)
(1)是一个关键字，表示的是最终的意思。
(2)它可以修饰类，修饰成员变量，修饰成员方法。
(3)特点：
它修饰的类不能被继承。
它修饰的变量是常量。
它修饰的成员方法不能被重写。
(4)面试题：
修饰局部变量。

    方法的形式参数：
        基本类型：基本类型的值不能发生改变。
        引用类型：引用类型的地址值不能发生改变，但是内容可以发生改变。

2：多态(掌握)
(1)同一个对象在不同时刻表现出现的多种状态。
举例：
水(水蒸气,冰,水)
理解：
编译时期状态和运行时期状态不一致的现象。

        判断下面哪个有问题：从右边往左边念。
        Fu f = new Fu();
        Zi z = new Zi();
        Fu f = new Zi(); //多态
        Zi z = new Fu(); //报错
(2)多态的前提：
    A:要有继承或者实现关系。
    B:有方法重写。
        因为一般都是抽象类或者接口的多态。
    C:要有父类/父接口的引用指向子类对象。
(3)多态访问的成员特点：
    Fu f = new Zi();

    A:成员变量
        编译看左边，运行看左边。
    B:成员方法
        编译看左边，运行看右边。
    C:静态方法
        编译看左边，运行看左边。
(4)多态的好处和弊端：
    A:好处
        提高了程序的可维护性和可扩展性。
        维护性：继承保证
        扩展性：多态保证
    B:弊端
        父类/父接口不能访问子类特有功能。
(5)多态中的类型转换：
    A:向上转型
        Fu f = new Zi();
    B:向下转型
        Zi z = (Zi)f;

    举例：孔子装爹。
(6)多态的体现形式：
    A:具体类多态
        class Fu {}
        class Zi extends Fu {}

        Fu f = new Zi();
    B:抽象类多态
        abstract class Fu {}
        class Zi extends Fu {}

        Fu f =  new Zi();
    C:接口多态
        interface Inter {}
        //接口的实现类命名：接口名+Impl
        class InterImpl implements Inter{}

        Inter i = new InterImpl();

3：抽象类(掌握)
(1)把多个类中相同的方法声明给抽取出来。定义到一个类中。
一个方法如果只有方法声明，没有方法体，那么该方法必须定义为抽象方法。
而一个类中如果有抽象方法，那么，该类必须定义为抽象类。
(2)抽象类的特点：
A:抽象方法和抽象类都必须用abstract表示。
B:一个类继承抽象类的时候；
要么：本身是一个抽象类。
要么：实现抽象类中的所有抽象方法。
C:抽象类不能实例化。可以按照多态的使用方式使用。
D:成员特点：
a:成员变量
可以是变量，也可以是常量。
b:构造方法
有
c:成员方法
可以是抽象，也可以非抽象。
(3)抽象类的好处：
A:抽象类中的非抽象方法提高了代码的复用性。
B:抽象类中的抽象方法强制要求子类必须重写某些方法。
(4)抽象类的案例：
A:猫狗案例
B:老师案例
C:学生案例(自己做的)
D:员工案例
(5)抽象类中的几个小问题：
A:抽象类不能实例化，构造方法有什么用呢?
用于子类访问父类数据的初始化。
B:如果一个类中没有抽象方法，而类却被定义为了抽象类，请问为什么?
不让创建对象。
C:abstract不能和哪些关键字共存：
private: 冲突
final: 冲突
static: 无意义

4：接口(掌握)
(1)如果一个抽象类中的所有成员方法都是抽象的，java就提高了一种更抽象的表达方式：接口。
(2)接口的特点：
A:接口用interface定义。
类实现接口用implements关键字。
B:一个类要实现接口：
要么：本身是抽象类。
要么：实现接口中的所有抽象方法。
C:接口不能实例化。可以按照多态的使用方式使用。
D:成员特点：
a:成员变量：只能是常量。
默认修饰符：public static final
b:成员方法：只能是抽象方法。
默认修饰符：public abstract
(3)类与接口的关系：
A:类与类的关系
继承，单继承。
B:类与接口的关系
实现，单实现，多实现。
继承一个类的同时实现多个接口。
C:接口与接口的关系
继承，单继承，多继承。
(4)案例：
A:猫狗案例用接口实现基本版本。
(5)抽象类和接口的区别:
A:成员区别
抽象类：
a:成员变量
可以是变量，也可以是常量。
b:构造方法
有
c:成员方法
可以是抽象，也可以非抽象。
接口：
a:成员变量：只能是常量。
默认修饰符：public static final
b:成员方法：只能是抽象方法。
默认修饰符：public abstract
B:关系区别
a:类与类的关系
继承，单继承。
b:类与接口的关系
实现，单实现，多实现。
继承一个类的同时实现多个接口。
c:接口与接口的关系
继承，单继承，多继承。
C:设计理念不同
抽象类被继承体现的是：is a的关系。抽象类中定义的是继承体系共性功能。
接口被实现体现的是：like a的关系。接口中定义的是继承体系的扩展功能。

    案例：
        运动员和教练案例。

        分析：从具体到抽象。
        实现：从抽象到具体。
        使用：具体。

---

day5

1：包(掌握)
(1)其实就是文件夹。
(2)作业：把同名称的类放到不同的文件夹下使用。
(3)格式：
package xxx.yyy.zzz;
(4)带包的类的编译和运行：
A:手动式
a:javac编译当前类文件。
b:手动建立包对应的文件夹。
c:把a的class文件放到b的最终文件夹下。
d:通过java命令执行。注意了：需要带包名称的执行。
java cn.itcast.HelloWorld
B:自动式
a:javac编译的时候带上-d即可
javac -d . HelloWorld.java
b:通过java命令执行。注意了：需要带包名称的执行。
java cn.itcast.HelloWorld

2：导包(掌握)
(1)不同包下的类之间的访问。
我们发现，每次使用不同包下的类的时候，都需要加包的全路径。
比较麻烦。这个时候，java就提供了导包的功能。
(2)格式：
import xxx.yyy.zzz.类名;

    扩充格式：
        import xxx.yyy.zzz.*;
        但是不建议使用这种做法。
(3)面试题：
    package,import,class的有没有顺序呢?
    package > import > class

    唯一    多个       多个

3：权限修饰符(掌握)
(1)案例：
cn.itcast
Fu
Zi
Demo
com.liuyi
Zi
Demo
(2)结论：
本类 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认(什么都没有) Y Y
protected Y Y Y
public Y Y Y Y

4：常见的修饰符的使用(掌握)
类 成员变量 构造方法 成员方法
private Y Y Y
默认 Y Y Y Y
protected Y Y Y
public Y Y Y Y
final Y Y Y
static Y Y
abstract Y Y

类：public
成员变量：private
构造方法：public 
成员方法：public

5：内部类(理解)
(1)把类定义在其他类的内部，就被称为内部类。
(2)内部类的访问特点：
A：内部类可以直接访问外部类的成员，包括私有。
B：外部类要访问内部类的成员，必须创建对象。
(3)内部类的分类：
A:成员内部类
a:private 访问的安全性
b:static 访问的方便
B:局部内部类
a:带名字的(类)
b:不带名字的(对象)
(4)面试题：
局部内部类访问局部变量必须加final修饰。
(5)匿名内部类：(掌握)
格式：
new 类名或者接口名() {
重写方法;
};

     本质：是继承类或者实现接口的子类匿名对象。
(6)案例：
    开发中怎么用：
        interface Inter {
            public abstract void show();
        }

        class InterDemo {
            public void method(Inter i) {
                i.show();
            }
        }

        class InterTest {
            public static void main(String[] args) {
                InterDemo id = new InterDemo();
                id.method(new Inter(){
                    public void show() {
                        System.out.println("HelloWorld");
                    }
                });
            }
        }

    面试题：
        interface Inter {
            void show();
        }

        class Outer {
            //补齐代码
            public static Inter method() {
                return new Inter(){
                    public void show() {
                        System.out.println("show");
                    }
                };
            }
        }

        class OuterDemo {
            public static void main(String[] args) {
                Outer.method().show();
            }
        }

---

day6

1：Object(理解)
(1)是类层次结构的根类，所有的类都直接或者间接的继承自该类。
(2)成员方法：
A:toString()
返回对象的字符串表示。
默认格式：包名.类名@哈希值的十六进制。
建议重写该方法。而且，不用自己动手。
B:getClass()
返回对象的字节码描述文件。反射时候再讲。
C:hashCode()
返回对象的哈希值。可以理解为地址值。
D:finalize()
被对象的垃圾回收器调用，用于垃圾回收。
E:equals()
默认情况下，比较对象的地址值。
建议重写该方法。而且，不用自己动手。
一般重写方法的时候：都是比较的是对象的成员变量值。
(3)==和equals()的区别?
A:==
a:基本类型 比较的是基本类型的值
b:引用类型 比较的是引用类型的地址值
B:equals()
只能比较引用类型。
默认比较地址值。

2：Scanner(了解)
(1)用于键盘录入的。
(2)使用步骤：
A:导包
B:创建对象
C:调用方法
(3)成员方法：
int nextInt()
String nextLine()
(4)小问题：
int – int
String – String
String – int
int – String 有问题。

    解决方案：
        A:要么都是字符串，然后要什么转成什么。
        B:重新创建一个新的录入对象。

3：String(掌握)
(1)多个字符组成的一串数据。
(2)构造方法：
A:String s = new String();
B:String s = new String(byte[] bys);
C:String s = new String(byte[] bys,int index,int count);
D:String s = new String(char[] chs);
E:String s = new String(char[] chs,int index,int count);
F:String s = new String(String str);
G:String s = “hello”;
(3)面试题：
A:字符串一旦被赋值就不能被改变。
请自己理解这句话。
B:String s = new String(“hello”)和String s = “hello”;的区别
前者创建了2个对象
后者创建了1个对象
C:看程序写结果
String s1 = new String(“hello”);
String s2 = new String(“hello”);
System.out.println(s1==s2);
System.out.println(s1.equals(s2));

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5==s6);
        System.out.println(s5.equals(s6));
    D:看程序写结果
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3==s1+s2);
        System.out.println(s3.equals(s1+s2));
(4)常见方法：(补齐中文意思)
    A:判断功能
        boolean equals(Object obj)
        boolean equalsIgnoreCase(String str)
        boolean contains(String str)
        boolean startsWith(String str)
        boolean endsWith(String str)
        boolean isEmpty()
    B:获取功能
        int length()获取字符串长度。
        char charAt(int index)
        int indexOf(int ch)
        int indexOf(int ch,int fromIndex)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)
    C:转换功能
        byte[] getByteds()
        char[] toCharArray()
        static String copyValueOf(char[] chs)
        static String valueOf(char[] chs)j
        static String valueOf(int i)基本类型
        String toLowerCase()
        String toUpperCase()
        String concat(String str)
    D:其他功能
        String replace(char old,char new)
        String replace(String old,String new)
        String trim()
        int compareTo(String str)
        int compareToIgnoreCase(String str)
(5)案例：
    A:模拟登录
    B:遍历字符串
        a:length()和charAt()
        b:把字符串转成字符数组
    C:统计字符串中大写，小写，数字字符个多少个
    D:把字符串的首字母转成大写，其他小写
    E:查找大串中小串出现的次数

---

day7

1:StringBuffer/StringBuilder(掌握)
(1)字符串缓冲区类。
(2)String,StringBuffer/StringBuilder的区别?
A:String的字符串长度固定。而StringBuffer/StringBuilder的字符串长度是可以改变的。
B:StringBuffer是线程安全的，效率低。
StringBuilder是线程不安全的，效率高。
(3)构造方法：
A:StringBuffer sb = new StringBuffer();
B:StringBuffer sb = new StringBuffer(50);
C:StringBuffer sb = new StringBuffer(“hello”);
(4)成员方法：
A:添加功能
append,insert
B:删除功能
delete,deleteCharAt
C:替换功能
replace
D:截取功能
substring
E:反转功能
reverse
(5)案例：
A:把一个数组转成一个字符串：
[11, 22, 33, 44, 55]
B:把一个字符串反转输出：
输入：abc
输出：cba
(6)两个类可以相互转换，其实是为了使用别人的功能。

2:数组操作(掌握)
(1)基本操作：
A:遍历
B:获取最值
C:数组发转
D:基本查表法
E:基本查找
(2)高级操作：
A:排序
冒泡:相邻元素依次比较。
public static void bubbleSort(int[] arr) {
for(int x=0; x

day8

1：正则表达式(理解)
(1)符合一定规则的字符串。
(2)规则：
A：字符
x 字符 x
\ 反斜线字符
\r 回车
\n 换行

    B：字符类
        [abc] a、b 或 c（简单类） 
        [^abc] 任何字符，除了 a、b 或 c（否定） 
        [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内 
        [0-9] 0-9的数字字符

    C：预定义字符类
        . 任何字符
        \d 数字：[0-9]
        \w 单词字符：[a-zA-Z_0-9]
            在正则表达式中可以组成单词的字符。 

    D：边界匹配器
        ^ 行的开头 
        $ 行的结尾
        \b 单词边界 (出现的地方不能是单词字符。)
            hello,world ja?v;a

            hello
            world
            ja
            v
            a

    E：数量词
        X? X，一次或一次也没有 
        X* X，零次或多次 
        X+ X，一次或多次 
        X{n} X，恰好 n 次 
        X{n,} X，至少 n 次 
        X{n,m} X，至少 n 次，但是不超过 m 次9 
(3)正则表达式的功能：
    A:判断功能
        String -- public boolean matches(String regex)
    B:分割功能
        String -- public String[] split(String regex)
    C:替换功能
        String -- public String replaceAll(String regex,String replacement)
    D:获取功能
        Pattern -- public static Pattern compile(String regex)
               public Matcher matcher(String input)
        Matcher -- public boolean find()
                   public String group()
(4)案例：
    A:校验QQ号码。
    B:校验电话号码。
    C:校验邮箱。
    D:按要求分割字符串。
    E:把论坛中的所有数字用*替换。
    F:获取三个字符组成的单词。

2：Random(理解)
(1)用于产生随机数的类。
(2)构造方法：
Random:没有种子。每次产生的都是变化的。
Random(long seed):有种子。种子一样，产生的随机数一致。
(3)成员方法：
int nextInt():返回int范围
int nextInt(int n):返回[0,n)范围
(4)案例：
获取随机姓名。

3：System(理解)
(1)系统类，提供了一些静态的功能供我们使用。
(2)成员方法：
A:public static void gc() 运行垃圾回收器。
B:public static void exit(int status)
终止当前正在运行的 Java 虚拟机。
参数用作状态码；根据惯例，非 0 的状态码表示异常终止。
C:public static long currentTimeMillis()返回以毫秒为单位的当前时间。
D:public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)

4：Date/DateFormat/Calendar(掌握)
(1)Date 日期类。可以精确到毫秒。
A:构造方法
Date()
Date(long time)
B:成员方法
void setTime(long time)
long getTime()
C:要掌握的内容
如何得到毫秒值：
Date – getTime()
System – currentTimeMillis()
如何设置日期的毫秒值：
Date – Date(long time)
Date – setTime(long time)
(2)DateFormat 对日期进行格式化和解析的类。
A:Date – String
public final String format(Date date)
B:String – Date
public Date parse(String source)
C:DateUtil的使用。
(3)Calendar 日历类。把时间给分割成一个个的日历字段，
你可以通过get方法根据给定的日历字段获取对应的值。来组合一个完整的时间。
A:根据给定的日历字段获取对应的值
public int get(int field)
B:设置年月日
public final void set(int year,int month,int date)
C:根据给定的日历字段和值，来决定是加还是减去对应的值
public void add(int field,int amount)
D:获取任意一年的2月份有多少天?

---

day9

1：对象数组(掌握)
(1)其实就是数组中存储的元素是对象。
(2)案例：
创建一个对象数组存储5个学生对象。并遍历。

2：Collection(掌握)
(1)我们学习的是面向对象的语言，而面向对象的语言操作的时候，是以对象为主。
我们如果想操作多个对象，就必须首先把这个多个对象给存储起来。
到目前位置，我们仅仅只能使用数组来做这个事情。
而数组有一个弊端，就是对象的个数必须是固定的。
这个时候，java就提供了另外的一种容器：集合。
(2)数组和集合的区别?
A:数组
长度固定
元素可以是基本类型，也可以是引用类型。
只能存储同一种数据类型。
B:集合
长度可变
元素只能是引用类型。
可以存储不同的数据类型。
(3)Collection继承体系结构图：
Collection
|–List
|–ArrayList
|–Vector
|–LinkedList
|–Set
|–HashSet
|–TreeSet

    分析：从具体到抽象
    实现：从抽象到具体
    学习：抽象
    使用：具体
(4)Collection集合的功能概述：(自己补齐 补齐方法名称和方法的解释)
    A:添加功能
    boolean add(Object e):往集合中添加一个元素。
    boolean addAll(Collection c):往集合中添加一个集合的元素。

    B:删除功能      
    void clear():移除集合中的所有元素。
    boolean remove(Object o):移除集合中指定的一个元素。
    boolean removeAll(Collection c):移除集合中指定的一个集合的元素。

    C:判断功能
    boolean contains(Object o):判断集合中是否包含指定的元素。
    boolean containsAll(Collection c):判断集合中是否包含指定的一个集合的元素。
    boolean isEmpty():判断集合是否为空。

    D:迭代器   Iterator iterator()用于获取集合中的元素。

    E:长度功能
    int size():获取集合中元素的个数。

    F:交集功能
    boolean retainAll(Collection c)

    G:转换为数组
    Object[] toArray():把集合转换为数组。
(5)迭代器
    A:迭代器是集合的一种遍历方式。
    B:迭代器的使用步骤
        a:通过集合对象获取迭代器对象。
        b:通过迭代器对象判断是否有元素。
        c:通过迭代器对象获取元素，并移动到下一个位置。

    C:每种具体的集合的迭代器的具体实现是在每个具体集合类中。
      以内部类的方式实现的。
(6)案例：
    创建集合对象
    创建元素对象
    把元素添加到集合中
    遍历集合

    A:Collection存储字符串并遍历。

        Collection c = new ArrayList();

        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator it = c.iterator();
        while(it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }

    B:Collection存储自定义对象并遍历。(自己补齐)

3：List(掌握)
(1)List的特点
Collection
|–List
元素有序(存储顺序和取出顺序一致)，可重复。
|–set
元素无序，唯一。
(2)List集合的特有功能：(自己补齐 补齐方法的返回值类型和方法说明)
A:添加功能
add(int index,Object) 在指定的位置添加元素。
B:删除功能
remove(int index) 删除指定索引位置的元素，并返回该元素。
C:修改功能
set(int index,Object obj) 用指定的元素修改指定位置的元素，并把修改前的元素返回。
D:获取功能
get(int index) 根据给定的索引，获取元素。
E:列表迭代器
(3)案例：
A:List集合存储字符串并遍历。
a:迭代器
b:普通for(get()和size()结合使用)
B:List集合存储自定义对象并遍历。
(4)ListIterator的使用：
A:可以逆向遍历，但是要先正向遍历，一般不用。
B:并发修改异常的问题：
用迭代器迭代元素的时候，不能通过集合去改变集合。

        解决方案：
            a:集合遍历，集合修改。
            b:列表迭代器遍历，列表迭代器修改。

---

day10

1：泛型(理解)
(1)泛型类
class Demo {
public void show(QQ qq) {
…
}
}
(2)泛型方法
class Demo {
public void method(T t) {
…
}
}
(3)泛型接口
interface Inter {
void show(QQ qq);
}

    //方式1
    class InterImpl implements Inter {
        public void show(String s){

        }
    }

    //方式2
    class InterImpl implements Inter {
        public void show(QQ qq){
            ...
        }
    }

2：Set(掌握)
(1)Collection
List 有序，可重复。
Set 无序，唯一。
(2)HashSet
如何保证元素唯一性的呢?
底层数据结构是哈希表(散列表)。具体的是由一个元素是单向链表的数组组成。
它依赖于两个方法：hashCode()和equals()方法。
执行顺序：
先判断hashCode()是否相同，
如果相同
继承执行equals()方法，看其返回值：
true:元素重复，不存储。
false:元素不重复，存储。
如果不同
存储。

    记住：
        看到HashXxx结构的集合，就要知道，被该集合存储的元素要重写hashCode()和equals()方法。
        而且，是自动生成的。
(3)TreeSet  
    底层数据结构是二叉树。

    如何保证元素的唯一性的呢?
        根据比较的返回值是否是0来决定。
    如何保证元素的排序的呢?
        A:自然排序 元素具备比较性
            让集合中被存储的元素所属的类实现Comparable接口。
        B:比较器排序 集合具备比较性
            在创建集合对象的时候，让构造方法接收一个Comparator接口的子类对象。
(4)LinkedHashSet
    底层由链表和哈希表组成。
    由链表保证有序。
    由哈希表保证唯一。
(5)案例：
    HashSet:
        存储String
        存储Student
        存储Person
    TreeSet:
        存储String
        存储Integer
        存储Student
        存储Person

3：静态导入(了解)
(1)以前的导入是导入到类的级别，现在可以通过静态导入，导入到方法的级别。
(2)格式：
import static java.xxx.xxx.方法名;

    注意：
        要能看懂这种东西，自己一般不用。

4：可变参数(理解)
(1)针对在写一个方法的时候，不知道具体要有多少个形式参数的时候。
java提供了可变参数的用法。
(2)格式：
修饰符 返回值类型 方法名(数据类型… 变量) {

    }

    注意：
        A:变量其实是该数据类型的一个数组。
        B:形式参数如果有多个的话，可变参数只能是最后一个。
        C:数据类型要一致。
(3)Arrays工具类的asList方法的使用。
    注意：用数组转换后的集合的长度不能发生改变。


        （集合数组之间的相互转换是个不明白的点儿）

---

day11

1：Map集合(掌握)
(1)Map集合存储是键值对形式的元素。
(2)Map和Collection集合的区别(面试题)
A:Map集合存储的是键值对形式的元素。
Collection集合存储的是单个的元素。
B:Map集合的键是唯一的。
Collection的儿子Set集合元素是唯一的。
C:Map集合的值是可以重复的。
Collection的儿子List集合的元素是可以重复的。
(3)Map集合的功能概述：(自己补齐 方法的名称，返回值，参数列表及解释说明)
A:添加功能
V put(K key,V value):如果键不存在，就是添加功能。如果键存在，就是修改功能。返回的是被修改前的值。

    B:删除功能
    void clear():清空集合中的所有键值对元素。
    V remove(Object key):根据键删除键值对元素，并把值返回。

    C:判断功能
    boolean containsKey(Object key):判断集合中是否包含指定的键。
    boolean containsValue(Object value):判断集合中是否包含指定的值。
    boolean isEmpty():判断集合是否为空。

    D:获取功能
    Set> entrySet():
    V get(Object key):根据键去集合中获取值。
    Set keySet():返回的是集合中所有键的元素。
    Collection values():返回的是集合中所有值的元素。


    E:长度功能
    int size():集合中的键值对元素的对数。
(4)Map集合的遍历：
    A:通过键找值
        a:获取所有键的集合。keySet()
        b:遍历键的集合，得到每一个键。增强for。
        c:根据键去map集合中找值。get(K key)。

    B:通过键值对对象找键和值(理解)
        a:获取所有键值对对象的集合。entrySet()。
        b:遍历键值对对象的集合，得到每一个键值对对象。增强for。
        c:根据键值对对象获取键和值。getKey(),getValue()。
(5)HashMap案例：
    A:HashMap
    B:HashMap
    C:HashMap
    D:HashMap
(6)TreeMap案例：
    A:TreeMap
    B:TreeMap
(7)其他的案例：
    A:HashMap嵌套HashMap并遍历。
    B:HashMap嵌套ArrayList并遍历。
    C:ArrayList嵌套HashMap并遍历。
    D:统计字符串中每个字符出现的次数。
(8)Hashtable和HashMap的区别?(面试题)
    A:HashMap 线程不安全，效率高。允许null键和null值。
    B:Hashtable 线程安全，效率低。不允许null键和null值。

2：Collections工具类的使用。
(1)Collections是针对集合进行操作的工具类。
(2)Collection和Collections的区别?
A:Collection 是集合的顶层接口，定义了集合中的共性功能。
B:Collections 是针对集合进行操作的工具类。提供了排序，查找等功能。
(3)Collections常见的功能：
A:排序
B:二分查找
C:最大值
D:反转
E:随机置换
(4)扑克牌案例：
A:模拟洗牌
B:模拟洗牌，并对牌进行排序。

---

day12

1：总结集合，请参照集合的总结图.bmp即可。

2：异常(理解)
(1)程序出现的不正常的情况。
(2)异常的继承体系结构：
Throwable
|–Error 严重的问题，一般我们解决不了。
|–Exception
|–RuntimeException 运行时期异常，这种问题一般要修正代码。
|–非RuntimeException 编译时期异常，必须进行处理，否则代码不能够通过。

    举例：
        石家琦骑自行车去山区旅游。
        问题1：山路塌陷
        问题2：车没有轮胎
        问题3：好路不走，偏偏走石子路
(3)JVM针对异常的默认处理方案：
    默认情况下，会把异常的类名，原因，及错误出现的位置输出在控制台。
    并从这个地方终止程序运行。
(4)我们自己如何针对程序进行处理：
    A:try...catch...finally
        基本格式：
            try {
                可能有问题的代码。
            }catch(异常类名 变量名){
                异常的处理。
            }finally {
                释放资源。(IO，数据库操作比较常见)
            }
        变形格式：
            try...catch...
            try...catch...catch...
            try...catch...finally...
            try...catch...catch...finally...
            try...finally...

        针对一个try多个catch的情况：

            父异常必须放最后。
            try{

            }catch(){

            }catch(){

            }

            JDK7的新特性：这个要求都是平级关系。

            try{

            }catch(异常1 | 异常2 ... 变量){}
    B:throws
        后面跟的是异常类名。
        位置：在方法的()后面。

    注意：
        能try...catch就不要throws。
        但是，目前讲课为了方便，我都throws。
(5)编译时期异常和运行时期异常的区别?
    A:编译时期异常 必须进行处理的。
    B:运行时期异常 可以处理，也可以不处理。
(6)throws和throw的区别?
    A:throws
        位置：在方法()后面，跟的是类名。
        如果后面根据的是RuntimeException及其子类，那么，该方法可以不用处理。
        如果后面根据的是Exception及其子类，那么，必须要编写代码进行处理，或者调用的时候抛出。
    B:throw
        位置：在方法中，跟的对象名称。
        如果方法中，有throw抛出RuntimeException及其子类，那么，声明上可以没有throws。
        如果方法中，有throw抛出Exception及其子类，那么，声明上必须有throws。
(7)自定义异常
    只需要继承自Exception或者RuntimeException。
    提供构造方法即可。

3：File(理解)
(1)IO流操作最主要的作用就是上传文件和下载文件。
而File类是java提供给我们用来表示文件的类。
(2)File的构造方法：
A:File file = new File(“d:\a.txt”);
B:File file = new File(“d:\”,”a.txt”);
C:File file = new File(“d:\”);
File file2 = new File(file,”a.txt”);
(3)File类的常见功能：(自己补齐)
A:创建功能
创建文件
public boolean createNewFile():如果文件存在，就不创建。否则，创建。
创建文件夹
public boolean mkdir():如果文件夹存在，就不创建。否则，创建。
public boolean mkdirs():如果多级文件夹存在，就不创建。否则，创建。
B:删除功能
public boolean delete() 删除文件或者文件夹。
C:重命名功能
public boolean renameTo(File dest):
如果路径相同，就是改名。
如果路径不同，就是剪切。
D:判断功能
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
public boolean isDirectory():是否是文件夹
public boolean isFile():是否是文件
public boolean exists():是否存在
E:获取功能
public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
public long length():获取文件字节数
public long lastModified():获取最后一次修改时间的毫秒值
F:高级获取功能
public String[] list():获取指定目录下的所有文件或者文件夹的名称(String)数组。
public File[] listFiles():获取指定目录下的所有文件或者文件夹的文件(File)数组。
G:带过滤器的高级获取功能
public String[] list(FilenameFilter filter):
(4)案例：
A:获取指定目录下指定后缀名的文件的名称。
a:基本做法。先获取所有的，然后遍历的时候，判断。
b:用过滤器的做法。先判断，获取，最后遍历。
B:批量修改文件名称。

---

day13

1：递归(理解)
(1)方法定义中调用方法本身的现象。
举例：
老和尚给小和尚讲故事。
我们学编程。
(2)递归的注意事项：
A:递归一定要有出口，否则就是死递归。
B:递归的次数不能太多，否则内存溢出。
C:构造方法不能递归使用。
(3)递归解决问题的基本思想：
A:分解和合并。
B:找哪些东西
出口
规律
(4)递归的题目：(至少看一遍)
A:递归求阶乘
B:兔子问题
C:递归输出指定目录下指定后缀名的文件绝对路径
D:递归删除带内容的目录

2：IO流(掌握)
(1)IO流的作用：上传文件和下载文件。
上传文件：
数据源：本地
目的地：服务器
下载文件：
数据源：服务器
目的地：本地
(2)IO流的分类：
A:流向
输入流 读取数据
输出流 写出数据
B:数据类型
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流

    一般来说，如果没有说明按照哪种类型分，指的是按照数据类型分。
(3)什么时候使用字符流,什么时候使用字节流。
    如果一个要操作的文件，通过记事本打开并能够读懂其内容，就可以考虑使用字符流。
    否则，就使用字节流。

    什么都不知道，就用字节流。
(4)IO的基类及具体类
    IO
        |--字节流
            字节输入流
                InputStream
                    FileInputStream
            字节输出流
                OutputStream
                    FileOutputStream
        |--字符流
            字符输入流
                Reader
                    FileReader
            字符输出流
                Writer
                    FileWriter
(5)FileWriter写数据的步骤及代码体现：
    步骤：
        A:创建字符输出流对象。
        B:调用write方法。
        C:释放资源。

    代码体现：
        FileWriter fw = new FileWriter("fw.txt");

        fw.write("hello,io");

        fw.close();

    几个要注意的小问题：
        A:创建字符输出流对象做了哪些事情?
        B:为什么要刷新缓冲区?
        C:为什么要释放流资源?
        D:刷新和释放有什么区别?
        E:如何实现数据的换行?
        F:如何实现数据的追加写入?
(6)FileReader读数据的步骤及代码体现：
    步骤：
        A:创建字符输入流对象。
        B:调用read方法,并把数据显示在控制台。
        C:释放资源。

    代码体现：
        FileReader fr = new FileReader("fr.txt");

        //方式1：一次读取一个字符
        int ch = 0;
        while((ch=fr.read())!=-1) {
            System.out.print((char)ch);
        }

        //方式2：一次读取一个字符数组
        char[] chs = new char[1024];
        int len = 0;
        while((len=fr.read(chs))!=-1) {
            System.out.print(String.valueOf(chs,0,len));
        }

        fr.close();
(7)复制文本文件：
    两种方式操作。代码自己补齐。

    数据源：c:\\a.txt
    目的地：d:\\b.txt
(8)加入异常后的代码(看懂即可)
    A:FileWriter写数据
    B:字符流复制文本文件

---

day14

1：字节流(掌握)
(1)继承体系
InputStream
FileInputStream
OutputStream
FileOutputStream
(2)案例：
A:字节流复制文本文件。
B:字节流复制图片。
C:字节流复制MP4并测试效率。

2：高效流(掌握)
(1)字符高效流
BufferedReader
BufferedWriter

    案例：
        高效流复制文本文件。
(2)字节高效流
    BufferedInputStream
    BufferedOutputStream

    案例：
        高效流复制图片。
(3)字符高效流的特殊功能
    BufferedReader
        String readLine()
    BufferedWriter
        void newLine()

    案例：
        高效流特殊功能复制文本文件。
(4)IO流的使用
    文本文件的复制：9种。
        字节流：4种
        字符流：5种

    二进制流数据的复制：4种。
        音视频文件。

3：转换流(理解)
(1)键盘录入写到文本文件。
用Scanner实现。
(2)用System.in录入数据，写到文本文件。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    理解：从字节到字符
    使用：从字节到字符
(3)把文本文件的数据，用System.out写到控制台
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    理解：从字符到字节
    使用：从字节到字符
(4)案例：
    数据源     目的地
    a.txt       b.txt
    a.txt       System.out
    System.in   b.txt
    System.in   System.out
(5)案例：
    System.in -- a.txt -- b.txt -- System.out
(6)案例：
    A:ArrayList -- a.txt
    B:a.txt -- ArrayList

4：登录注册案例(理解)
注册：写数据
登录：读数据

接口：定义要做什么，但是不提供实现。

---

day15

1：字符编码(理解)
(1)编码表：由字符及其对应的数值组成的一张表。
(2)常见的编码表：
ASCII
ISO-8859-1
gb2312
gbk
gb18030
big5
utf-8
(3)编码问题：
A:IO流中的编码问题
B:String类中的编码问题

    记住：统一编码最好。

2：Properties(理解)
(1)是键值对形式的属性列表。是Map体系的一个集合类。
可以和IO流进行结合使用。
(2)案例：
A:作为Map集合的使用。
B:作为集合的特有功能使用
a:setProperty(String key,String value)
b:getProperty(String key)
stringPropertyNames()
C:和IO流结合使用的例子
a:load() 把文件中的数据加载到集合中
b:store() 把集合中的数据存储到文件中
D:给你一个文件，user.txt。请判断里面是否有键为”lisi”的，如果有，则修改其值为100。

3：打印流(掌握)
(1)打印流仅仅是用来写数据的，没有读取数据的。
(2)打印字节流 PrintStream
System:
public static final PrintStream out

        System.out.println();

   打印字符流 PrintWriter
(3)特点：
    A:可以把任意类型的数据写到文本文件。
    B:如果启动了自动刷新，在调用println()的方法的时候，可以自动刷新，并换行。
    C:可以直接对文件进行操作。
        问题：哪些流可以直接对象文件进行操作。
        看API，流的构造方法，如果可以同时有File和String类型的参数，就可以。
(4)案例：
    通过打印流改进复制文本文件的代码

    BufferedReader br = new BufferedReader(new FileReader("a.txt"));
    PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);

    String line = null;
    while((line=br.readLine()) != null) {
        pw.println(line);
    }

    pw.close();
    br.close();

4：序列化和反序列化流(理解)
(1)序列化：把对象按照流一样的方式存储到文件中或者在网络中传输。
简记：把对象按照流一样操作。
反序列化：把文件中或者网络中的流数据还原成对象。
简记：流数据还原对象。
(2)对象怎么才能实现序列化呢?
让对象所属的类实现序列化接口。
(3)记住：
看到一个类实现了序列化接口，就要知道，该类的对象可以被序列化流进行操作。
将来还可以通过反序列化流还原。
如果想在序列化后，对java文件做一些简单的改动，不影响以前写过的数据，
那么，就应该在java文件中给出固定的序列化id值。
而且，这样做了以后，还可以解决黄色警告线问题。

5：其他的几个了解的流对象(理解)
(1)DataOutputStream/DataInputStream
可以把基本数据类型的数据写到文件，也可以还原为基本的数据类型的数据。
只不过，要注意还原时候的顺序和写的顺序要一致。
(2)ByteArrayOutputStream,ByteArrayInputStream
(3)CharArrayWriter,CharArrayReader

---

day16

1：多线程(理解)
(1)多线程：应用程序有多条执行路径。
进程：正在运行的应用程序，系统会为其分配空间。
每个进程具备独立的空间。
线程：应用程序的执行单元，执行路径。
线程共享同一个进程的资源。
单线程：应用程序只有一条执行路径。
多线程：应用程序有多条执行路径。

    举例：
        迅雷下载。
(2)多线程的两种实现方案：(参照 多线程两种实现方案的比较和几个小问题.bmp)
    A:继承Thread类
    B:实现Runnable接口
(3)面试题
    A:start()和run()的区别。
    B:线程随机性原理。
    C:线程的生命周期图。

    D:同步的方式有几种。
    E:sleep()和wait()的区别?
(4)卖票案例：
    A:通过继承Thread类实现
    B:通过实现Runnable接口实现
(5)卖票案例：
    加入模拟等待版本。

    这个时候就出问题了。
    A:同一张票被卖了多次。
    B:出现了负数票。
(6)线程安全问题：
    如何分析线程安全问题呢?
    A:是否是多线程环境
    B:是否有共享数据
    C:对共享数据是否有多条语句操作
(7)解决办法：同步
    同步代码块：
        synchronized(锁对象) {
            需要被同步的代码。
        }
    A:锁对象可以是哪些呢?
        Object的对象。这个锁对象可以是任意对象。
        但是一定要注意，多个线程必须使用的是同一个锁对象。
    B:需要被同步的代码是哪些呢?
        共享数据
        共享数据是否有多条语句操作

---

day17

多线程：(理解上非常重要,EE开发用的较少,Android稍微多一点点)
A:多线程概念
进程：正在运行的应用程序。
线程：应用程序的执行路径，执行单元。

    多线程：一个应用程序有多条执行路径。
B:实现方案
    A:继承Thread类
    B:实现Runnable接口
C:线程的随机性原理
    CPU在多个程序间做着高效的切换来执行程序的。
D:线程的生命周期
    新建 -- 就绪 -- 运行 -- 死亡

    运行 -- 阻塞 -- 就绪
E:线程安全问题的产生及解决
    a:多线程环境
    b:是否有共享数据
    c:共享数据是否被多条语句操作

    解决方案：
        a:同步代码块
        b:同步方法
        c:JDK5以后的Lock锁。
F:同步的锁对象
    代码块：任意对象
    方法：this
    静态方法：类名.class
G:线程间的通信
    不同种类的线程针对同一个资源的操作。

面试题：
A:多线程有几种实现方案?分别怎么实现的?
B:如何启动一个线程?
C:start()和run()方法的区别?
D:sleep()和wait()方法的区别?
sleep():必须指定时间。不释放锁对象。
wait():可以指定时间，也可以不指定时间。释放锁对象。
E:线程的生命周期。
F:同步有几种方案?分别怎么实现?
G:生产者和消费者多线程案例。
单生产单消费
多生产多消费
H:请自己写4个线程，操作一个数据，
其中两个线程对这个数据做加法操作，另外两个线程对这个数据做减法操作。

    张孝祥java就业面试宝典.chm 中的第一个Java基础笔试题第58,59...

I:请写这样的一个案例：
    我们班要组织一个活动，这个活动要分组。分2组。
    由两个老师分别选人：
        你一个
        我一个
        你一个
        我一个
        ...
怎么着才能做多线程开发呢?
    Java并发编程。

多线程程序的实际使用：
new Thread() {
public void run() {
for(int x=0; x<100; x++) {
System.out.println(x);
}
}
}.start();

new Thread(new Runnable(){
    public void run() {
        for(int x=0; x<100; x++) {
            System.out.println(x);
        }
    }
}){}.start();

new Thread(new Runnable(){
    public void run() {
        System.out.println("hello");
    }
}){
    public void run() {
        System.out.println("world");
    }
}.start();

---

day18

1:GUI(用户图形界面) 了解
(1)GUI 图形界面
CLI 命令行方式
(2)java针对图形界面提供的包
java.awt 和系统关联较强。重量级。
javax.swing 可以跨平台。轻量级
(3)体系结构：
组件：就是具备属性和行为的对象。

    组件：
        基本组件 就是能够直接看到效果的一些小对象，比如按钮，文本框。
        容器组件 就是能够存储基本组件和容器组件的组件。
(4)事件监听机制：
    A:事件源
    B:事件
    C:事件处理
    D:事件监听

    举例：人受伤事件。
(5)案例：
    A:第一个简单的窗体案例
    B:窗体可以关闭了案例
    C:窗体添加按钮案例
    D:窗体把文本框的值转换到文本域中的案例
    E:模拟四则运算
    F:猜数字小游戏
    G:随机点名器
    H:登录注册案例

---

day19

1：网络编程(理解)
(1)用编程语言来实现计算机的资源共享和信息传递。
计算机网络：多台独立的计算机用网络通信设备连接起来的网络。
实现资源共享和数据传递。
(2)网络通信的三要素
A:IP地址
计算机在网络中的唯一标识。
现在使用的是：”点分十进制”
B:端口
应用程序的的标记。
C:协议
通信的规则。

        UDP:不建立连接，数据打包传输，数据有限制，数据不可靠，速度快。
        TCP:建立连接，数据无限制，数据可靠，速度慢。
(3)UDP发送和接收数据
    先开启谁都无所谓。
    A:发送端
        步骤和代码体现。

        步骤：
            创建发送端的Socket服务对象。
            创建数据并把数据打包。
            发送数据。
            释放资源。

        代码体现：
            DatagramSocket ds = new DatagramSocket();

            byte[] bys = "udp,我来了".getBytes();
            DatagramPacket dp = new DatagramPacket
                (bys,bys.length,InetAddress.getByName("192.168.32.80"),12345);

            ds.send(dp);

            ds.close();

    B:接收端
        步骤和代码体现。

        步骤：
            创建接收端的Socket服务对象。
            创建数据包。
            接收数据。
            解析数据。
            释放资源。

        代码体现：
            DatagramSocket ds = new DatagramSocket(12345);

            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys,bys.length);

            ds.receive(dp);

            String ip = dp.getAddress().getHostAddress();
            String data = new String(dp.getData(),0,dp.getLength());
            System.out.println(ip+"---"+data);

            ds.close();

    C:案例：
        A:键盘录入数据发送。
        B:键盘录入数据发送，发送的ip地址改进为广播地址。
        C:多线程改进聊天程序。
        D:演示了一个GUI版本的聊天程序。
(4)TCP发送和接收数据
    必须先开启服务器。
    A:客户端
        步骤和代码体现。

        步骤：
            创建客户端Socket对象。
            获取输出流。
            写数据。
            释放资源。

        代码体现：
            Socket s = new Socket("192.168.32.80",12345);

            OutputStream os = s.getOutputStream();
            os.write("tcp,我来了".getBytes());

            s.close();
    B:服务器端
        步骤和代码体现。

        步骤：
            创建服务器Socket对象。
            监听客户端连接。
            获取输入流。
            读取数据。
            释放资源。

        代码体现：
            ServerSocket ss = new ServerSokcet(12345);

            Socket s = ss.accept();

            InputStream is = s.getInputStream();
            byte[] bys = new byte[1024];
            int len = is.read(bys);
            String data = new String(bys,0,len);
            System.out.println(data);

            s.close();
            ss.close();

    C:案例：
        A:服务器给出反馈。
        B:客户端是键盘录入，服务器输出到控制台。
        C:客户端是键盘录入，服务器是写到文件。
        D:客户端是读取文件，服务器是写到文件。反馈信息
        E:客户端是读取图片，服务器是写到图片。反馈信息

---