你需要注意的Java小细节

1.调用静态常量不会引起初始化(调用初始化代码块)。但是要调用类的静态方法当然会初始化类了

class Test{
    static{
                  System.out.println("初始化");
     }
        public  final static  String  str="ddd";
}
public class Main {
public static void main(String[] args) {
System.out.println(Test.str);
}
}

输出ddd。

2.关于静态代理与动态代理

public class ProxyTest {

    public static void main(String[] args){

            Class clazz = Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
           System.out.println(clazz);
           System.out.println(Person.class);
    }

}
public interface Person {
    public   void  sayHello();
}

输出:

class com.sun.proxy.$Proxy0 interface main.Person

为什么需要一个classloader,就是因为class是动态生成的。这个class就是代理对象。(也就是被扩展了的Person对象。Person是一个接口) Java中的代理与OC中的委托基本类似。但是区别不同的是,JAVA中的代理对象包裹着被代理的对象(得到的是被扩展的Person对象) 。而OC中代理对象是作为被代理对象的一个属性。(个人觉得,OC中的代理更能体现面向对象编程,尤其是对多态的理解。)

也就是说,java中的代理最终获得的是代理对象(虽然是Person接口,但是不是我们自己处理逻辑的的那个实现对象),而在OC中获得的是原对象。

Class proxyClass= Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
         InvocationHandler handler = new MyInvocationHandler();
         Person f = (Person) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
         System.out.println(f);

proxyClass的getConstructor得到的是代理类的构造器对象,而不是person的构造器对象。

使用代理可以根据接口动态的生成对象,所谓的动态代理就是根据接口动态生成代理对象而已。

public class ProxyTest {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{

            Class proxyClass= Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
         InvocationHandler handler = new MyInvocationHandler();
       Person  person= (Person) proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
      person.sayHello();  
    }
}
public class MyInvocationHandler  implements  InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("我被调用了!");
        return null;
    }
}

调用这个动态生成对象(扩展了的Person对象)的任何方法都将调用invoke方法。

动态代理:

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{
             Class proxyClass= Proxy.getProxyClass(Person.class.getClassLoader(), Person.class);
             MyInvocationHandler handler = new MyInvocationHandler();
             //person是一个接口。我们自己的处理逻辑还需要实现:
             handler.setTarget(new PersonImpl());
//person是加入了InvocationHandler的person:
             Person  person= (Person )proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
             person.sayHello("Jetty"); 
    }
public class MyInvocationHandler implements InvocationHandler {
    private Person person;
    public void setTarget(Person target) {
        this.person = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        new Before().before();
         method.invoke(person, args[0]);//自己的逻辑调用。成员变量person
        return null;
    }
}
public class Before {
    public    void    before(){
        System.out.println("before");
    }
}

可以看出,java中的动态代理体现了java中最重要的一点:面向接口编程。这样生成的代理类也是一个Person对象。

这些都是一些小问题,但是有助于理解输入输出流。

InputStreamReader 中的一个 read()是每次只会从磁盘里面读取一个字节。它会非常频繁的访问磁盘。(想一想,每次只从磁盘读一个字节) InputStreamReader 是字节流通向字符流的桥梁:它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定,或者可以接受平台默认的字符集。

每次调用 InputStreamReader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换,可以提前从底层流读取更多的字节,使其超过满足当前读取操作所需的字节。

为了达到最高效率,可要考虑在 BufferedReader 内包装 InputStreamReader。例如:

 BufferedReader in
   = new BufferedReader(new InputStreamReader
import java.io.*;
import java.io.DataInputStream;
public  class   Main{
    public static void main(String[] args) throws  Exception {

      BufferedReader   reader= new BufferedReader(new InputStreamReader(new FileInputStream(new File("text.txt"))));

String line=null;
 while((line=reader.readLine())!=null){
     String[]  s=line.split("\\s+");

     for ( String single:s ) {
           System.out.println(single);
     }

 }
    }
}                  

(System.in)); \s匹配任意的空白符,包括空格,制表符(Tab),换行符,中文全角空格

Java的重定向JAVA支持标准的输出输入重定向。

public  class   Main{
    public static void main(String[] args) throws  Exception {

       System.out.println("Hello World!");

    }
}    

编译以后,直接使用java Main >test.txt进行输出重定向

使用输入重定向:

public  class   Main{
    public static void main(String[] args) throws  Exception {
         Scanner sc=new Scanner(System.in);  
        while(sc.hasNextLine())  
        {  
            System.out.println(sc.nextLine());  
        }  
    }
}
java  Main<text.txt;