首先：这段代码能正确执行！

public class ReadIn {

    public static void main(String[] args) throws Exception {
        InputStream in=System.in;
        StringBuilder sb=new StringBuilder();
        while(true){
            int ch=in.read();      //为什么此处能调用abstract read(),
            if(ch=='\r')
                continue;
            if(ch=='\n'){
                String s=sb.toString();
                if("over".equals(s))
                    break;
                System.out.println(s.toUpperCase());
                sb.delete(0, sb.length());
            }
            else
                sb.append((char)ch);
        }
    }
}

Animal  al=new Cat();
al.speak();

你说这个speak是Animal还是Cat的，显然是Cat的，Cat类对speak进行重写。这个不是一个道理么？System.in重写read

InputStream in=System.in;抽象类InputStream是不能实例化，但并不是不能定义对象啊！只要不new就行了，你看下System.in的原型。
static InputStream        in
          “标准”输入流。在System类中是一个静态的InputStream对象。此对象已实现read，从控制台读取，直接将对象指向InputStream in的in是没问题的。

邓士林 发表于 2015-2-2 12:26
InputStream in=System.in;抽象类InputStream是不能实例化，但并不是不能定义对象啊！只要不new就行了，你 ...

抽象类可以创建对象，这个没有问题，问题是，在创建了其对象后，通过其对象调用的 无参Read()方法，应该是InputStream这个类中的 无参Read()方法吧？因为此处创建的不是子类对象，不可能调用子类方法。
而InputStream中的方法是abstract的。根本没有方法体啊！！！

楼上回答的很形象！！！

这是多态的向上转型，成员方法中，子类重写父类的方法

InputStream in = System.in;InputStream是抽象类，但是System不是抽象类，这里的指向的是System类的in方法所生成的InputStream类型的对象，下面的in.read();就可以当做是InputStream的子类重写了父类的read方法。

邓士林 发表于 2015-2-2 14:51
Animal  al=new Cat();
al.speak();

这里的 al 父类引用指向的是子类Cat对象，在运行期调用子类重写后的speak方法。这里Cat是一个类，这当然没有问题！
但我想知道的是：InputStream in=System.in;这里的父类引用具体指向的是InputStream的哪一个子类对象？

邓士林 发表于 2015-2-2 14:51
Animal  al=new Cat();
al.speak();

这里的 al 父类引用指向的是子类Cat对象，在运行期调用子类重写后的speak方法。这里Cat是一个类，这当然没有问题！
但我想知道的是：InputStream in=System.in;这里的父类引用具体指向的是InputStream的哪一个子类对象？

邓士林 发表于 2015-2-2 14:51
Animal  al=new Cat();
al.speak();

这里的 al 父类引用指向的是子类Cat对象，在运行期调用子类重写后的speak方法。这里Cat是一个类，这当然没有问题！
但我想知道的是：InputStream in=System.in;这里的父类引用具体指向的是InputStream的哪一个子类对象？

这里是InputStream的所有子类。AudioInputStream, ByteArrayInputStream, FileInputStream, FilterInputStream, InputStream, ObjectInputStream, PipedInputStream, SequenceInputStream, StringBufferInputStream 。
InputStream in=System.in;这里的父类引用具体指向的是InputStream的哪一个子类对象？

liuhaozzu 发表于 2015-2-3 10:25
这里的 al 父类引用指向的是子类Cat对象，在运行期调用子类重写后的speak方法。这里Cat是一个类，这当然 ...

给你个文章看，自己学会看源码行么？我也是看源码。
http://www.cnblogs.com/chenfei0801/archive/2013/03/28/2987899.html，这哥们说的挺好，你看懂了就明白了。

邓士林 发表于 2015-2-3 10:29
给你个文章看，自己学会看源码行么？我也是看源码。
http://www.cnblogs.com/chenfei0801/archive/2013/0 ...

谢谢！
jdk8源码中返回的是null，太复杂了！先放放吧！

liuhaozzu 发表于 2015-2-3 11:12
谢谢！
jdk8源码中返回的是null，太复杂了！先放放吧！

给黑马币啊！哥们

可以用这段代码测试：
import java.io.InputStream;

public class UDPDemo {

        public static void main(String[] args) {
                InputStream in=System.in;
                System.out.println(in.getClass());
        }
}
System.in默认返回的是BufferedInputStream对象。

多谢啦，多看看源码就好理解了

System类声明了in：public final static InputStream in = null;
但是下面又有初始化，在private static void initializeSystemClass()中：setIn0(new BufferedInputStream(fdIn));

所以实际指向的是BufferInputStream，实际调试也是这样。
System.out.println(System.in); //java.io.BufferedInputStream@40671416


求分

我居然差不多都看不懂，只能说明一点，这不是IOS

搞清楚一点就行了，即System.in ：是System中的一个InputStream类型的静态变量，再参照上面有个朋友举得
Animal   al  =  new Cat();的例子，抽象方法自然是不能直接调用的，必须由其子类重写，你的代码中的in不是调用了抽象方法，而是调用了InputStream的子类中的read方法。你可以试试打印System.in看它是什么类型，然后看一看System类中的静态变量in实现的源码。

in 是java.lang.System的一个静态成员(static)，这里的in是一个InputStream子实现类的实体，因此in拥有InputStream的方法。

同理System.out 和 System.err，JVM启动的时候通过Java运行时初始化这3个流，所以你不需要初始化它们。

查看System.in的声明：

1. public final class System {
   
2. .....
   
3.     /**
   
4.      * The "standard" input stream. This stream is already
   
5.      * open and ready to supply input data. Typically this stream
   
6.      * corresponds to keyboard input or another input source specified by
   
7.      * the host environment or user.
   
8.      */
   
9.   public final static InputStream in = null;
   
10. .....
    
11. 
    
12.   /**
    
13.      * Reassigns the "standard" input stream.
    
14.      *
    
15.      * <p>First, if there is a security manager, its <code>checkPermission</code>
    
16.      * method is called with a <code>RuntimePermission("setIO")</code> permission
    
17.      *  to see if it's ok to reassign the "standard" input stream.
    
18.      * <p>
    
19.      *
    
20.      * @param in the new standard input stream.
    
21.      *
    
22.      * @throws SecurityException
    
23.      *        if a security manager exists and its
    
24.      *        <code>checkPermission</code> method doesn't allow
    
25.      *        reassigning of the standard input stream.
    
26.      *
    
27.      * @see SecurityManager#checkPermission
    
28.      * @see java.lang.RuntimePermission
    
29.      *
    
30.      * @since   JDK1.1
    
31.      */
    
32.     public static void setIn(InputStream in) {
    
33.         checkIO();
    
34.         setIn0(in);
    
35.     }
    
36. //......
    
37. }

复制代码

System.in 在JDK1.0的时候其实不是final的，通过对覆盖in来达到输入重定向，从JDK1.1开始改为final，提供的setIn方法来重定向输入流。

如果setIn是重定向System.in，并非对System.in初始化，那么问题来了
——System.in是如何初始化的？
实际上System.in是在JVM启动时，通过native方法初始化的。在java.lang.System开头其实有这么一段代码：

1. public final class System {
   
2. 
   
3.     /* register the natives via the static initializer.
   
4.      *
   
5.      * VM will invoke the initializeSystemClass method to complete
   
6.      * the initialization for this class separated from clinit.
   
7.      * Note that to use properties set by the VM, see the constraints
   
8.      * described in the initializeSystemClass method.
   
9.      */
   
10.     private static native void registerNatives();
    
11.     static {
    
12.         registerNatives();
    
13.     }
    
14. //......
    
15. }

复制代码

这里的注释说明了VM会通过调用initializeSystemClass方法来完成类的初始化。我们再看看这个方法：

1. 
   
2. /**
   
3.      * Initialize the system class.  Called after thread initialization.
   
4.      */
   
5.     private static void initializeSystemClass() {
   
6. 
   
7.         // VM might invoke JNU_NewStringPlatform() to set those encoding
   
8.         // sensitive properties (user.home, user.name, boot.class.path, etc.)
   
9.         // during "props" initialization, in which it may need access, via
   
10.         // System.getProperty(), to the related system encoding property that
    
11.         // have been initialized (put into "props") at early stage of the
    
12.         // initialization. So make sure the "props" is available at the
    
13.         // very beginning of the initialization and all system properties to
    
14.         // be put into it directly.
    
15.         props = new Properties();
    
16.         initProperties(props);  // initialized by the VM
    
17. 
    
18.         // There are certain system configurations that may be controlled by
    
19.         // VM options such as the maximum amount of direct memory and
    
20.         // Integer cache size used to support the object identity semantics
    
21.         // of autoboxing.  Typically, the library will obtain these values
    
22.         // from the properties set by the VM.  If the properties are for
    
23.         // internal implementation use only, these properties should be
    
24.         // removed from the system properties.
    
25.         //
    
26.         // See java.lang.Integer.IntegerCache and the
    
27.         // sun.misc.VM.saveAndRemoveProperties method for example.
    
28.         //
    
29.         // Save a private copy of the system properties object that
    
30.         // can only be accessed by the internal implementation.  Remove
    
31.         // certain system properties that are not intended for public access.
    
32.         sun.misc.VM.saveAndRemoveProperties(props);
    
33. 
    
34. 
    
35.         lineSeparator = props.getProperty("line.separator");
    
36.         sun.misc.Version.init();
    
37. 
    
38.         FileInputStream fdIn = new FileInputStream(FileDescriptor.in);
    
39.         FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out);
    
40.         FileOutputStream fdErr = new FileOutputStream(FileDescriptor.err);
    
41.         setIn0(new BufferedInputStream(fdIn));
    
42.         setOut0(new PrintStream(new BufferedOutputStream(fdOut, 128), true));
    
43.         setErr0(new PrintStream(new BufferedOutputStream(fdErr, 128), true));
    
44.         // Load the zip library now in order to keep java.util.zip.ZipFile
    
45.         // from trying to use itself to load this library later.
    
46.         loadLibrary("zip");
    
47. 
    
48.         // Setup Java signal handlers for HUP, TERM, and INT (where available).
    
49.         Terminator.setup();
    
50. 
    
51.         // Initialize any miscellenous operating system settings that need to be
    
52.         // set for the class libraries. Currently this is no-op everywhere except
    
53.         // for Windows where the process-wide error mode is set before the java.io
    
54.         // classes are used.
    
55.         sun.misc.VM.initializeOSEnvironment();
    
56. 
    
57.         // The main thread is not added to its thread group in the same
    
58.         // way as other threads; we must do it ourselves here.
    
59.         Thread current = Thread.currentThread();
    
60.         current.getThreadGroup().add(current);
    
61. 
    
62.         // register shared secrets
    
63.         setJavaLangAccess();
    
64. 
    
65.         // Subsystems that are invoked during initialization can invoke
    
66.         // sun.misc.VM.isBooted() in order to avoid doing things that should
    
67.         // wait until the application class loader has been set up.
    
68.         // IMPORTANT: Ensure that this remains the last initialization action!
    
69.         sun.misc.VM.booted();
    
70.     }

复制代码

JVM会判断当前操作系统，并决定对应的初始化方法。同一JVM命令和不同OS的API的对照关系是不同的。

总结一下：
in的初始化是由JVM启动时完成的，根据当前操作系统封装了对应OS的标准输入的系统调用。
in的具体实现类也是Native的，而in.read()，其实是JVM调用了OS提供的获取键盘输入的API。

InputStream in=System.in;相当于父类引用指向了子类对象，in.read()；实际执行的是已经复写的方法