java笔记整理

之前学习马士兵老师的java的笔记做了好几份，主要是java se 和部分j2ee.和这里把他们整合到一起，以便于日后查看

第一次Java笔记

Unit1,java基础部分

1,创建一个对象

在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

 

声明：声明一个对象，包括对象名称和对象类型。

实例化：使用关键字new来创建一个对象。

初始化：使用new创建对象时，会调用构造方法初始化对象。

在java中无论什么变量都要先声明，再赋值，再使用

 

2, 源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

>一个源文件中只能有一个public类

>一个源文件可以有多个非public类

>源文件的名称应该和public类的类名保持一致

>如果一个类定义在某个包中，那么package语句应该在源文件的首行。

>如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。

3, 程序都是从main方法开始执行。为了能运行程序，必须包含main方法并且创建一个实例对象

 

4, Java的两大数据类型:

>内置数据类型（基本数据类型），只占用一块空间

    Java语言提供了八种基本类型。六种数字类型（四个整数型(byte(8位、有符号的，以二进制补码表示的整数,范围为-128~127) , short(12位有符号) , int(32位有符号) , long(64位有符号))，两个浮点型(float(32位),double(64位))），一种字符类型(char)，还有一种布尔型(boolean 默认值是false)

如果记不住的话也没有关系,在程序中打印一下就知道了

// byte  

        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  

        System.out.println("包装类：java.lang.Byte");  

        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  

        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  

        System.out.println(); 

打印结果如下,其他的几种变量类似

基本类型：byte 二进制位数：8

包装类：java.lang.Byte

最小值：Byte.MIN_VALUE=-128

最大值：Byte.MAX_VALUE=127

 

>引用数据类型(对象,数组,默认值都为null)类的每个成员变量再不同的对象中有不同的值，但是方法公用，执行的时候才占用内存，引用数据类型占用两块空间，一块存放名字，名字的值指向另一块，另一块存放内容（new出来的空间，存放在堆中）

变量由类的构造函数创建

>java中常量通常是大写,用final修饰

 

5, Java语言支持一些特殊的转义字符序列

 

6,java中的修饰符

访问修饰符:

public : 所有类可用

private : 同一类内可见,

protect : 同一包内的类和不同包内其子类可用

默认:同一包内可见

非访问修饰符:

static修饰符，用来创建类方法和类变量。无论一个类实例化多少对象，它的静态变量只有一份拷贝

Final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。Final变量能被显式地初始化并且只能初始化一次

Abstract修饰符，用来创建抽象类和抽象方法。抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类

 

Synchronized和volatile修饰符，主要用于线程的编程,Synchronized关键字声明的方法同一时间只能被一个线程访问Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值

7,java的一些位运算符

A = 0011 1100

B = 0000 1101

逻辑运算符: A = true B = false

8, instance运算符用来检查该对象是否是一个特定类型（类类型或接口类型）,例如

String name = 'James';

boolean result = name instanceOf String; //由于name是Strine类型，所以返回真

9 , java数组

int [ ] a = new int [5];

int [] a = { 1,2,3,4,5};

针对数组有一种特别的循环foreach例如

int [] a = {1,2,3,4,5};

for(int element :a)

{

System.out.println(element);

}

数组作为函数参数

void printArray(int[] array)

数组作为函数的返回值

public static int[] reverse(int[] list)//定义时,注明返回值是一个数组

int[] result = new int[list.length];//list与result都是数组

return result;//返回数组名

 

Arrays类

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

给数组赋值：通过fill方法。

对数组排序：通过sort方法,按升序。

比较数组：通过equals方法比较数组中元素值是否相等。

查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

 

unit 2,java的一些类库

1,number类:

  >装箱,拆箱:

              >>我们在开发过程中有的时候需要把int等内置类型当作类使用,java为每一个内置类型数据提供了对应的包装类.这种由编译器特别支持的包称为装箱, byte、int、long、double都属于number类

>Number类中的方法

2,Character类的方法

3 , String类的方法较多,写代码的时候直接查看手册完成

4 , JavaStringBuffer和StringBuilder类

 

当对字符串进行修改的时候，需要使用StringBuffer和StringBuilder类。

和String类不同的是，StringBuffer和StringBuilder类的对象能够被多次的修改，并且不产生新的未使用对象,多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下，则必须使用StringBuffer类。

Unit 3 java一些杂项(日期,正则表达式)

1,java.util包提供了Date类来封装当前的日期和时间

Unit 4 java文件操作

Unit 5 java异常

Unit 6 java面向对象

1 Java中的关系

 

       关联关系：比较弱的一种关系，比如研究生类是教授类的教方法的参数，那么可以称他们是关联关系

       继承关系：若A是B，那么A继承自A

       聚合关系：A是B的一部分，那么B是A的聚集，若A不可共享，那么B是A的组合，聚集和组合合成聚合。

       实现关系：实现接口

       多态关系

2，类是静态的，存放在代码区

       对象是动态的，存放在堆中

3，java内存：

第二次

Unit 1 面向对象思想

1， 命名规则

类名的首字母大写

变量名和方法名的首字母小写

运用驼峰标识（如class BigDog 每个单词的首字母都要大写）

 

2， main方法所在类的类名必须和文件名相同

 

3， java中存储空间的区别

a)     heap是堆，存储new出来的变量

b)     stack是栈，存储局部变量

c)     data segment 静态变量，字符串常量

d)     code segment 存放代码

 

4， static 声明的变量是静态成员变量，他是该类的公共变量，在第一次使用的时候被初始化对该类所有的对象来说，该变量只有一份

static声明的方法为静态方法，如果没有对象也可以调用这个静态的方法，方法是类名加上方法名（变量名），如System.out中的out就是一个静态的方法

在static方法里面不可以访问非静态成员，比如main方法中不能直接访问类中的非静态成员，必须先new一个对象出来（因此类一般都设置成static类型的，要不然在访问的时候会出错？？？？？？？？）

 

5， 包（package）的出现是为了解决大型程序中的命名冲突的问题

a)     Java中包的命名规则：

                i.         公司的域名倒过来，后面还可加上项目的名称等。比如hfut.ocm可以写在程序的第一行（程序的第一条语句） package com.hfut; //package是关键字，这是一个两层的包裹，包括com和hfut，包裹可以层层外加，

               ii.         为了使别人可以访问这个包内的文件，在使用包的文件的时候，文件的位置要正确，并且在调用的文件加上import语句

              iii.         Class 文件的 最上层的包的父目录必须位于classpath下

              iv.         不同的项目最好使用不同的classpath以免产生冲突，特别是新旧版本，特别容易出问题，而且还很难找到问题所在

               v.         执行一个类需要写全包名

b)     在jdk/jre/lib/rt.jar （runtime）使用 winrar打开可以发现java运行的时候需要的class文件，主要有之下几个著名的包

                i.         Java.lang  java语言的核心包，包括String，Math，Integer，System， 和Thread，除了此包之外，其他的包使用的时候都需要引入

               ii.         Java.awt  抽象窗口工具集（abstract window toolkits）用来构建GUI

              iii.         Java.applet 包含applet运行时候的所需的一些类

              iv.         Java.net 与网络相关的类

               v.         Java.io 与输入输出相关的类

              vi.         Java.util 包含一些试实用的工具类，如定义系统特性，使用与日期相关的函数

6， 权限控制

7， 继承

a)     Extends关键字，可以表述为什么是什么

b)     重写（overWrite）：子类重写基类的方法

                i.         名称，参数，返回类型相同

               ii.         重写方法（子类）不能比被重写方法（基类）更严格的访问权限(与多态有关)

c)     重载(overLoad)：同一个类里面不同的方法具有相同的方法名称，但是参数数量不同

d)     This引用本类中的对象，super引用基类中的对象

e)     子类的构造过程中应该先调用父类的构造方法（使用super调用父类的构造方法，使用this调用自己的构造方法，并且如果调用super的构造方法，必须写在子类构造方法的第一行，如果没有使用super，系统自动调用父类中没有参数的构造方法，若无此构造方法，那么就会编译出错）

f)      所有的类都是Object的子类，其他类默认从Object继承，如public class Person{}相当于public class Person extends Object{}，在其他类型和String类型同时输出的时候自动调用Object的toString方法。如System.out.println(“d:”+d)相当于System.out.println(“d:”+d.toString())。，一般需要在子类中重写toString方法，因为这个方法返回的是目标的哈希编码，哈希编码用来记录对象的位置（独一无二表示一个对象，并可以找到对象的位置），可以快速地找到该对象，避免循环查找，这些哈希编码组成一个哈希表

g)     在Java中“==”表示判断是否完全相同，a.equals（Object x）表示判断a与x是否值相等（包括地址，也就是说两个对象是不是同一个对象），同时equals也可以理解为两个对象的名字的值“==”,(即指向同一个地址，地址相同)，如果觉得不好用你当然可以重写，在String中就重写了equas()方法

8， 多态：为了解决扩展问题

a)     多态又叫动态绑定或者迟绑定，指的是在执行期间而不是编译期间

b)     多态的三个必要条件

                i.         要有继承

               ii.         要有重写

              iii.         父类引用指向子类对象

9， 抽象类：关键字abstract，可以修饰类或者方法

a)     含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写（或者被子类再次成名为抽象的，留待子类的子类去实现）

b)     抽象类不能被实例化

c)     抽象方法只需要声明，不需要实现。

d)     如果一个方法暂时不知道是干什么的或者没有实现的必要，那么就可以把它声明为抽象的，留待子类去实现，格式如下  public abstract void enjoy （）；特别注意，没有大括号，大括号即使为空，也是一种实现，相当与C++中的虚函数与纯虚函数

10，        final修饰符

a)     final变量的值不能被改变（只读）

b)     final的方法不能被重写

c)     final 的类不能被继承

 

11，        接口（关键字interface）：用以解决java的多继承问题（java实际上没有多继承）

a)     多个无关的类可以实现一个接口（实现的关键字：implement），实际上是重写方法

b)     一个类可以实现多个无关的接口（实际上类似 多继承），接口之间使用逗号隔开，还可以有自己的属性和方法，但是接口的方法必须全部实现

c)     与继承关系类似，接口与实现类之间存在多态性(比如Singer是一个接口People实现了这个接口可以Singer s1 = new People();来使得s1获得People类中关于Singer的方法，前面说过Singer是静态的抽象的，但是他并没有去new出来东西，因此是合法的)

d)     接口可以继承其他的接口使用extends关键字，并添加其他的属性和抽象方法

e)     接口是一种特殊的抽象类，这个抽象类中的所有的方法都是抽象的（写不写都是抽象的），只包含常量（或者变量被定义为static final类型的不可以改变,在接口中其实方法和变量都是默认是这种类型的，当然写清楚更加直观）和方法的定义，并没有实现

f)      为什么java中没有多继承，那是为了修正C++中多继承出现的问题，比如多个父类中出现了相同的变量，而Java中使用static final修饰变量，就使得变量属于每一个类，就避免了这种情况的发生

g)     所有指向子类的基类都可以通过强制转换获得访问子类全部方法的功能

h)     存在一个问题：当两个接口的某个方法名称相同，但是返回值不同，这两个接口被同时继承的时候就会出现了问题，目前马老师推荐最好避免这种情况的发生，日后再寻找解决办法。

12，        面向对象的一个总结，本章结束。

 

Unit 2 异常处理

1， 异常指的是运行期出现的错误，观察错误的名字和行号最重要，并且要敢于调试，设计良好的程序应该在异常发生的时候提供处理这些问题的方法。

2， 常见的异常有越界，除0溢出，文件不存在等。Java可以自己检查下标是否越界，但是C++不能

3， 异常发生的时候会生成一个异常类对象，该异常类对象封装了异常事件的信息并提交给java运行时系统，这个过程称为抛出（throw），可能出错的地方用try修饰，处理异常地方捕获（catch）异常并进行处理，一个try可以跟随多个catch

4， 自己写的程序也可能出现异常，可以按以下处理

5， 异常的分类

a)     Error是我们无法解决的错误

b)     Exception是我们可以解决的错误

                i.         Runtime Exception可以解决（try catch）也可以不解决（只throw）

               ii.         Exception其他的异常必须解决

 

6， Finally { }里面的无论抛不抛出异常都要执行

7， 异常发生时可以使用下面两个方法来获取异常的信息

8，

若是异常无法处理，抛出给上级处理，格式

XXX 方法名（） throws 异常类型{

        方法体

}

上级在调用这个异常的使用try{方法名}catch（）{异常处理}来处理

若是不想处理或者无法处理，上级在调用方法的时候继续抛出

       方法名（）throws 异常类型；

8， 抓到一个异常之后一定要做一个处理至少要打印一下，否则这个异常就被吞掉了（异常存在，但是无法发现），这是非常危险的编程习惯，在main方法后抛出Exception是非常不好的编程习惯（虽然这样用的真的很爽），最好还是try catch

9， Java中有时候需要重写方法，但是这个方法抛出了异常，那么重写的方法必须没有抛出异常或者和原方法抛出的异常相同，太大或者太小都不行

10，        总结：

a)     掌握五个关键字

                i.         Throws

               ii.         Throw

              iii.         Try

              iv.         Catch

               v.         Finally

b)     throws语句　  
  throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或RuntimeException， 或它们的子类，这个规则不起作用， 因为这在程序的正常部分中是不期待出现的。 如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。  
   
  throw语句　  
  throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

Unit 3 数组

1， C++的数组是分配在栈上，java分配在堆上，并且与C++不同的是定义java数组的时候

a)     Int a [];

b)     Int [] a ;  //这两个声明是存放在栈上的

都是可以的，但是int a[5]；是不允许的

声明之后可以在堆上new出来，如a = new int[5];

2， 数组的初始化：

a)     静态初始化：在定义数组的同时就为数组分配空间并赋值

                i.         int a = {1,2,3};

               ii.         Date days = {new Date{1,2,3}, newDate{1,2,3}, new Date{1,2,3};}

b)     二维数组相当于数组的数组

c)     数组的拷贝a.array

d)     关于数组的几种排序算法很重要

unit 4 常用类

一般可以通过直接查找API文档得到，在API文档中出现Deprecated表示是过时的方法，已经不用了。

String 类 不可变的字符序列

1，  

a)     String a = “Hello”;

          String b = “Hello”;

System.out.println(a == b);//true

为什么会是true呢？，因为a与b（都存在于栈中）都没有new出来对象，“Hello”存放于堆中，但是a和b的值相同，java对其做了一个优化，只保留一份“Hello”，因此ab都指向这个Hello，因此为true

b)     String 中的equals经过了重写，只要值相同就返回true

char c [ ] = {“s”,”u”,”n”,” ”,”j” ,”a”,”v”,”a”};

String a = new String(c);

String b = new String(c);

String d = new String(c,4,4); //从c的第四个字节开始复制四个字符

 

System.out.println(a == b); //false

System.out.println(a.equals(b));//true

System.out.println(d);//java

c)     String中的常用方法

     

StringBuffer类（Buffer ： 缓冲区）可变的字符序列（即StringBuffer可以对字符串进行改变而String不可以）

     

基础数据类型的包装类

把基础类型包装成对象,并提供了一系列的操作

int à Integer

 

Math类

 

File类

 

路径分割符：separator(Linux 下是正斜杠，windows下是反斜杠，而使用这个常量就会做到自动区分，从而可以跨平台，此外写正斜杠永远是正确的)

 

unit 5 容器（1136）

1，一个图

a)    Collection是一个一个的装数据

                         i.         set(集合)，无序，不可重复

1.     s1.retainAll(s2)，求s1,s2的交集

                        ii.         List（列表），有序，可重复（equals）

1.     List有点像数组，但是可以随意增加长度，但是数组不可以

2.     ArrayList 底层是数组实现的List

3.     LinkList   底层是链表实现的List

注意只能添加对象而不能是int类型或者其他类型

b)   Map是一对一对的装数据（键（key）-值（value）映射对），两个Map的元素是否equals，要比较他们的哈希值（hash code）是否相同

c)    

注意是Collections而不是Collection

d)   

2，一个类

2， 三个知识点

3， 六个接口

a)     最上面的图中有四个接口

b)     Iterator（迭代器）接口

c)     JDK1.5新增的增强for循环

                i.         不能随意的删增元素，无法单独访问下标元素

d)     Comparable接口

e)     对于之上的数据结构的选择

f)      Map接口

TreeMap应该是使用红黑树实现的，那么什么是红黑树呢？

              打包解包的概念（基础类型与对象之间的转换）（一般是系统自动完成的，不需要我们瞎操心）

       e）泛型

List<String> c = newList<String>,那么现在c只能存储String类型的数据，节省了判断数据或者数据转换的时间，在API文档中，类名之后有<E>的都可以这样操作

 

 

总结：

1， 一个图

2， 一个类：

a)     Collection

3， 三个知识点

a)     For

b)     Generic（泛型）

c)     Auto-Bxoing/unBoxing (打包/解包)

4， 六个接口

 

第三次

unit1 IO初步

1， 因为输入输出的概念是相对的，站在文件的角度和文件的角度来说是相反的，以后说的输入输出流都是站在程序的角度来说的

2， 几个重要的概念

处理流是在节点流的外层覆盖的流，就相当于TCP协议外层封装的报文一样

3， 以Stream结尾的都是字节流

4，

4， inputStreamReader 转换流，本来是一个一个字节的读取，现在换为一个字符串一个字符串的读取

5， 网络传输经常用utf-8，因为省空间

总结知识点：下面的名词熟记，知道其作用，其用法格式固定，多用几次就会了

unit 2 多线程

1， 线程的创建

a)     

2， 在实现接口后如果直接调用run（）方法，那么run方法只执行一次

a)     需要创建一个Thread对象，参数是刚刚实现了接口的类的对象，然后调用Thread对象的start（）方法，这样才是线程

3， 一般使用接口而不使用继承，因为继承比较死，继承了这一个就不能从其他的类中集成了，但是接口可以（虽然接口的代码量多那么一丢丢）

4，线程的状态转换

a)     

5，线程的控制方法

a)     

b)     什么叫线程还活着：就绪，运行，阻塞都算活着

c)     睡眠状态下被打断就会抛出异常

d)     在终止进程的时候stop已经停止使用了，因为太粗暴，不给处理未关闭程序的机会，interrupt用的较少，也是同样的原因，但是interrupt可以抛出异常进行处理。比较文雅的方法是设置一个Boolean类型的名为的flag变量，当flag==true的时候进程正常的执行，当设置其值为false的时候，比如在实现runable的类里面加上一个shutdown方法，这个方法的作用是把flag设置为false调用这个方法的时候，进程会自己安全中止的（即不会执行到代码的一般突然就终止了），其实stop的用法有点类似Windows中的任务管理器的终止任务，这样的操作同样是有坏处的，只有在软件实在不响应的时候才能这样的操作，平时尽量避免这样的操作。此外flag的用法不止于此，比如flag可以为int类型的，不同的值代表不同的操作

e)     三个比较重要的方法

6，线程的优先级

a)     

b)     缺省的意思就是默认的意思，这里也就是默认的优先级

c)     可以在NORM_PRIORITY 加或者减的方法去调整线程的优先级

7， 线程同步

a)     如果一个资源同时被两个线程访问，就可能发生冲突，因此我们需要同步，方法是若一个资源一个时刻只能被一个线程访问，那么就在这个资源（可能是一个方法）的首行（或者在定义这个方法的时候写在private等的后面）加上关键字synchronized(this),意思是这个资源被锁定了，若这个资源是一个方法，那么除了这个方法之外的其他方法其他线程仍然可以访问，必须对所有可能对结果产生影响的方法加锁（这里还有一点疑问），加锁可能会影响效率，不加锁可能会影响那个结果，因此要慎重的考虑

b)     死锁：线程1与线程2都是需要资源1和资源2才能运行，但是他们各锁住了一个，这样就尴尬了，就形成了死锁

c)     

d)     一般被读功能的资源可以不加锁，被写的资源要加上锁

8， wait和sleep的区别

a)     wait是Object类的方法，sleep是thread类的方法

                i.         wait的时候锁是释放的，别人可以用，但是sleep的时候别人不可以用我锁住的东西

               ii.         wait和notify是相反的，一个是沉睡，一个是唤醒

              iii.         yield让步（让出cpu资源）

9， 总结

a)     

b)     此外注意哲学家问题和生产者问题的代码实现

unit 3 网络

1， 网络编程不等于网站编程，网站编程之类如CSS等是基于网络编程的，只不过别人已经封装好了，网络编程也叫做TCP/IP编程或者叫socket编程，双向链路的一端称为socket（插座），在java中的关于网络相关的类的包都在java.net中

2， 关于网络的分层，我们主要关注TCP/IP协议中的TCP/UDP层（传输层）和IP层（网络层）

a)     关于TCP/IP层，若是要深入了解其协议，可以看一本书叫做《TCP/IP详解》，不过目前不需要了解的太详细，我们要做的只要记住IP层提供了IP地址即可

b)     关于子网掩码，前几位都是1，代表网络号，后几位都是0，表示这些片段可以用于划分子网，比如后四位为0，则有二的四次方个子网（16个），子网又可以分内网，如此循环，构成网络 

c)     TCP是可靠的连接，UDP是不可靠的连接，发送时不需要建立连接，但是速度快（比如说网络通话等）

3， socket

a)     socket通常用来实现Client-Server连接，java.net包中定义了两个类，Socket和ServerSocket分别用来实现双向连接的client端和Server端，这个主要是TCP的连接，因为UDP关于客户和服务端的意识很模糊（比如QQ通话），所谓SOCKET只是逻辑上的

b)     建立连接需要ip地址和端口号，端口号两个字节，用来区分程序，此外一个程序可以占用多个端口，我们自己编写程序一般使用1024之后的端口号，因为之前的系统可能使用，下面是一些比较固定的端口

                i.         80端口，打开网页

               ii.         21端口，FTP

              iii.         25端口，SMTP（发送邮件）

              iv.         110端口 ，收邮件（叫啥名来着？）

c)     端口又分为TCP端口和UDP端口，但是他们的端口号可能相同，每一个都是65536个

d)     

e)     Server和Client要同时开发，但是启动的时候要先启动Server端，本地ip是127.0.0.1

4， 总结

unit 4 GUI 编程

1， GUI念做“古意”，graphic user interface图形用户界面

a)     

2， awt是java比较旧的开发包，因为windows下和Linux下有些许的区别。新的开发包教swing

3，

4，

5，

6， 一般在使用frame的时候尽量定义自己的Frame类（继承frame），而不要直接使用frame类new对象，这样做会有更大的灵活性

a)     

7，

8， 若是在找一个类的方法的时候没有咋API文档中发现，可以去找一下他的父类

9，

10，        之上三种布局管理器用的比较多，其他的布局管理器有时间看看就好

11，        事件监听（很重要）

a)     

12，        

13，        内部类可以直接访问包装类的对象（默认拥有外部类的引用）

14，        

15，        repaint方法是先调用update方法，再调用paint方法，有带你类似双缓冲的原理

16，        匿名类，父类的参数是一个类的实现，这是封装比较好的一种方法

a)     如上图，addWiddowListener是父类，WindowsAdapter是内部类，他只在这个父类的内部起作用，别人不需要访问他，也不能访问他，因此他只在这里起作用就好，不要让别人修改他，匿名类其实完全可以用内部类来代替，在代码比较多或者代码修改频繁的情况下不要使用匿名类

b)     键盘监听类

17，        之上就是j2se基础的大概内容了，之上的内容完全可以适用命令行来运行，之后就要使用ecplise了，终于解放了，可以开始J2SE的高级部分了

 

Ecplise的简单使用

1， 学习使用一种新软件的时候不要看一本书每个菜单都弄明白是干啥的，一边用一边学，遇到不懂的查资料，这样比较好

反射机制

1，

2，

3，反射机制其实还是不太懂，但是实在不想看了，看看数据库开始写项目吧

 

正则表达式—字符串处理利器

1，

2， 在正则表达式中：之下的信息在pattern类中都有说明，不需要特别去记

a)     “.”表示一个字符 ，

b)     “*“

c)     ”+“

d)     \\d表示一个一位数字

e)     ？

 

 第四次：

unit 1—JDBC

1，首先了解一些关于java的常见知识点

a)     JDK是Java development toolkit,相当于是Java的库函数，是编译，运行java程序的工具包。
J2EE是Java 2 enterprise edition是Java的一种企业版用于企业级的应用服务开发
J2SE是Java 2 standard edition是Java的标准版,用于标准的应用开发

2，JDBC：java Database Connectivity,Java数据库连接

3，基本的sql语句

a)     

4，JDBC的编程的步骤非常的固定：

a)     

b)     

                i.          DML（data manipulation language）：
       它们是SELECT、UPDATE、INSERT、DELETE，就象它的名字一样，这4条命令是用来对数据库里的数据进行操作的语言

              ii.         
DDL（data definition language）：
       DDL比DML要多，主要的命令有CREATE、ALTER、DROP等，DDL主要是用在定义或改变表（TABLE）的结构，数据类型，表之间的链接和约束等初始化工作上，他们大多在建立表时使用

             iii.         DCL（Data Control Language）：
       是数据库控制功能。是用来设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句。在默认状态下，只有sysadmin,dbcreator,db_owner或db_securityadmin等人员才有权力执行DCL

c)     java中注意逗号和问好与中文的区别，很可能找半天找不到是怎么错了

unit2 html

1， html超文本标记语言

2， html分为head和body两部分

a)     head中常用的标签

                i.         <title>文字</title> 文字将显示在标题栏

               ii.         <meta>:用于设置一些头信息，显示文本本身的信息

              iii.         <style>…</style>用于定义CSS格式

              iv.         <Script language = “ ”>…</Script>用于定义脚本

               v.         <link>

              vi.         <base>

b)     body中常见的标签

                i.         设置颜色,用的较少，现在都是用CSS设置颜色，html只是用来放置标签显示内容

a)     link =“#FFFFFF” 链接颜色

b)     alink =“#FFFFFF” 设置颜色时链接被激活

c)     vlink  =“#FFFFFF” 设置颜色时表示链接被访问后

d)     bgcolor = “#FFFFFF” 背景色，背景也可以是一个图片

e)     test = “#FFFFFF” 文字颜色

               ii.         <a>链接</a>

              iii.         关于路径有本地路径，绝对路径，相对路径，目前用的比较多的是相对路径，所谓相对是指对当前网址的URL而言的

unit3 Javascript

1， javascipt语法：

a)     基础语法

b)     DOM，文件对象模型

c)     BOM，浏览器对象模型

2， javascript是一门弱类型的语言，所有的变量都由var定义

3， JavaScript的事件处理是非常重要的，指的是当网页上发生某些事件的时候会调用这些函数或者语句

a)     

b)     

servelet

1，

2，xml文件，里面是类似html文件的各种标签，

a)     server.xml文件做任何操作之前都需要进行备份操作，一般是修改端口

b)     web.xml一般不需要进行改动

3， 学习的方法，先看一下提纲，知道大致讲什么，然后就开始做东西，哪里不会再回去查，这是面向工作的学习方法，解决问题，做出东西是第一位的。但是应试教育还是要扣课本

4， 怎么阅读图书馆里面的书，比如小说，看一下前面，推测一下自己会怎样写，看一下结局，就ok了

5， 汉字内码扩展规范，称GBK

6， 网上的东西只要我们可以访问一定可以下载下来

7， 一些网页的状态码

a)     404找不着

b)     200正常

c)     403禁止访问

d)     500服务器内部错误

8， webapplication就是一个格式比较固定的目录

1,构建一个 JDBC 应用程序包括以下六个步骤-

·        导入数据包：需要你导入含有需要进行数据库编程的 JDBC 类的包。大多数情况下，使用 import java.sql.就足够了。

·        注册 JDBC 驱动器：需要你初始化一个驱动器，以便于你打开一个与数据库的通信通道。

·        打开连接：需要使用 DriverManager.getConnection() 方法创建一个 Connection 对象，它代表与数据库的物理连接。

·        执行查询：需要使用类型声明的对象建立并提交一个 SQL 语句到数据库。

·        提取结果数据：要求使用适当的 ResultSet.getXXX() 方法从结果集中检索数据。

·        清理环境：依靠 JVM 的垃圾收集来关闭所有需要明确关闭的数据库资源。