从File类到操作系统

public class File implements Serializable, Comparable<File>

private static final FileSystem fs = DefaultFileSystem.getFileSystem();
public int compareTo(File pathname) {
    return fs.compare(this, pathname);
}

//fs  FileSystem
public int compare(File f1, File f2) {
    return f1.getPath().compareTo(f2.getPath());
}

/**
 * The FileSystem object representing the platform's local file system.
 * 这个是static所以是一个单例
 */
private static final FileSystem fs = DefaultFileSystem.getFileSystem();

private File(String child, File parent)
private File(String pathname, int prefixLength)
public File(String pathname)
public File(String parent, String child)
public File(File parent, String child)
public File(URI uri)

public File(String pathname) {
    if (pathname == null) {
        throw new NullPointerException();
    }
  //normalize就是一个字符串的处理过程把/aaa//bbb///ccc/ 都变成/aaa/bbb/ccc
    this.path = fs.normalize(pathname);
  //prefixLength查看path的第一个字符是不是‘/’是的话返回1，不然返回0
    this.prefixLength = fs.prefixLength(this.path);
}
public File(String parent, String child) {
    if (child == null) {
        throw new NullPointerException();
    }
    if (parent != null) {
        if (parent.equals("")) {
          //大家可以理解成parent和child拼接，不过他会处理多余和缺少/的情况，还有空字符串
          //getDefaultParent返回常量“/”
          //用户传入的路径都要经过normalize处理后才能使用
            this.path = fs.resolve(fs.getDefaultParent(),
                                    fs.normalize(child));
        } else {
          //和上面一样
            this.path = fs.resolve(fs.normalize(parent),
                                    fs.normalize(child));
        }
      //这里可以看出如果parent是null或者“”的时候和File(String pathname)逻辑一样
    } else {//如果parent是null和File(String pathname)逻辑一样
        this.path = fs.normalize(child);
    }
    this.prefixLength = fs.prefixLength(this.path);
}
//这个就不说了其实就是把String的parent换成File.path
public File(File parent, String child)

public File(URI uri) {
    // Check our many preconditions
  // 一堆校验大家自己看看就好
    if (!uri.isAbsolute())
        throw new IllegalArgumentException("URI is not absolute");
    if (uri.isOpaque())
        throw new IllegalArgumentException("URI is not hierarchical");
    String scheme = uri.getScheme();
    if ((scheme == null) || !scheme.equalsIgnoreCase("file"))
        throw new IllegalArgumentException("URI scheme is not \"file\"");
    if (uri.getRawAuthority() != null)
        throw new IllegalArgumentException("URI has an authority component");
    if (uri.getRawFragment() != null)
        throw new IllegalArgumentException("URI has a fragment component");
    if (uri.getRawQuery() != null)
        throw new IllegalArgumentException("URI has a query component");
    String p = uri.getPath();
    if (p.equals(""))
        throw new IllegalArgumentException("URI path component is empty");

    // Okay, now initialize
    // fromURIPath复制一下源码的注释很好懂  "/foo/" --> "/foo", but "/" --> "/"
    p = fs.fromURIPath(p);
  // separatorChar下面马上说
    if (File.separatorChar != '/')
        p = p.replace('/', File.separatorChar);
  //这两行之前说过
    this.path = fs.normalize(p);
    this.prefixLength = fs.prefixLength(this.path);
}
//对于内部可信任的调用避免使用normalize
private File(String pathname, int prefixLength) {
    this.path = pathname;
    this.prefixLength = prefixLength;
}
//对于内部可信任的调用避免使用normalize
private File(String child, File parent) {
  //不知道assert的同学赶紧赶紧去查查把，主要是调试用的
    assert parent.path != null;
    assert (!parent.path.equals(""));
    this.path = fs.resolve(parent.path, child);
    this.prefixLength = parent.prefixLength;
}

//这两个字段具体在什么地方会用后面再说
    /**
     * This abstract pathname's normalized pathname string. A normalized
     * pathname string uses the default name-separator character and does not
     * contain any duplicate or redundant separators.
     *
     * @serial
     */
    private final String path;
    /**
     * The length of this abstract pathname's prefix, or zero if it has no
     * prefix.
     */
//第二个生僻关键字transient这个是与Serializable接口相关的
    private final transient int prefixLength;

/**
 * The system-dependent default name-separator character.  This field is
 * initialized to contain the first character of the value of the system
 * property <code>file.separator</code>.  On UNIX systems the value of this
 * field is <code>'/'</code>; on Microsoft Windows systems it is <code>'\\'</code>.
 *
 * @see     java.lang.System#getProperty(java.lang.String)
 */
//getSeparator返回一个slash变量这变量是UnixFileSystem的构造方法里面设置的
//刚刚说过UnixFileSystem是一个单例，所以在第一次调用File的时候就会设置slash变量
//Properties props = GetPropertyAction.privilegedGetProperties();最终是System.getProperties()
//slash = props.getProperty("file.separator").charAt(0);Unix都是‘/’
public static final char separatorChar = fs.getSeparator();

/**
 * The system-dependent default name-separator character, represented as a
 * string for convenience.  This string contains a single character, namely
 * {@link #separatorChar}.
 */
//char转化String
public static final String separator = "" + separatorChar;

// aa -> aa        /ds/aa -> aa      / -> ""
public String getName() {
    int index = path.lastIndexOf(separatorChar);
    if (index < prefixLength) return path.substring(prefixLength);
    return path.substring(index + 1);
}

public String getParent() {
    int index = path.lastIndexOf(separatorChar);
    if (index < prefixLength) {
        if ((prefixLength > 0) && (path.length() > prefixLength))
            return path.substring(0, prefixLength);
        return null;
    }
    return path.substring(0, index);
}

public boolean isAbsolute() {
    return fs.isAbsolute(this);
}
//UnixFileSystem类中 PrefixLength>0 说明是/开头就是绝对路径
public boolean isAbsolute(File f) {
    return (f.getPrefixLength() != 0);
}

//先处理字符串然后调用之前说过的私有构造方法
public File getParentFile() {
    String p = this.getParent();
    if (p == null) return null;
  //这里就是使用了私有构造方法
    return new File(p, this.prefixLength);
}

public boolean setReadOnly() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
        security.checkWrite(path);
    }
    if (isInvalid()) {
        return false;
    }
    return fs.setReadOnly(this);
}
public boolean delete() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
        security.checkDelete(path);
    }
    if (isInvalid()) {
        return false;
    }
    return fs.delete(this);
}