不积跬步无以至千里

BeanUtils

                   setProperty(Objectobj,String name,Object value)

                            Student stu = new Student();

                            BeanUtils.setProperty(stu, "name", "Lily");

                            BeanUtils.setProperty(stu, "age", 18);

                            System.out.println(stu);

getProperty(Object obj,String name)

                            Studentstu = new Student("Lilei",20);

                            Stringname = BeanUtils.getProperty(stu, "name");

                            Stringage = BeanUtils.getProperty(stu, "age");

                            System.out.println(name);

                            System.out.println(age);

populate(Object bean, Map<String,String[]> properties)

                            Student stu = new Student();

                            Map<String,String[]>map = new HashMap();

                            map.put("name", new String[]{"Jim"});

                            map.put("age", new String[]{"18"});      

                            BeanUtils.populate(stu, map);

System.out.println(stu);

饥饿单例模式

         private static final Singleton01 single = new Singleton01();

                   private Singleton01(){

                  

                   }

                   publicstatic Singleton01 getSingle(){

                            returnsingle;

                   }

懒汉单例模式

private static SingletonDemo02 single;

                   private SingletonDemo02(){

                  

                   }

                   public static  SingletonDemo02getSingle(){

//                         如果创建 就不在进入同步代码块 提高效率

                            if(single == null){

                                     synchronized(SingletonDemo02.class){

//                                           避免同步时创建多个对象

                                               if(single == null){

                                               single = new SingletonDemo02();

                                               }

                                     }

                            }

                            return single;

                   }

厉害了,我的哥...

多交流,更有利于学习,...

貌似是从JavaSE开始的啊。加油。

都在这里晒笔记啊  牛

- - 6666666666666666

加油，谢谢分享

顶顶顶顶顶顶顶顶

回复回复

收藏了,以前学的都忘得差不多了,连配环境变量都忘了...

Xsl全名：xml schema instance

Web-app web.xml的根节点标签名称

Version 版本

Xmlns web.xml文件用到的命名空间

Xmlns：xsi  指web.xml遵守xml规范

Xsi：shemaLocation 具体用到的schema资源

XML

         可扩展的标记语言

         作用

                   1.存放数据

                   2.配置文件

         语法

                   文档声明

                            <?xmlversion="1.0" encoding="UTF-8"?>

                            1.文档声明必须为<?xml开头，以?>结束；

                            2.文档声明必须从文档的0行0列位置开始；

                            3.文档声明只有2个属性：

                                     version版本

                                     encoding编码

                   元素

                            <bean></bean>

                            1.必须开始结束

                            2.标签由开始标签，元素体、结束标签组成<hello>大家好</hello>

                            3.元素体 可以是文本 也可以是标签<b><a>你好</a></b>

                            4.空元素<c   />

                            5.元素命名 区分大小写 不用特殊符号 不要xml开头

                            6.必须有根元素

                   属性

                            <beanid=”” className=””>

                            1.出现在开始标签

                            2.属性名="属性值"

                            3.一个元素多个属性不可相同

                            4.属性名无特殊符号 字母开头

                   注释

                            <!---->

                   转义字符(不用记)

                            <  &lt;

                            >  &gt;

                            "  &quot;

                            '  &apos;

                            &  &amp;

                   CDATA

                            <![CDATA[

                                     纯文本

                            ]]>

                   DTD

                            引用DTD

                                     本地dtd

                                     <!DOCTYPEbeans SYSTEM "bean.dtd">

                                     公共dtd

                                     <!DOCTYPEbeans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"

                                     "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

                            元素声明(了解)

                                     ？ 0-1次

                                     *  任意次

                                     +  至少1次

                                     ()分组

                                     |  或

                                     ,  顺序

                            属性声明(了解)

                                     属性的语法：（attribute）

                                     <!ATTLIST元素名

                                               属性名 属性类型 约束

                                               属性名 属性类型 约束

                                               ...

                                     >

                                     元素名：属性必须是给元素添加，所有必须先确定元素名

                                     属性名：自定义

                                     属性类型：ID、CDATA、枚举…

                                               ID: ID类型的属性用来标识元素的唯一性

                                               CDATA：文本类型

         

                                     约束：

                                               #REQUIRED：说明属性是必须的；required

                                               #IMPLIED：说明属性是可选的；implied

                            能根据约束写标签即可

                   Schema

                            引用Schema

                                     <beansxmlns="http://www.itcast.cn/bean"

                                           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                                            xsi:schemaLocation="http://www.itcast.cn/beanbean-schema.xsd"

                                     ></bean>

                            能根据约束写标签即可

                           

                           

      xml解析

                   DOM解析原理

                            将xml加载进内存 形成DOM树 并得到一个document对象

                   dom4j

                            常用API如下：

                            1.SaxReader对象

                                     a)read(…) 加载执行xml文档

                            2.Document对象

                                     a)getRootElement()获得根元素

                            3.Element对象

                                     a)elements(…) 获得指定名称的所有子元素。可以不指定名称

                                     b)element(…) 获得指定名称第一个子元素。

                                     c)getName()获得当前元素的元素名

                                     d)attributeValue(…) 获得指定属性名的属性值

                                     e)elementText(…) 获得指定名称子元素的文本值 不实用

                                     f)getText()获得当前元素的文本内容

类加载器

         全盘负责委托机制

                   全盘负责：A类如果要使用B类（不存在），A类加载器C必须负责加载B类

                   委托机制：A类加载器如果要加载资源B，必须询问父类加载是否加载。

         获取类加载器

                   ClassLoaderloader = 类名.class.getClassLoader();

动态代理

         调用者------类

         调用者-----代理类-----类

         ObjectproxyObj = Proxy.newProxyInstance(参数1,参数2,参数3);

                   参数1：ClassLoader，负责将动态创建类，加载到内存。当前类.class.getClassLoader();

                   参数2：Class[] interfaces,代理类需要实现的所有接口（确定方法）,被代理类实例.getClass().getInterfaces();

                   参数3：InvocationHandler,请求处理类，代理类不具有任何功能，代理类的每一个方法执行时，调用处理类invoke方法。

                          invoke(Object proxy ,Method ,Object[]args)

                                     参数1：代理实例 与你无关

                                     参数2：当前执行的方法

                                     参数3：方法实际参数。

public class ProxyDemo{

//  传入被代理的对象  匿名对象使用obj  用final修饰  

//  返回值object为 生成的代理对象

    public Object getProxy(final Object obj){

//     被代理对象的类加载器   被代理对象实现的接口   要实现的InvocationHandler子类

        ObjectnewProxy = (Object)Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),newInvocationHandler(){

            @Override

//           返回值Object 为method执行后的返回结果

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Classc = obj.getClass();

                Method[]methods = c.getMethods();

               

                if("add".equals(method.getName())){

                    System.out.println("执行add");   

                }

                if("remove".equals(method.getName())){

                    System.out.println("执行remove");

                }

                if("get".equals(method.getName())){

                    System.out.println("执行get");

                }

                return method.invoke(obj, args);

            }

        });

        return newProxy;

    }      

}

测试：

public classProxyTest {

    public static void main(String[] args){

        ProxyDemoproxy = new ProxyDemo();

        List<String>list = newArrayList<String>();

        list = (List<String>)proxy.getProxy(list);

        list.add("hello");

        list.add("world");

        

        list.get(0);

    }

}

单元测试

         @Testeclipse自带jar包 Ctrl+1导入使用

注解

         JDK提供的注解

                   @Deprecated表示被修饰的方法已经过时

                   @Override重写方法 1.5支持父类不支持接口 1.5之后支持接口

                   @SuppressWarnings抑制警告 需要给属性值 all 所有警告都抑制

自定义注解

                   关键字@interface

                  成员

                            publicabstract 返回值类型属性名()[defualt 属性值];

                            返回值类型

                                     基本类型，字符串，Class,注解，枚举，一维数组

public @interface Annotation {

  public abstract intage();

  public abstract String name();

}

注意：需要加上元注解才可以使用(不需要背单词能够使用快捷键写出即可)

                         @Retention 用于确定被修饰的自定义注解生命周期

                                      RetentionPolicy.SOURCE 被修饰的注解只能存在源码中，字节码class没有。用途：提供给编译器使用。

                                     RetentionPolicy.CLASS被修饰的注解只能存在源码和字节码中，运行时内存中没有。用途：JVM java虚拟机使用

                                     RetentionPolicy.RUNTIME被修饰的注解存在源码、字节码、内存（运行时）。用途：取代xml配置

                         @Target 用于确定被修饰的自定义注解使用位置

                                     ElementType.TYPE修饰类、接口

                                     ElementType.CONSTRUCTOR  修饰构造

                                     ElementType.METHOD修饰方法

                                     ElementType.FIELD修饰字段

//自定义注解要做元注解声明 Retention 生命周期  Target注解作用的位置

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE,ElementType.METHOD})

public @interface Annotation02 {

    public abstract int age(); //default 10;

    public abstract String name(); //default "Lily";

    public abstract Annotation AnnotationDemo() default @Annotation(age=19,name="hellp");

    public abstract String[] names() default {"JIm","Tom"};

   

}

       注解使用

                   使用格式

                            @注解类名( 属性名= 值 , 属性名 = 值 , .....)

                            应用在类，方法，构造方法 字段上

                   注意

                            如果属性名为value，且当前只有一个属性，value可以省略。

                            如果属性类型为数组，设置内容格式为：{ 1,2,3 }

                            一个对象上，注解只能使用一次，不能重复使用。

         解析

                            java.lang.reflect.AnnotatedElement

                            booleanisAnnotationPresent(Class annotationClass) 当前对象是否有注解 传入判断注解的字节码文件对象

                            TgetAnnotation(Class<T> annotationClass) 获得当前对象上指定的注解 传入获取注解的字节码文件对象 返回要获取的注解类型

public classAnnotationTest {

    @Annotation02(age = 30,name = "hello")

    public void method(){

        System.out.println("此方法被Annotaion02注解");

    }

    @Test

    public void method2(){

        

        Classc = AnnotationTest.class;

        Method[]methods = c.getMethods();

        

        for(Method method : methods){

            boolean b = method.isAnnotationPresent(Annotation02.class);

//          System.out.println(method.getName());

            if(b){

                System.out.println(method.getName());

//              获取方法上注解的实例

Annotation02 anno = (Annotation02) method.getAnnotation(Annotation02.class);

//              输出注解中携带的信息

                System.out.println(anno.name());

            }

        }

反射获取成员方法

       Class类中方法

            Method[] getMethods()  获取所有公共方法

            Method getMethod(String name, Class<?>... parameterTypes)  获取指定方法名的公共方法

                                       name 方法名

                                       Class<?>... parameterTypes 可变参 方法需要的参数类型 如果不写为空参方法

       Method类中方法

            Object invoke(Object obj, Object... args)   对带有指定参数的指定对象调用由此 Method 所表示的方法

                                 obj 要运行哪个对象的方法

                                 args 方法的实际参数

       1.获取字节码文件对象

       2.通过字节码文件对象获取方法对象

       3.调用invoke方法运行当前方法 注意 需要给定一个对象 可以通过快捷方式反射创建

Method setMethod = c.getMethod("setName", String.class);

        setMethod.invoke(obj, "Jim");

      

        Method setMethod2 = c.getMethod("setAge", int.class);

        setMethod2.invoke(obj, 18);

Object obj = c.newInstance();

      

        FileReader fr = new FileReader("prop.properties");

        Properties p = new Properties();

        p.load(fr);

      

        Set<String> keys = p.stringPropertyNames();

        for(String key : keys){

            String methodName = "set" + key.substring(0, 1).toUpperCase() + key.substring(1);

            Method setMethod = c.getMethod(methodName, String.class);

            setMethod.invoke(obj, p.getProperty(key));

        }

定义一个类 类具备 私有成员变量  空参数构造方法 get/set方法 //实现Serializable接口 我们称这样的类叫做 JavaBean

获取字节码文件对象

   1.Object类中的方法  

        Class getClass() 获取字节码文件对象

   2.每种数据类型 都有一个静态的class属性 包括基本数据类型

   3.Class类的静态方法

       staticClass forName(String className)

Person p = new Person();

        Classc = p.getClass();

        

        Classc2 = Person.class;

        

        Class c3 = Class.forName("com.itheima.bean.Person");

反射获取构造方法

        Class类中方法

           Constructor<?>[]getConstructors()  返回当前字节码文件对象的所有public修饰的构造方法

           Constructor<T>getConstructor(Class<?>... parameterTypes) 返回指定了参数的构造方法

           参数

              Constructor 用来描述构造方法的类  返回回来的就是Constructor的对象

              Class<?>...parameterTypes 可变参数  是构造方法参数类型 如果参数不写 则返回空参构造方法

       Constructor

            T newInstance(Object... initargs)  运行构造方法创建对象

                             返回值T 是泛型 没有泛型就是Object类型

                             参数 为构造方法要使用的实际参数  参数不写则运行的是空参构造方法

Constructor con = c.getConstructor();

        Objectobj= con.newInstance();

        

        Constructorcon2 = c.getConstructor(String.class,int.class);

        Objectobj2= con2.newInstance("Lily",18);

//      getDeclaredConstructor获取私有构造函数

        Constructorcon3 = c.getDeclaredConstructor(String.class);

//      允许暴力访问

        con3.setAccessible(true);

        Objectobj3= con3.newInstance("Jim");

反射获取成员变量(因为成员变量都是私有的，所以用的很少)(了解)

       Class类中方法

            FieldgetField(String name)   返回指定变量名的成员变量

            Field[] getFields()  返回所有public修饰的成员变量

       Field类中的方法

            void set(Objectobj, Object value) 为指定对象的成员变量赋值  obj为要赋值的对象 value为要赋的值

       1.获取字节码文件对象

       2.通过字节码文件对象获取字段对象

       3.调用set方法为字段赋值 注意 需要给定一个对象 可以通过快捷方式反射创建

Field[] fields = c.getDeclaredFields();

        for(Field field : fields){

            System.out.println(field);

        }

//      获取私有字段

        FieldnameField = c.getDeclaredField("name");

        FieldageField = c.getDeclaredField("age");

//      允许暴力访问

        nameField.setAccessible(true);

        ageField.setAccessible(true);

//      设置字段值

        nameField.set(obj, "Tom");

        ageField.set(obj, 18);

//      获取字段值

        System.out.println(nameField.get(obj));

        System.out.println(ageField.get(obj));

//      System.out.println(obj);

文件上传多线程版本, 服务器端

ServerSocket server = new ServerSocket(8888);

        final Socket client = server.accept();

        while(true){

            new Thread(){

                public void run(){

                    InputStream in = null;

                    BufferedOutputStream bos = null;

                    OutputStream out = null;

                    try {

                        in = client.getInputStream();

                        String fileName = "com.itheima"+System.currentTimeMillis()+new Random().nextInt(9999)+".txt";

                        bos = new BufferedOutputStream(new FileOutputStream(new File("e:\\project",fileName)));

                        byte[] buf = new byte[1024];

                        int len = -1;

                        while((len = in.read(buf)) != -1){

                            bos.write(buf, 0, len);

                        }

                        out = client.getOutputStream();

                        out.write("接收ok".getBytes());

                    } catch (IOException e) {

                        e.printStackTrace();

                    }finally{

                        try {

                            if(out != null){

                                out.close();

                            }

                        } catch (IOException e) {

                            e.printStackTrace();

                        }

                        try {

                            if(bos != null){

                                bos.close();

                            }

                        } catch (IOException e) {

                            e.printStackTrace();

                        }

                        try {

                            if(in != null){

                                in.close();

                            }

                        } catch (IOException e) {

                            e.printStackTrace();

                        }

                        try {

                            if(client != null){

                                client.close();

                            }

                        } catch (IOException e) {

                            e.printStackTrace();

                        }

                    }

                }

            }.start();

        }

TCP的服务端

      服务端  java.net.ServerSocket

               ServerSocket(int port) 创建服务端对象

    方法

              Socket accept() 获取连接服务端的Socket对象

   

   1.创建ServerSocket对象

   2.调用accept获取连接服务端的客户端对象

   3.调用Socket的获取字节输入流的方法接收你好

   4.调用Socket的获取字节输出流的方法发送不好

5.关闭资源

ServerSocket server= newServerSocket(8888);

        Socketclient = server.accept();

        

        InputStreamin = client.getInputStream();

//在服务器创建新的文件名

        String fileName ="com.itheima" + System.currentTimeMillis() + newRandom().nextInt(9999)+".txt";

        BufferedOutputStreambos = new BufferedOutputStream(new FileOutputStream(new File("e:\\project",fileName)));

        byte[] buf = new byte[1024];

        int len = -1;

   

        while((len = in.read(buf)) != -1){

            bos.write(buf, 0, len);

        }

        //接收完成后给客户端发送提示

        OutputStreamout = client.getOutputStream();

        out.write("接收完毕".getBytes());

        

        out.close();

        bos.close();

        in.close();

        client.close();

TCP客户端

   客户端  java.net.Socket

     构造方法

                 Socket(InetAddress address, int port)

                 Socket(String host, int port)  创建客户端对象 绑定服务端ip地址及端口号

   方法

                InputStream getInputStream() 获取输入流

                OutputStream getOutputStream() 获取输出流

   

   

   1.创建客户端对象绑定服务端的ip和端口

   2.获取输出流 输出"你好"

   3.获取输入流 用来接收服务端发送的"不好"

   4.关闭资源

Socket client= newSocket("127.0.0.1",8888);

        

        OutputStreamout = client.getOutputStream();

        BufferedInputStreambis = new BufferedInputStream(new FileInputStream("e:\\project\\socket.txt"));

        

        byte[] buf = new byte[1024];

        int len = -1;

        

        while((len = bis.read(buf)) != -1){

            out.write(buf, 0, len);

        }

        //告知服务器发送完毕 必须有

        client.shutdownOutput();

        //接收服务端的提示

        InputStreamin = client.getInputStream();

        len = in.read(buf);

        System.out.println("接收到的data"+new String(buf,0,len));

        

        in.close();

        bis.close();

        

        out.close();

    client.close();

java.net.InetAddress IP地址

   静态方法(创建对象)

               static InetAddress getLocalHost() 返回本地主机

               static InetAddress getByName(Stringhost) 返回指定主机的IP对象  IP地址  主机名 网址

  

   方法

                String getHostName() 返回当前IP下的主机名

                String getHostAddress() 返回当前IP下的字符串IP

InetAddress address = InetAddress.getLocalHost();//tom-PC/192.168.107.56

       StringhostName = address.getHostName(); //tom-PC

       StringhostAddress = address.getHostAddress();//192.168.107.56

      

       InetAddress address2 = InetAddress.getByName("tom-pc");//tom-PC/192.168.107.56

       InetAddress address3 = InetAddress.getByName("127.0.0.1");///127.0.0.1

       InetAddress address4 = InetAddress.getByName("www.baidu.com");//www.baidu.com/119.75.218.70

UDP协议发送端

     发送端套接字  java.net.DatagramSocket

               构造方法

                                 DatagramSocket()  创建发送端对象

               方法

                                  void send(DatagramPacket p) 发送数据包

     发送端的数据包 java.net.DatagramPacket

               构造方法

                                 DatagramPacket(byte[]buf, int length, InetAddress address, int port)

length不能超过字节数组的长度  一般设置为buff.length

                                 创建数据包对象 封装数据  接收端地址 及端口号

   1.创建发送端对象DatagramSocket

   2.准备数据

   3.创建数据包的对象封装 封装数据  接收端地址 及端口号

   4.调用DatagramSocket的send方法发送数据包DatagramPacket

   5.关闭资源

        DatagramSocket ds = new DatagramSocket();

        

        byte[] buf = "你好".getBytes();

        DatagramPacketdp = new DatagramPacket(buf,buf.length, InetAddress.getLocalHost(), 6666);

        

        ds.send(dp);

        ds.close();

UDP的接收端

      接收端套接字  java.net.DatagramSocket

               构造方法

                          DatagramSocket(int port)创建接收端对象

               方法

                          void receive(DatagramPacket p) 接收数据包

       接收端数据包java.net.DatagramPacket

               构造方法

                        DatagramPacket(byte[] buf,int length) 接收长度为length的数据包

   1.创建接收端对象

   2.创建DatagramPacket接收端数据包的对象

   3.调用DatagramSocket的receive接收数据包

   4.拆包

               DatagramPacket

                         int getLength() 获取长度

                         int getPort() 获取端口

                        InetAddress getAddress() 获取ip

   5.关闭资源

DatagramSocket ds= newDatagramSocket(6666);

        //接收数据包最大为64k

        byte[] buf = new byte[1024*64];

        DatagramPacketdp = new DatagramPacket(buf, buf.length);

        ds.receive(dp);

        InetAddressaddress= dp.getAddress();

        //获取接收数据的真实长度

        int len = dp.getLength();

        buf = dp.getData();

        System.out.println(new String(buf,0,len));

        

        ds.close();

解决线程的安全隐患的方式采取同步的方式

   同步代码块

      synchronized(任意对象){

               可能会出现问题的代码块

      }

         public void run() {

        while(true){

            synchronized (this) {

                if(i>0){

                    try {

                        Thread.sleep(10);

                    }catch(InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");

                    i--;

                }

               

            }

            

        }

    }

   同步方法

         public static synchronized void sell(){

//      synchronized(SubThread.class) {

            if(i>0){

                try {

                    Thread.sleep(10);

                }catch(InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");

                i--;

            }

//      }

    }

解决线程的安全隐患的方式 采取同步的方式

   同步代码块

      synchronized(任意对象){

               可能会出现问题的代码块

      }

   同步方法

     在方法的声明上加入关键字synchronized

     同步方法有锁吗？ 有 锁是谁？ this

     同步方法可以是静态的吗？ 可以  静态的同步方法锁还是this吗？ 绝对不是

    那是谁？ 类名.class

     

    效率和安全

    线程 安全 效率低

    线程不安全 效率高

JDK1.5

   使用Lock接口来解决线程安全问题

   

   java.util.concurrent.locks.Lock 接口

   实现类ReentrantLock

                void lock() 获取锁

                void unlock() 释放锁

int i = 100; //100张票

    Lock l = new ReentrantLock();

    @Override

    public void run() {

        while(true){

                l.lock();

                if(i>0){

                    try {

                        Thread.sleep(10);

                        System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");

                        i--;

                    }catch(InterruptedException e) {

                        e.printStackTrace();

                    }finally {

                        l.unlock();

                    }   

                }

            }

    }