Java学习---基础知识学习

2016-07-23 周六

利用键盘输入的时候需要抛出异常，直接快捷键 ctrl + 1 ;
定义数组 int score[] = new int[4] ; 只有4个数字
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;
String str = br.readLine() ;//直接输入，直接输出
score[i] = Integer.parseInt( str) ; //转换Str 为 Int
int temp = Integer.parseInt(str);   //字符串变为int型
String str = new String(b); byte变字符串
Scanner scan = new Scanner(System.in) ;
冒泡排序： i=1;j=0 ;
    for (int i = 1 ; i < 3 ;i++ ){
        for(int j = 0 ; j< 3 ; j++){
            if(score[i] < score[j]){
                int temp = score[i] ;
                score[i] = score[j] ;
                score[j] = temp ;
            }

方法的定义: public static 返回值方法名（类型参数，类型参数,）{
                程序体；
                （return) //可省略
        }
类名定义： ArrayDemo (单词首字母大写)
方法定义： printInfo (第一个单词小写，后面的单词首字母大写 )

定义的时候 char c[] = {'','','',''} ; 字符串都是单引号，字符都是双引号
float型的参数都是 3.2f,
使用 break 可以结束一层循环
使用 return 可以结束一个方法
方法的递归； return x + sum(temp) ;
栈中存放的是堆空间的地址；中放的是名字，堆内存是实际数字

2016-07-24 周日

Java 的直接数组排序 java.util.ARRAY.sort() ;
Java 的直接复制数组 System.arraycopy(源数组，源数组开始位置，目标数组，目标数组开始位置，数组长度 ) ;
    (说是复制，其实就是目标位置的数组的替换，将源数组的数字复制到目标数组的位置，目标数组的长度不变)
Java 新特性：foreach(数据类型变量名：数组名称) ; foreach (int x ; temp) ;
Java 新特性：可变参数：返回类型方法名(类型... 参数) public void fun (int... arg)
    例： fun(new int[]{1,1,1,1,1}); // 传递参数可以直接传递
Java的多态性：方法的重载；方法名同但是参数类型和参数的个数不同；   System.out.println 也属于重载
              对象的多肽：子类对象可以和父类对象进行相互转换，而且根据子类的不同，完成的功能也不同
Java的封装性：对象的属性和行为看成整体，即对象；
              信息的隐蔽
              private 声明的属性或者方法只能被类的内部进行访问，而不能在外部被访问；
this的使用：
    this.表示当前对象，this必须发放到构造方法的首行
    this调用构造方法时一定要保留一个构造方法作为出口，也就是有一个构造方法不调用this();
    this.方法名() 强调是本类中的方法；
    this.属性强调是本类中的属性；
Java的继承性：拥有一般特性的事物，在基础上派生其他；
类：成员变量声明 + 方法定义：
构造方法：在实例化的时候就可以进行赋值，而不是调用setter 和 getter 方法 //也即是说，只是一个赋值的过程，没有返回值
           方法名与主类同；不能有返回值类型声明；不能有return语句；默认 default 类型
匿名对象：没有明确给出名称的对象；一般只使用一次，而且直接开启堆空间，不存在栈空间的索引；
            new Person("zhangsan",12).tell() ;
String 本身就是一个类，但是我们一般用的String没有开辟栈空间，比较的只是堆空间的值；
        一个字符串本身就是一个String的匿名对象；
        “==” 比较的是开辟的空间，而不是内容；
        equal() 比较内容是否一致；
        String 里面indexOf本身就可以比较内容是否相等，他是找到内容，然后返回字符所在位置， !(indexOf("hello"))!= -1 表示找到
        一个String对象内容的改变实际上是通过内存地址的更新完成的，本身的字符串内容不会变；
        char[] toCharArray() ;//转换为字符数组 charAt() //特定的位置取值 String split()//按照指定的字符串分割
        String subString()指定字段取值 equals(), equalsIgnoreCase()
        split 和 raplaxeAll() 支持正则表达式；，返回时一个 String s[] =
        indexOf : 从指定位置开始查找字符串位置，没有找到就返回 -1 ；
        charAt ：取出指定位置的字符   trim() :去掉左右的空额
        length 和 length() 在数组中,length是长度，String操作中是函数，需要length() ;
引用传递：就是将一个堆内存空间的使用权交给多个栈内存空间
        接受本类的对象： public void fun(Demo d2)

2016-07-28 周四

Java的内存区域：
    栈内存：保存所有对象的名称（堆地址的内存空间）
    堆内存：保存每个对象的属性内容
    全局变量： static类型属性
    全局代码段：保存所有的方法定义
Static关键字：堆内存保存对象，可以用static共享属性
    static声明属性的又称为类属性，因为类的公共属性应该由类来修改，毕竟用户不知道到底会有多少对象产生；
        static String count = "ad";   Person.count = "bc";
    static声明的方法又称为类方法，可以用类名调用；
        public static setName(String name) ;      Person.setName("lvfengtao") ;
    static应用，可以查看定义了多少给实例化对象；
System.exit(1) ; //可以直接退出程序，设置非0数字
代码块：
    普通代码块：{}括起来的，直接在方法或者语句中设置的
    构造代码块：直接写在类中的代码块   //只有一行代码
    静态代码块：用static声明的代码块
        静态代码块优于主方法执行，类中的静态代码块优先于构造块执行，且只执行一次，不管产生几个对象
构造方法私有化： private 方法名()
    构造方法一旦私有化，就不能new调用，就必须从内部调用
        一种是static 属性，另一种是static 方法，返回实例，通过类.方法名调用；
单例设计模式：无论程序怎么运行，始终只有一个实例化对象存在，只要将构造方法私有，就可以对控制实例化对象的产生；
数组一定要先开辟空间，因为是引用类型
主方法的String args[]    本身就是一个类，主方法中的参数本身就是以对象数组的形式出现的；
内部类：在类的内部在定义一个类
    缺点：类由属性和方法构成，所以会破坏类结构
    唯一的好处就是可以访问外部类的私有属性；
    用static声明的内部类变成了外部类，但是不能访问非static声明的外部类属性
在外部访问内部类
    外部类.内部类内部类对象 = 外部类实例.new 内部类() ;
    private 定义是在一个类里面都可以访问，所以内部类可以直接访问外部类的属性；
使用statIC声明的内部类就会成外部类，使用static声明的内部类不能访问非static声明的外部类
在方法中定义一个内部类
    在方法中定义的内部类不能直接访问方法中的参数，如果发放中的参数想要被内部类访问，就必须在参数前加final关键字

2016-07-30 周六

使用构造方法的时候，一定是this.setName(name);   继承的时候是，super(age,name);   Getter方法中：return school;
关于输出，最好是在类中返回String方法，然后在主类中 System.out.println(实例化对象.方法名) ；

6.1 继承类(派生类)
    Java只允许单继承，一个子类只允许有一个父类，允许多层继承，一个父类还有一个父类；
    子类是不能调用父类的私有成员，子类可以调用父类的非私有方法，但是不能直接调用父类的私有成员，但是可以通过setter和getter；
    子类实例化对象之前，先调用父类的构造方法，后调用子类的构造方法，实际上子类的构造方法中隐藏了super()方法【超类】
    子类不能拥有比父类更高级的访问权限
6.2 this 和 super 区别：
    1.this 只能调用本类的属性、方法，本类中没有则父类查找    super 访问父类的方法，方法
    2.this 调用本类构造， supe 调用父类构造，且放在子类首行
    3.this 表示当前对象
6.4 final :完结器    ，final声明的类不能有子类，声明的方法不能被覆写，声明的变量为常量，不可以修改
    final声明的变量必须全部大写； public static ，final String NAME = "Lvfengtao";
6.5 Abstract 抽象类：抽象类是一种模板，必须被继承才能用，一个子类只能继承一个抽象类
    包含一个抽象方法的类是抽象类；抽象类和抽象方法必须由abstract声明；抽象方法只需声明，不需要具体；
    抽象类必须被继承，子类必须前部复写抽象类中的全部抽象方法 public abstract void print();
    抽象方法不要使用private声明，因为必须被覆写，子类不易复写；
    抽象类可以定义构造函数，所以子类实例化之前必须对父类进行实例化，也就是说先必须给打印父类的构造方法然后子类的构造方法
    子类可以通过super()方法调用抽象类(父类)的构造方法,也可以在子类调用父类指定参数的构造方法

    子类 extends 抽象类 implements 接口A，接口B
6.6 接口：特殊的类，由全局常量和公共的抽象方法组成 // 接口本身已经定义，所以不需要在写 public static fianl 和 abstract ;
           由于明确规定了抽象方法是public 类，所以也不需要在写；
           接口与抽象方法一样需要子类的继承 implements，一个子类可以实现多个接口，摆脱继承的单继承
           全局常量，在接口里定义的时候用大写
           Java允许一个抽象类实现多个接口，但是一个接口不允许继承抽象类，允许一个接口继承多个接口
           接口的继承： interface A extends B, C
    interface A {
        public static final String INFO =， "Lvfengtao"             ====   String INFO = "Lvfengtao"
        public abstract void print()   ========== (public)void print()
        //全局常量；
        抽象方法； //必须是public方法，写与不写，Java的接口方法都是pblci
    }
6.7 对象的多态性
    表现： 1、方法的重载和覆写
           2、对象的多态性
                        （向上转型：子类--> 父类；父类父类对象 = 子类实类
                          向下转型：父类 --> 子类，且必须说明向下转型的子类类型）子类子类对象 = （子类）父类实例
        ** 对象是Object类型，需要转型 String str = (String)obj[i];

2016-08-02 星期二

6.12 包装类； Java数据分为基本数据类型和引用数据类型,

              用的最多的还是讲字符串变为数据类型（int i= Interger.parseInt("1234")）；
              (字符串变为数组的时候需要抛出异常)
    拆箱和装箱： Interger i = new Interger(x);   int x = i.intValue();
                   Integer i = 0 ;//自动封装         int x = i; //自动拆箱

7.1 异常的基本概念
    Java的异常都是以类和对象的形式存在，Java的错误主要是语法和语义的错误，编译的时候没有报错，但是运行的时候也可能报错
    Try() 找到错误后会跳转到 catch里面，一旦产生异常，则首先回产生一个异常类的实例化对象，
    Exception 和 Error 都是Java Throwable的异常类
    通常用e.printStaceTrace()方法打印异常信息，所有的额子类的实例都可以用父类来接受，所以可以调转
7.2 throws 和 throw关键字
    throws声明的方法，表示此方法不处理异常，而是调用方法去处理；

2016-08-03 星期三

9.1 多线程：继承 Thread类【要覆写run()】或者实现Runnable类 // 都需要覆写run()方法
        由于受到单继承的影响，所以一般多线
中程是通过
        同时可以调用父类start()方法，实现多线程，说是调用start()方法，但是调用的却是run()方法的主题
        一般重复调用start()方法回抛出异常，而且本质上调用 start0()这个方法，因为使用了native声明，所以需要依靠底层的操作系统支持
        实现Runnable()方法，需要实现多线程，可以利用Thread类中设定的方法启动多线程
        Thread类也是Runnable接口的子类，但是Thread并没有完全的实现Runnable接口的run() Thread 构造方法 Thread thread = new Thread(接受 Runnable的子类，设置线程名称 )
        继承Thread类并不能实现资源共享，如果想要资源共享必须实现Runnable接口

        避免单继承带来的局限性；代码能与多个线程共享，代码与数据是分开的；
9.2 线程的状态：创建、就绪、运行、阻塞、终止
    getName: 取得线程名称；   setName：设置线程名称
    main()本身也就是一个线程，每次Java运行都至少启动2个线程，一个main,一个垃圾回收
    main()方法可能比其他方法更早执行；
    public static Thread currentThread(): 返回当前执行的类
    public final String getName(): 返回线程名称
    public final int getPriority(): 返回优先级   1 5 10
    public boolean isInterrupted(): 线程是否中断；
9.3 Thread类中有一个方法: 利用构造函数可以直接命名线程   子类实例化以后就可以直接start
    Runnable,需要子类实例化对象，然后调用Thread调用start方法
9.6 解决资源同步问题：1、使用同步代码(Synchronized(同步对象 this)
                      2、同步方法
            多线程共享同一资源的时候需要同步，但是过多会产生死锁；
    方法的完整定义：
    public/default/private/protected   final static syncronized 返回类型方法名（参数类型参数名称） throws EXCEPTION{    return [返回值/返回调用处]}
    死锁：同步可以保证资源共享的正确性，所谓死锁就是2个线程都在等待彼此完成任务，造成程序停滞

2016-08-06 星期六

    new String(bInput);   //byte数组变为字符串    byte[] b = str.getBytes();
    int i = Integer.parseInt(str);    //字符串变整数    {\\d4}必须数字出现4次
    (^\\d+.?) 正则表达式匹配小数   ,? 表示小时代可以出现一次或0次
    [a-zA-Z0-9]字母数字     \w 字母、数字、下划线     ^\\d{4}-\\d{2}-\\d{2}$:年与日
    [abc]: 字符abc   [^abc]: 除了abc之外的任意字符 \d ：数字 \D: 非数字 \w：字母、数字、下划线 \s:所有空白字符
    X？：出现0次到1次 X*:出现0次，1次，多次 X+：出现1次或多次
    X|Y：先X或Y XY：先X后Y

    正则表达式需要Patter和Matcher两种类完成, Patter类主要进行正则规范Matcher主要执行验证
    Patter.complie("[0-9]+").matcher(str).matches();
    Patter p = Patter.compile("[0-9]+");
    Matcher m = p.matcher(str);
    m.matches();

12.16 序列化
    实现Serializable接口，还需要依靠对象输出对象和对象输入流
        对象输出流(ObjectOutputStream): 实现序列化
            构造方法(传入输出对象)：ObjectOutputStream(OutputStream out)
            普通方法(输出对象)： writeObject(Object obj)
                File file = new File("E:" + File.separator + "test.txt");
                ObjectOutputStream oos = null;
                OutputStream os = new FileOutputStream(file);
                oos = new ObjectOutputStream(os);
                oos.writeObject(new People("People",21));
                oos.close();

    实现Externalable接口，还需要依靠对象输出对象和对象输入流

        public void readExternal(ObjectInput input)   // 读取需要的内容
        {
            this.name = (String)input.readObject(); //需要转换
        }
        public void writeExternal(ObjectOutput output) // 写入需要的内容
        {
            output.writeObject(this.name);
        }
    transient: 声明的关键字不可以被序列化

13.1 认识类集
            :动态完成对象数组操作，是动态的对象数组，是对一些实现好    的数据结构的包装，不受对象数组长度限制；
        特点:对基本类集（动态数组、连接表、树）实现是高效的
             框架允许不同类型的类集以相同的方式和高度
        Collection: 接口，存放一组单值(集合中的每个元素都是一个对象)的最大接口，
        List: Collection 子类接口，堆Collection扩充，允许内容重复
        Set: Collection 子类接口，没有对Collection扩充，允许内容不重复
              依靠hashCode()和equals()两个方法区别
        Map；存放一对值得最大接口，Key -- > Value

        Iterator:集合的输出接口，用于输出集合中的内容，胆小
        ListIterator: 可以双向输出

        Enumeration: 输出指定集合的内容
        SortedSet: 单值的排序接口，可以使用比较器排序
        SortedMap：存放一对值得排序接口，按照key值比较

        Queue: 队列接口，可以实现队列操作
        Map.Entry: Map.Entry的内部接口，每个Map.Entry对象都保存这一对 key --> Value的内容，每个Map接口都保存很多Map.Entry接口实例
        List<String> list = new ArrayList<String>() ;
        System.out.print(list);

2016-08-07 星期日

13.1 String str[] = list.toArray(new String[]{}); //后面的{}实为初始化
        indexOf() 找不到返回-1 找到显示位置

        ArrayList 和 Vector区别：
            ArrayList是异步处理方式，性能高，非线程安全操作类，使用Iterators

        LinkedList子类和Queue接口
            LinkedList表示一个链表的操作类， ListedList<> l = new ListedList<>();
            poll()方法找到首字母并回删除首节点， peak() 找到首字母
            Queue表示的是队列操作接口，采用FIFO方式操作，for(int i; i< list.size()+1

        set：
            散列存放：HashSet：
                set<String/也可以是个类名> s = new HashSet<String/也可以是类名>();
                System.out.println(set);   //自主调用toString()方法
            有序存放：TresSet 类中的每一个对象所在的类都必须实现Comparable接口才可以使用；
                       TreeSet自定义排序是一定要继承Comparable类，复写Comparto()方法，
                       public int compareTo(Person per)
                       但是比较器比较的时候，如果某个属性没有进行比较的指定，也会认为是同一个对象，所以应该增加按照姓名比较；
                       return this.name.compareTo(per.name);
                去除重复元素：主类不需要继承TreeSet,但是需要复写equals方法，编写hashCode方法
13.6 集合的输出
        如果要输出Collection、Set集合中的内容，可以将其转换为对象数组输出，而List则可以直接使用get()方法输出；
        常用的类集合为:
            Iterator: 迭代输出(判断元素是否有内容，有就输出)
            ListItarator: Iterator的子接口，专门用于输出List
            Enumeration: 旧接口

2016-08-08 星期一

13.6.1
    Iteration: Iterator是一个接口，直接使用Colletion定义的    itreator()实例化；同理List和Set也实现了此方法
        hasNext(): 返回boolean,判断元素是否有内容，
        next():输出,取出内容
    ListIterator：只能通过List实现实例化，只能输List内容
        hasPrevious(): 判断是否有上一个元素
        pervious(): 取出当前元素
        nextIndex(): 返回下一个元素的索引
        previousIndex(): 返回上一个元素的索引
        set(): 替换元素
        实现ListIterator接口双向输出时，如果想完成右后向前输出，则一定要先右前向后输出；
    forEach: for (String str: list)//(类对象：集合){}

13.7 Map接口
    Map<K,V>:
        clear(): 清空cler()
        containKey(): 判断指定key是否存在
        set<May.Entry><K,V> entrySet(): 将Map对象变为Set集合
            Map.Entry是Map内部定义的一个接口，专门保存key->va
                可以由外部通过“外部类.内部类”直接调用
            Map内容是K-V形式保存，实际上K-V是把数据保存在M.E之后
                Map输出数据的时候必须使用M.Entry接口
        V get(OBJECT key): 根据key 取得Value
        set<K> keySet(): 取得所有key
            Set<String> set = map.keySet();
        Collection<V> value(): 取出全部value
        V put(K kye, V value): 向集合中加入元素
        putAll<Map<? extends K, ? extends V>t> 一个Map集合加入到另一个
13.7.1 Map接口常用的类
           HashMap：无序存放，新的操作类，key不能重复
           HashTable: 无序存放，旧类操作，key不能重复
           TreeMap：有序Map集合，按key排序，不允许重复
           WeakHashMap：不再用的内容青岛湖
           IdenHashM： key可以重复
        Map接口的使用注意事项：
            1.不能直接使用迭代输出Map内容，因为Map 存放一对值，Iterator只能输出一个
            2.Map很少作为直接输出的额，只是用作查询
            3.直接使用非系统类作为key

2016-08-28 星期日

//利用indexOf判断某个字符是否存在也可以用
//replaceAll （源数字，目标数字) 直接替换
//System.out.println(str.charAt(8)); 取出第8个字符
继承父类以后调用父类的构造方法：super(name, address, sex, age);
输出父类的属性： super.toString()

代理模式：代理和真实主题均要实现接口，在代理中实现真实主题实例化(构造方法中实现)
工厂模式: 其他了均实现接口，定义一个类专门获取实例，不是构造方法获得
适配器模式：接口定义方法，构造方法实现此接口，方法体为空，后子类继承抽象类，有选择的复写方法
观察者模式：要被关注的继承Obserable类，调用父类方法 super.setChanged(); super.nosuper.notifyObservers() 观察着实现 Observer接口，在update类中，判断是否是一个类，输出即可
//这些接口呢都需要用到多态性，都是接口接口对象 = new 子类对象()，实现向上转型，转型后可以调用子类复写父类的方法
如果需要向下转型，则调用子类自己的方法，但是需要先向上转型后， instanceof 比较对象；

//如果要进行字符串的拆分，利用split方法
Pattern p = Pattern.compile("[a-zA-Z]");
String s[] = p.split(str);
//如果需要正则表达式来进行字符的替换，
String str = "123231m3m123m123m123m12";
        Pattern p = Pattern.compile("[a-zA-Z]");
        Matcher m = p.matcher(str);
        String ss = m.replaceAll("_");
、、以上方法String都有支持的 boolean matches(String regex); String[] split(); String replaceAll(String regex, s)

2016-08-30 星期三

时间类： SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
         sdf.format(new Date())    ;
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Date temp = sdf.parse(str);
字符串拆分：
        String str = "<html xmlns=\"http://www.w3.org/1999/xhtml\">";
        str = str.substring(str.indexOf(" ")+1, str.indexOf(">")).replaceAll("\"", " ").replaceAll("\\.", " ").replaceAll("/", " ");
字符串内输入双引号： \"
定时调度：
    Timer类：是一种线程设施，可以定时安排一个时间，与TimerTask(实现由TImer安排的一次或重复执行的某一个任务)配合使用
IO操作：
    File打开文件--> 字节流制定位置-->读写--> 关闭流
    FIle类：文件本身操作
        boolean createNewFile();
        boolean exists();
        boolean isDirectory();
        String[] list();
        File[] listFiles();
        boolean mkdir();
        boolean renameTo(File dest);   //已有文件重新命名
    RandomAccessFile类：随机读取类（一般不用）
        RandomAccessFile(File file, String mode)   //file路径
        RandomAccessFile(String path, String mode)//固定路径
        close(): 关闭操作
        void writeBytes(String s): 字符串写入文件
        void writeInt(jint v)
        int read(byte[] b): 将内容读取到一个byte数组
        byte readByte(): 读取一个字节
        int readInt(): 读取整数型
        int skipBytes(int n):指针跳过多少字节
        void seek(long pos): 指针位置
    所有数据都是已流的方式传输或保存，分字节和字符
    字节流：以byte为准，需要将字符串转为Byte数组
     OutputStream
        OutputStream out = new FileOutputStream(file);
        OutputStream out = new FileOutputStream(file, true);追加内容
        String str = "\r\nHEllo world"; 文件需换行，可以加\r\n
        byte[] b = str.getBytes();
        out.write(b);
        out.close();
     InputStream:
        int avaliable(); //取得文件大小
        int read();//以数字的方式读取
        int read(byte[] b) ；内容读取到byte数组
        InputStream input = new FileInputStream(file);
        byte[] bb = new byte [(int)f.length()]
        //byte[] bb = new byte[1212];
        //int len = input.read(b); //取出内容到byte数组,确定输出多少
        while(input.read()!=-1)
        {
            b[len] = (byte) temp;
            len++;
        }
        input.close();
        System.out.println(new String(b, 0, len));
        一个字符2个字节；
    字符流： Writer        子类： FileWriter
        可以添加对象， Writer writer = new FileWriter(new File(), true);
        write(String str) 字符串输出
        write(char[] c)        字符数组输出
        flush()     强制清空缓存
            Reader   子类 FileReader
        int read()
        int read(char[] c): 内容读取到字符数组，返回长度
        字符的输出： new String(c, 0 ,len)
        读取字符串有2中方法：直接从文件读取
                              for循环读取一个字节 int len = 0；
                              int temp = 0; //接收每一个内容
                              while((temp = reader.read())!=-1)
                              {
                                c[len] = (char)temp;
                                len++;
                              }
        字符流使用了缓冲区，字节流没有使用缓冲区(内存区域)；
        不关闭时也将字符内容输出，可以使用Writer类的flush()方法

    打印流： PrintStream() 和字符打印流()

2016-09-03 星期六

1.Serializable(Serializable)
        一个类的对象要想被序列化(一个对象变为2进制，方便存储和传输)，就必须实现Serialiable接口，依靠ObjectOutputStream()和ObjectInputStream()
       Java序列化的时候会产生一个序列化ID，通过JVM实现
            File file = new File("F:" + File.separator + "hello.txt");
            OutputStream out = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(out);
            oos.writeObject(new Person("lisi"));
            ObjectInputStream ois = new ObjectInputStream()
            oos.close();
            InputStream input = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(input);
            Object obj = ois.readObject();
            ois.close();

    2. Externalizable是Serializable子类，实现此接口的可以用户自己制定被序列化的内容
        writeExternal(ObjectOutput ot): 指定要保存的属性信息，对象序列化时调用
        readExternal(ObjectInput in): 读取被保存的信息，反序列化用
        以上2个方法都是DataOutput 和 DataInput接口的子类
        public Person(){};
        public Person(String name)
            {   this.name = name; }
            //读取属性，有一个强制转换的要求
        public void readExternal(ObjectInput input)
            {   this.name = (String) input.readObject();}
            //保存name属性
        public void writeExternal(ObjectOutput output)
            {     output.writeObject(this.name);    }
        一个类要使用Externalizable实现序列化，此类必须有一个无参构造方法，因为在反序列化的时候会默认调用无参构造实例对象
    3. transient：关键字表示对象的某一个属性不希望被序列化
    4.    序列化一组对象：
            对象输出时只提供了writeObject(Object obj))，并没有多对象输出，所以要实现同时序列化多个对象，就可以使用对象数组操作。
            因为数组属于引用类型，可以用Object类型接收
    5.    List Set(重复内容依靠hashCode() 和 equals()方法区别) Queue SortSet(对集合中的数据进行排序)
        List:接口
            add(int index, E element)
            addAll(int index, Collection<? extends E> c) 添加一组元素
            E get(int index)
            ListIterator<E> listIterator()
            E remove(int index)
            E removeAll(Collection<?> arg0)
            List<E> subList(int fronIndex, int toIndex)
            E set(int index, E element)
            toArray(): 集合变为对象
            size(): 返回集合的长度
            get(int index): 返回当前的位置的数字
            for(int i = 0; i < allList.size(); i++)
            {
                System.out.print(allList.get[i] + "、");
            }
        LinkedLis：链表操作类
            addFirst(E e );
            addList(E e);
            boolean offer();
            E removeFirst()
        Queue:先进先出
            E element()：找到表头
            E peek() 找到不删除;
            E pool() 找到后删除; 利用此方法先进先出输出数字
            E remove() 检索并移除表头

        Set：HashSet && TreeSet
        HashSet:
            无规律可循
        TreeSet:
            有规律
            如果是比较对象，则需要继承Comparable接口，实现CompareTo()方法
            class Person implements Comparable<Person>//接口处定义泛型类型
            public int compareTo(Person per) {
                if ( this.age > per.age)
                {
                    return 1;
                }
                else if (this.age < per.age)
                {
                    return -1;
                }
                else
                {
                    return 0;
                }
            比较器操作时如果某个实现没有进行比较，则默认为是一个对象
            如果实现了HashSet,则所有的重复对象也会继续出现，就需要复写Object类的equals()方法和hashCode()方法，一个对象编码表示一个对象
        SortedSet:    TreeSet继承SortedSet
            SortedSet<String> set = new TreeSet<String>();
            first(); last();
            SortedSet<E> headSet(E element):开始到指定位置
            SortedSet<E> tailSet(E element):指定到最后
        //可以用get()方法输出数字
        Iterator:
            Iterator iter = list.iterator();
        ListIterator:
            由前向后： hasNext() && next()
            有后向前：利用hasPrevious()方法由前向后判断，用previous取出元素
            set() 和 add() 可以更改和添加元素
            foreach输出：
                for (类对象：集合) {}; for（String str: all)

        Map：HashMap && TreeMap
            put(Object key， Object obj): 添加数据
            get(): 根据key值取得value的值
                Map<String, String> map = new HashMap<String, String>();
                Set<String> keys = map.keySet();
                Iteration key = keys.iterator();
                while(key.hasNext())
                {
                    String str = key.next();
                    System.out.println(map.get(str）);//根据key 取值
                }
                map.get（iter.next()）
            containKey(): 判断指定的key是否存在
            keySet(): 将一个Map中的key变为Set集合，然后利用Iterator输出
            values(): 返回Collection，注意定义泛型类型
                Collection<String> col = map.values();
                Iteration valus = col.iterator;
                while(values.hasNext()){};
            Map接口注意事项：
                1. 不能直接使用迭代输出Map中的全部内容，因为Map存放的是一对值，Iterate只能每次找到一个值，如果非要迭代输出，则必须：
                    1> Map实例通过entrySet()方法变为Set接口对象
                    2> 通过Set接口实例化Iterator、
                    3> Iterator迭代输出，每一个ie内容都是Map.Entry的对象
                    4> 通过Map.Entry进行 key --> value分离
                    (Map中的每对数据都是通过Map.Entry保存的，所以也是Map.Entry输出)
                    Map<String ,String> map = null;
                    map = new HashMap<String, String>();
                    map.put("04122077", "吕峰涛");
                    map.put("04122076", "吕峰");
                `    Set<Map.Entry<String, String>> set = map.entrySet();
                    Iterator<Map.Entry<String, String>> iter = set.iterator();
                    while(iter.hasNext())
                    {
                        Map.Entry<String, String> me = iter.next();
                        System.out.print( me.getKey() + "--> "    + me.getValue()    + "\t");
                    }
            SortedMap: 排序接口，实现此类都是排序的子类，例如TreeMap
                Comparator<? super K> comparator();
                K firstKey(); K lastKey();
                SortedMap<k, V> subMap(K fromKey, K endKey)
                SortedMap<K, V> tailMap<K fromKey): 返回大于指定key的部分集合
            Collection:
                addAll(): 为一个集合增加内容 Collection.addAll("ARRAY", "BufferedReader");
                reserve():
                binarySearch(): 返回内容位置
                sort(); 排序
                swap(): 交换我ie之

            Stack: 先进先出
                push: 进站
                pop: 出战
                int search(Object o): 在战中查找
            Properties:
                new Property().setProperty("key", "value");
                store(OutputStream out, String comment, String encoding);
                list(PrintStream out):
                loadFromXML(InputStream in):
                storeToXML(OutputStream out)

2016-09-05 星期一

1. Class类方法
        Class<?> forName(String Name): 传入完整"包.类", 实例化Class对象
        c1 = Class.forName("com.huawei.ftl.X");
        System.out.println("类名称： " + c1.getName());
        也可以通过类.class或者对象.getClass()实力化Class类
        实例化后可以通过newInstance()实例化对象，注意转换类型
        per = (Person) c.newInstance();
        （以上注意一点，就是类中必须由无参构造方法）
        Construtor[] getConstructor: 得到类中所有的构造方法
        Field[] getDeclaredFields(): 得到继承来的类
        Class[] getInte

2016-09-10 星期六 JavaWeb

    HTML注释语句： <!-注释语言->
    1. JS的事件处理： body (onLoad()="start()" onUnload()="stop()" onClick="fun()")
                    onSubmint():事件在提交之前先验证
                    onCHange(): 变化
           文本处理： var value = document.form.content.value;
                    //精确到具体的name值，然后取值，否则为空

    2.3.3Window对象
         window.location: 定位到对应网页
         window.open: 打开网页设置
         HTML：表达式完成交互的收到，表单元素写在《form>里面
         JavaScript是基于对象的语言，function是函数，又返回值直接返回return即可。
     3.1 XML：可扩展性标志语言，实现数据交换，系统配置，内容管理。
         XML语言是以<? ?> 开始和结束的
         version：
         encoding：编码
         standalone: 是否独立运行， XML声导固定格式
         <?xml-stylesheet type="text/css" href = "attri.css"?>
         <![CADATA[里面的内容不解析]]>
     3.2 XML解析：SAX && DOM(文档对象模型)
         4个重要的额借口：
             Document：整个XML文档，根节点
             Node：每一个Node代表一个节点
             NodeList：节点的集合
             NamedNodeMap：一组节点和其唯一名称对应关系，属性节点
             NodeList getElementByTagNsme();取指定节点名
             Element createElement(String tagName):创建指定名节点
         Dom4J：利用工具来读写文件
             Document doc = DocumentHelper.createDocument();
             Element addresslist = doc.addElement("addresslist");
             Element linkman = addresslist.addElement("linkman");
             Element name = linkman.addElement("name");
             name.setText("吕峰涛");
            OutputFormat format = OutputFormat.createPrettyPrint();
             format.setEncoding("GBK");

2016-09-11 星期日

        1.创建目录--> WEB_INFO--> 复制WEBapps/ROOT/web.xml到虚拟目录下
        Tomcat修改端口：conf/server.xml
          虚拟目录：复制web.xml
            <content path="/mldn" docBase="虚拟目录地址"/>
            修改conf/web.xml listings的false修改为true;
            2xx:请求成功
            3xx:重定向
            403：禁止
            404：找不到文件
            500：服务器内部错误
        Tomcat是个Web容器
        2.JSP学习
            JSP的命名采用小写，且最终都是以*.class完成
            request.getParameter()方法接受输入内容。

2016-09-11

1. JavaBean；一个类只包含属性，setter,getter方法
         POJO: 简单的Java对象
         VO：专门传递值
         TO：传递对象
    2. 数据库操作：
        pstmt = conn.prepareStatement(sql);
        pstmt.setInt(1, tid);
        (注意顺序，一定是先执行语句，然后设置变量)

2016-09-18

    1.抽象类的使用：      Person per = new Student("lvfengtao", 12o, 99.9f);
        抽象类中定义抽象方法为public，不用写方法体 public abstract void say();即可；
    2.工厂模式中在工厂类中定义了一个静态方法来获取接口的实例；
        public static Fruit getInstance(String name)
    3.代理模式； Network net = new Proxy(new Real());

    }

2016-10-02 星期日

1. 使用Dom4J 生成XML文件，XML主要是用于数据交换
            Document创建一个DOC文档，一个文档只有一个根节点
            Element添加元素，
            OutputFormat完成格式化，设置为中文格式。
            XMLWriter完成数据的写入
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(
                        new FileOutputStream(
                                "G:" + File.separator + "new2016.xml"), format );
             writer.write(doc);
             writer.close();

    2. JS操作XML
        JS点击显示文字：
            document.getElementById("info").innerHTML = "<h2>www.MLDNJAVA.cn</h2>" ;
        JSP注释：
            1.   显示注释客户端可以看见
            2.<%--注释内容--%>;   /* */      // 隐式注释
        Scriptlet：3种方式
            1.<% %> : 定义局部变量
              <%!%>：全局变量，类，方法
              <%=%>: 输出一个变量
            2.标签：<jsp:scriptlet> 代码块 </jsp:scriptlet>
        Page: langua="Java" contentType="text/html" pageEncoding="GBK"
            必须是text/html 因为conf/web.xml写了这个
            2.错误页面显示：
                <%@ page isErrorPage = "true"%>   isErrorPage (注意大小写)
                <%@ page errorPage="error.jsp"%>
                属于服务器端的跳转
        Include：包含指令：
            1.静态包含： <%@ include file= "" %>
            2.动态包含：<jsp:include>:自动区分页面静态还是动态
                <jsp:include page = "{包含文件路径 | <%=表达式%>}" flush = "true/false"/>
                    <jsp:param name="参数名称" value="参数内容"/>
                </jsp:include>
                静态是先包含后处理，动态是先处理后包含
        跳转： <jsp:forward page = {""}>

2016-10-04 星期二 JSP

    中文问题：
        HTML：<meta http-equiv="Content-Type" content="text/html;
    charset= utf-8 "/>
        REQUEST：如果获取返回的值，可以设置
            request.setCharacterEncoding("utf-8");
    1.JSP内置对象 (9个，out, request, session(保存用户信息), application(所有用户的共享信息), response, pageContext(JSP页面容器))
      4个属性：page(一个页面保存，调整失效),
                request(只在一次请求保持),
                session(再一次会话范围内，任何跳转都行，新开浏览器失效),
                application(服务器保持)
            公共方法： setAttribute(), getAttribute(), removeAttribute(),
    2.
    page:
        pageContext.setAttribute("name", "吕锋涛");
        String name = (String)pageContext.getAttribute("name");
        取得属性后要记得想下转型
    HTTPServletRequest && ServerletRequest
    request：表示跳转后属性继续保存，换成超链接之后失效，一次情况下服务器只会给予回应一次
        getParametervalues(String name)：取得客户端发来的一组请求
        String method = request.getMethod();
        String ip = request.getRemoteAddr();
        String path = request.getServletPath();
        String contextPath = request.getContextPath();
        Enumeration enu = request.getHeaderNames();
        角色验证
    HTTPServletResponse && ServerletResponse
    response:对客户的的请求回应(HTML跳转 && sendRedirectict)
        addCookie(Cookie cookie)
        setHeader(String name, String value) //
            response.setHeader("refresh",2) 2秒刷新一次
            response.setHeader("refresh",2; URL="hello.html") 2秒刷新后跳转页面，客户端跳转
            <META HTTP-EQUIV="refresh" CONTNT="3";URL="hello.html">
        sendRedirectict(String location)客户端调整
        <jsp:forward> && sendRedirectict:
            JSP是服务器段跳转，跳抓后地址不变，客户端跳转会导致地址变化
                服务器端跳转时立刻的，客户端是执行万页面后跳转
        操作Cookie：让服务器端的技术保存在客户端，火灾客户端执行数据处理，提高了网页的速率，减少了服务器的运载，安全性差。
    javax.servlet.http.HttpSession
    session：一次设置，与设置页面相关就保存属性，可以通过超链接。新打开浏览器失效
        主要用于登陆和注销操作，每一个session对象都表示不同的访问用户
        getId(),
        getCreation():
        getLastAccessedTime():
        isNew():
        invalidate()://让session失效
        Enumeration getAttributeNames():
        获取用户时间：getCurrentTIme()；
        登陆程序：通过sessio保存方法；使用Cookie保存信息；通过表单隐藏域保存信息；通过地址重写保存信息
    application:保存属性到服务器
        getRealPath():
        getContextPath():取得当前虚拟路径名称
        配置虚拟目录：<Context path="/mldn" docBase="D:/mldn">
总结一下：
    1. request.setCharacterEncoding("GBK"); 设置为中文格式。
    <meta http-equiv="Content-Type" content="text/html;
    charset= utf-8 "/>
    2. this.getServletContext().getRealPath("/")；后去虚拟目录对应的真是目录
        request.getContextPath(); //获取虚拟目录对应目录
    3. PrintStream ps = new PrintStream(new FileOutputStream(file)); 设置输出流，输出到文件
        ps.println(content);
       ps.close();
       //但凡IO操作必然涉及异常处理以及IO流的关闭
    4. Scanner scanner = new Scanner(new FileInputStream(file)); 不明到底有多少的时候用StringBuffer;
          scanner.useDelimiter("\n");
          StringBuffer buf = new StringBuffer();
    5. response.setHeader("refresh", "2;URL=login.jsp"); 定时跳转
        <META HTTP-EQUIV="refresh" CONTENT="3";URL="request_demo_02.html">HTML定时跳转
        session.invalidate();   用户失效
        session.getAttribute("userid")；获取属性
        session.getId(); 和Cookie一样
    6. Cookie c[] = request.getCookies(); 至少1个
        <%=c[i].getName()%> ---> <%=c[i].getValue()%>
        **inst： getParametervalues用星号其区别；
    7. <jsp:param name="uname" value="<%=name%>"/> 传递参数：
        get && post区别：
            get:提交后的内容会显示在地址栏，post不会

    pageContext: response等设置的都可以在pageContext完成。
        pageContext.forward("hello.jsp"?info="hell0"); 传递参数可以直接传递
        String info = pageContext.getRequest().getParameter("info");
    config的配置需要在web.xml文件中配置

2016-10-05 星期三 JavaBean；

1. JavaBean；一个类只包含属性，setter,getter方法
         POJO: 简单的Java对象
         VO：专门传递值
         TO：传递对象，远程传输时必须继承Serialization
        所有的类放入一个包，声明为public class, 属性封装，至少有一个无参构造方法
        <jsp:useBean id = "sim" scope="page" class="com.huawei.ftl.SimpleBean"/>
        <jsp:setProperty property="*" name="sim"/> name是实例化对象名称，pro="*" 自动匹配

    2. 三目运算： return value == null?"":value;
    3. MVC:
        Model:完成独立的业务操作，JAVABEAN
        Control    ：负责所有的用户请求，判断是否合法，根据请求类型调用JavaBean，显示给View
        View：接受Servlet传递的内容，调研JavaBean显示给用户
        RequDispatcher(): request属性传递内容

2016-10-09 星期日小雨
    1. JSTL1.2标准库开发
        c: 核心开发库
        sql:查询数据库操作
        xml：XML数据
        fn: 函数操作
        H&N：fmt.tld 格式化数据
    2. c:out :输出属性
        c：set: 设置属性
        <jsp:useBean id="login" class = "com.huawei.mvc.servlet.LoginServlet" scope = "request"/>
        <%     request.setAttribute("simple", login); %>
        <c:set var = "world" value = "hello world" target = "${simple}" property = "content" />
                var:属性名称 value: 属性内容 scope: 保存范围 target:存储的目标属性 property:制定target属性
        c: remove : 删除指定属性
        c: catch:异常处理
        c: choose:多条件判断，可以结合c:when c:otherwise
                <c:choose>
                    <c:when test="${num==20}">
                        <h3>输入的nuam的值为： 20</h3>
                    </c:when>
                </c:choose>
        c: foreach :输出数组，集合
            <c:forEach items="${ref}" var = "m">
                ${m}
            </c:forEach>
            注意items里写的是一个集合，一个变量，要用${}表示
        c: url : 根据路径和参数生成一个新的URL
        c: redirect: 客户端跳转
        c: if :
            <c:if test="${10 > 1}" var = "res" scope = "request">
            test制定比较大小内容， var保存判断结果
        c:forToken: 拆分数组
        c:import 可以讲其他页面导入进来，类似<jsp include>

2016-10-10 Struts开发

1. Struts 中的Action相当于Servlet
                  ActionForm == JavaBean
        所有的输入从ActionForm取得,Servlet中由request取得
        Action 中完成跳转，需要在Struts-config中配置，每个Action配置也给跳转路径