Java知识点

1.在Java的内存模型中虚拟机栈和本地方法去以及程序计数器都是线程隔离的，而方法去和堆是线程共享的。

2.在Java8中，接口里新增了default方法，目的是为了向前兼容。也就是说接口中不一定全都是抽象方法了。

// 1. 在java中有三种注释，这三种注释分别是 单行注释和多行注释以及文档注释
    //  //单行注释      /* 多行注释 */   /** 文档注释   */ 提取文档注释的方法是使用javadoc指令
    /* 2.标识符与关键字
     * java的分隔符符有 分号; 花括号{} 方括号[] 圆括号() 空格space 圆点.
     * java的标识符必须以字母,下划线，美元符号开头，后面可以跟任意的数字，字母，下划线和美元符号。
     * java关键字，java的标识符是不能使用关键字的，java中有三个特殊的直接量，分别是 true false null 这三个直接量不是关键字
     * 但也不能作为java的标识符。
     * 3.java语言支持两种java数据类型的分类，分别是基本类型(primitive Type)和引用类型(reference Type)。
     * java基本数据类型:有8个基本的数据类型，整型:byte(1字节) short(2个字节) int(4个字节) long(8字节) 浮点型:float(4字节)
     * double(8字节) 字符类型:char(2字节) 布尔类型:boolean，基本类型在运算的过程中整型默认是int类型，而浮点类型默认的double类型。
     * 4.java数值的表示有二进制，八进制，十进制，和十六进制。其中二进制以0B/0b开头，八进制以0开头，十六进制以0X/0x开头
     * 5.java浮点类型(float,double)提供了正无穷大POSITIVE_INFINITY和负无穷大NEGATIVE_INFINITY以及菲数NaN
     * 6.java的浮点类型的精度是有限的，如果需要精确保留数值的话，那么可以使用BigDecimal类
     * 7.只有浮点数除以0才会得到正无穷大货负无穷大的数，如果是整数除以0那么会抛出异常ArithmeticException /by Zero(除零异常)
     * 8.java基本类型的类型转换               char->
     *                                       int->long->float->double
     *                         byte->short->
     * 9.java中的逻辑运算符  &&,逻辑与运算，也叫短路运算  &也是逻辑与运算，但是不会短路   ||，逻辑或运算，短路，|逻辑或运算，但是不会短路
     */

/*
     * 1.数据:java数组也是一种类型，数组要求所有的元素必须是同一数据类型。java语言是面型对象的语言，因此有存在继承的关系类，那么在
     * 数组中是可以出现这个元素的子类的。例如一个数组中的元素是水果类，那么这个数组的存放的元素可是梨子，苹果，因为他们都是水果类。
     *  -数组元素的基本类型中的整数类型(byte,short,int,long)的默认值是0
     *  -数组元素的基本类型中的浮点类型(float,double)的默认值是0.0
     *  -数组元素的基本类型中的字符类型(char)的默认值是 '\u0000'
     *  -数组元素的基本类型中的布尔类型(boolean)的默认值是 null
     *  数组的索引越界异常:ArrayIndexOutOfBoundsException
     * 2.java8的增强类工具Arrays，该类里面含有一些静态的的方法
     *     -int binarySearch(type[] a, type key) 通过二分查找key所在的位置
     *  -type copyOf(type[] original, int length):这个方法吧数组复制成一个新的数组
     *  -type copyOfRange(type[] original, int from, int to)这个方法与前面的那个方法类似，只是复制从from到to的元素
     *  -void fill(type[] , val); 把数组中的所有元素之赋值为val
     *  -sort(type []); 对数组进行排序
     *
     */

/*
     * 1.java面向对象的三大特征:封装，继承，多态。
     * 2.构造器用于对类实例进行初始化操作，构造器支持重载。如果多个构造器包含了相同的初始化代码，
     * 则可以把这些代码放在普通的初始化代码块里面进行，初始化代码块总在构造器被调用之前被调用。
     * java在对类进行初始化时候，如果发现其父类没有被初始化， 那么会将继承树种的所有父类进行初始化。
     * 3.堆中的对象如果没有任何引用指向的话，那么就成了垃圾对象，java的垃圾回收器就会回收该对象。
     * 如果希望通知垃圾回收机制回收某个对象的话，只需要将指向该对象的引用切断，赋值为null即可。
     * 4.对象的this引用，this关键字总是指向调用该方法的对象。根据this出现位置的不同，this作为
     * 对象的默认引用有两种情形。
     *     -构造器中引用该构造器正在初始化的对象
     *  -在方法中引用调用该方法的对象
     * 5.java方法传递参数的方式只有一种，那就是值传递。
     * 6.java方法重载的要求是两同一不同，同一个类中的方法名相同，参数列表不同。至于方法的其他部分
     * 如方法的返回值类型，修饰符，与方法重载都没有任何关系。
     * 7.一个类在使用之前要进过类加载，类连接(类验证,类准备,类解析)，类初始化等几个阶段
     * 8.java局部变量:局部变量定义后，必须经过显示的初始化后才能使用，系统不会为局部变量执行初始化。
     * 这意味着定义局部变量后，系统不会立即为这个变量分配内存空间，直到等到程序为这个变量赋初始值时，系统
     * 才会为局部变量分配内存。
     * 9.封装:是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象的内部，不允许外部程序直接访问对象
     * 的内部信息，而是通过该类的所提供的方法来实现对内部信息的操作和访问。
     * 10.java中常用包
     *     -java.lang:这个包下包含了java语言核心类，包裹string thread math system
     *     -java.util:这个包下包含了java的大量工具类/借口和集合框架类/接口，例如:ArrayList,List,Set
     *     -java.net:这个包下包含了一些java网络编程的相关类/接口
     *     -java.io:这个包下包含了一些java输入/输出的编程相关类/接口
     *     -java.text:这个包下包含了一些java格式化相关的类
     *     -java.sql:这个包下包含了java进行JDBC数据库编程相关的类/接口
     * 11.重写方法是要遵守"两同两小一大"的规则,两同即方法名相同，方法参数相同。两小，重写的方法返回类型要比父类的更小或者相等
     * 重写的方法抛出的异常要比父类的小或者相等。一大指的的是子类的访问权限要跟父类的相等或者更大。
     * 12.java中进行类转换的时候，如果把父类转换成子类运行时会出现ClassCastException
     * 13.instance_of运算符，前面是一个引用类型，后面是一个类。用于判断引用类型是否为该类的子类。
     * 14.在java的初始化过程中，先初始化静态代码块或者静态变量。初始化静态资源时是一次从上往下进行初始化的，
     * 进行非静态资源初始化的时候也是从上往下依次进行初始化，也就是按顺序初始化。
     */

/*
     * 1.java提供了final关键字类修饰变量，方法和类，系统不允许为final变量重新赋值，子类不允许覆盖父类的final方法
     * final类不能派生子类。通过使用final关键字，允许java实现不可变类，不可变类会让系统更加安全。
     * 2.abstract和interface两个关键字分别用于定义抽象类和接口，抽象类和接口都是从多个子类中抽象出来的共同特征。但
     * 抽象类主要作为多个类的模版，而接口则定义了多类应该遵从的规范。
     * 3.==和equals的区别，java中提供两种方法来判断变量是否相等。一个是==另外一个是equals方法。当使用==号时，如果是
     * 基本数据类型，那么只要变量的值相等就会返回true，不要求变量的基本类型一致。当变量是引用类型的时候，那么变量的引用地址
     * 一样才会返回true。而equals方法是Object对象提供的方法，在Object兑现的equals方法中，同样是使用this == obj
     * 来判断对象是否相等。所以如果你需要判断两个对象是否相等，可以根据你的需要重写equals方法。
     * 但是重写equals方法应该满足以下几个条件:自反性，对任意的x,x.equals(x) 返回true
     * 对称性，对任意的x和y，如果x.equals(y)返回true，则y.equals(x)也返回true
     * 传递性，对任意的x和y以及z,如果x.equals(y)返回true,y.equals(z)也返回true那么，x.equals(z)也要返回true
     * 一致性，对任意的x和y,只要x和y的信息没有被改变无论调用多少次equals都会返回true
     * 对任何不适null的x,x.equals(null)一定返回false
     * 4.NullPointerException空指针异常，当尝试使用一个空对象的时候就会出现空指针异常。
     * 5.如果一个类始终只能创建一个实例，那么这个类被称为单例(Singleton),要想是一个类称为单例类，那么必须给它的构造函数
     * 用private修饰，这样外界就无法创建该类的实例，只能通过该类的内部来创建该类的实例。
     * 6.final，被该关键字修饰的类，方法，变量输赢最终类无法被派生。最终方法无法被重写，常量无法改变其值。final修饰的变量
     * 一旦获得其初始值那么就不能再赋值改变了。关于被final修饰的成员变量和类变量的制订初始值如下，如果是类变量，那么只能在
     * 声明的该变量的时候指定其初始化值，或者在静态代码块中指定其初始化值。实例变量只能在声明改变是指定其初始化值，或者在代码
     * 块中指定其值，或者在构造函数中指定其初始化值。也就是类成员只能在两个地方为其赋初始化值，而实例化变量只能在三个地方为其赋值
     * 7.抽象类和抽象方法的规则如下
     *     -抽象类必须使用abstract修饰符来修饰，抽象方法必须使用abstract修饰符来修饰，抽象方法不能有方法体
     *     -抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。即使抽象类里面不包含抽象方法。
     *     -抽象类可以包含成员变量，成员方法，构造器，初始化块，内部类。抽象类的构造器不能用于创建实例，只能用于让子类调用
     *     -含有抽象方法的类只能定义为抽象类
     * 8.java8对接口进行了改进，在1.7以前接口中只能是抽象方法，但是在1.8中可以有default方法，该方法可以有具体的方法实现。
     * 接口里可以有类方法，但是类方法必须实现方法体。默认的方法也是必须实现方法体。类方法和默认的方法都是java1.8中才出现的，类
     * 方法的默认修饰符为public
     * 9.在接口中可以有内部类，内部接口，接口里的变量全部是静态常量，方法是抽象的。接口更像是一种规范。  接口里定义的内部类，内部接口
     * 内部枚举默认都采用public static两个修饰符，不管定义时是否指定这两个修饰符，系统都会自动使用public static对他们进行修饰
     * 10.接口允许继承多个接口，接口之间用逗号分隔。接口和抽象类都不允许实例化但是允许声明引用类型，用来实现多态。
     * 11.内部类，包含内部类的类叫外部类。内部类的特点
     *     -内部类提供了更好的封装，可以把内部类隐藏在外部类之间，不允许同一个包中的其他类访问该类。
     *     -内部类成员可以访问外部类的所有私有数据，因为内部类也是外部类的成员，同一个类的成员之间可以互相访问。但是外部类不能访问内部类的
     *      的成员变量
     *     -内部类比外部类可以多使用三个修饰符:private，protected，static。这三个修饰符是不允许出现在外部类的修饰符上的。
     *     -非静态的内部类是不能拥有静态成员的
     * 12.内部类的局部变量会覆盖掉成员变量，内部类的成员变量会覆盖外部内的成员变量。访问内部内的成员变量用this，访问外部内的成员变量
     * 用OuterClass.this.XXX访问。
     * 13.Lambda表达式的作用主要就是代替匿名的内部类繁琐的语法。Lambda表达式由三部分组成，
     *     -形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可省略。
     *     -箭头  ->
     *     -代码块。如果代码块里面只有一条语句的话，那么连方括号都可以省略。如果，有返回值的只有一条语句，那么Lambda表达式会返回这条语句
     *      执行后的值。
     * 14.Lambda表达式也叫目标类型，Lambda表达式的目标类型必须是函数式接口。函数式接口表示该接口里面只能有一个抽象方法。
     * 15.Lambda表达式的结果被当成对象，因此程序中可以完全使用Lambda表达式进行赋值。
     * 16.enum枚举类，枚举类也是一个特殊的类。它可以有自己的构造函数，但是构造函数必须用private关键字修饰，如果不指定修饰符系统会
     * 默认添加上private修饰符。枚举类的实例必须定义在第一行。枚举类里面可以定义抽象方法，然后不同的实例可以根据不同的需要实现抽象
     * 方法，做不同的事。
     */

/*
     * 1.Java 运行时候的参数，在执行java指令的时候后面可以接上参数，参数会被保存在main函数的args数组里面。在传递参数的时候如果没有使用祖父穿的引用符号的话，
     * 那么参数的接受会以空格来区分多个参数，如果加上了字符串的引符号的话那么一个符号引用被算为一个参数。
     * 2.Scanner类获取键盘的输入，主要通过Scanner类的hasNext()方法判断是否还有下一个输入。同时可以使用nextXXX方法取下一个的输入。在使用Scanner类的
     * 时候需要指定读取的流，可以指定文件输入流，这样Scanner就会在相应的文件里面读取需要的数据。
     * 3.System类，代表了当前Java程序运行的平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接通过使用System类直接调用处理。
     * System类提供了代表标准输入，标准的输出和错误输出的的类变量，并提供了一些静态的方法用于方访问环境变量，系统属性的方法，还提供了加载文件和动态链接库的方法。
     * getenv(),getProperties(),getProperty()等访问程序平台的的环境变量和系统属性。还有提供了系统进行垃圾回收的GC()方法，以及通知系统进行资源清理
     * 的runFinalization()方法。出息之外还有out，err，in等对象的输入输出设置。
     * 4.Runtime类，代表了java程序运行时的环境，每个java程序都有一个与之对丁的Runtime实例。可以通过Runtime.getRuntime()来获取实例。
     * 5.ThreadLocalRandom和Random，用于随机的生成一个数字。ThreadLocalRandom是用于多线程的环境下用于解决资源的竞争。
     */

/*
     * 1.在使用Iterator对集合中的元素进行便利的时候只能使用Iterator提供的方法来操作元素，如果使用集合引用来进行操作的话将会产生异常。ConcurrentModificationException
     * 2.Set集合里面的元素是不能重复的，当想Set里面包含重复的元素的时候，往里面插入元素则会失败。Set集合插入的元素元素是无序的，Set集合判断里面判断是否包含次元素的时候是根据元素的
     * HashCode来计算是元素所在的位置，然后在根据equals方法判断是否相等如果哈希码一样并且Equals方法也返回ture的话，那么就是重复元素。
     * 3.在集合中如果需要对一个对象的equals方法或者hashcode方法进行重写的话，那么应该重写这两个方法。并且保证equals方法返回ture的时候，hashcode也要一样。
     */

/*
     * 1.使用泛型编程避免了集合忘记集合中的元素类型，这样可以保证在使用集合的时候不会出现ClassCastException异常。
     * 2.泛型:所谓泛型，就是允许在定义类，接口，方法时使用类型形参，这个类型形参将在声明变量，创建对象，调用方法时动态的制订(即传入实际的类型参数).
     * 3.当为一个类增加泛型声明的时候，那么在声明构造函数的时候就不需要在指定泛型声明。
     * 4.当创建了带泛型声明的接口，父类之后，可以为该接口创建实现类，或者改父类派生子类， 需要指出的是，当使用这些接口，父类时不能再包含类型形参。
     * 5.不管泛型的类型形参传入哪一种类型实参，对于java来说，他们依然被当成同一个类型处理，在内存中也只占用一块内存空间，因此在静态方法，静态初始化块
     * 或者静态变量的声明和初始化中不允许使用类型形参。
     * 6.在泛型参数的传递中要注意传递参数时一定要一致，比如参数时List<Object>,而实际传入的是List<String>那么在编译的时候将发生错误，也就是说
     * 虽然String是Object对象的子类但是在泛型中List<String>并不是List<Object>的子类。
     * 7.类型通配符?,例如List<?> 这里的？号被称为通配符，他的元素类型可以匹配任何类型。  
     * 8.设定类型通配符或者类型形参的上限<?/T extends class.name> 这表示在使用实际参数的时候?/T只能是class.name的子类或者相等。
     * 9.泛型方法,在声明方法时定义一个或多个类型参数。修饰符 <T, S> 返回值类型 方法名(形参列表){}
     * 10.泛型方法与类型通配符之间的区别、类型通配符就是被设计用来支持灵活的子类活化的。泛型方法允许类型参数被用来表示方法的一个或多个参数之间的类型依赖
     * 关系，或者方法返回值与参数之间的类型依赖关系。如果没有这种类型依赖关系，就不应该使用泛型方法。
     * 11.类型通配符的下限<? super T>表示?必须是T本身或者T的父类。
     * 12.泛型的擦除与转换。当把一个具有泛型信息的对象赋给另一个没有泛型信息的变量时，所有在尖括号之间的类型信息都将被扔掉。
     */

/*
     * 1.java程序在运行的过程中出现异常那么会寻求处理该异常的对象的catch块，如果找不到处理该对象的异常catch那么就会是程序停止执行。
     * 2.在try块里面声明的变量都是局部变量，在finally块或者catch块里面都是无法使用的。
     * 3.在catch块中的异常信息应该先处理小异常后处理大异常，否则会造成编译时出现错误。
     * 4.在JDK7以后再一个catch块中可以捕获多个异常，异常之间用|来分隔开，同时这些异常变量都是隐式的用了final，所以在catch块里面
     * 是不能在进行赋值的。
     * 5.Java垃圾回收机制是不会对任何的物理资源进行回收的所以需要在finally里面进行物理资源的关闭。
     * 6.在java的异常的finally语句块里面不是任何时候都会执行的，当在catch块里面有System.exit()方法调用的时候，那么finally
     * 就不会被执行，而是直接退出程序。
     * 7.在try块或者catch块里面使用了return语句，那么如果在finally块里面也使用了return语句的话，那么finally块里的return
     * 会使catch或者try块里面的return语句失效。
     * 8.java7以后可以使用增强的try块，在try后面使用圆括号来声明需要使用完后关闭的资源变量，但是这些资源必须实现Closeable接口
     * 好的是java7几乎把所有的资源类都进行了改写。改写资源类都实现了AutoCloseable或Closeable接口。
     * 9.使用throws声明抛出异常，当一个方法不知道如何处理异常的时候就用throws抛出异常交给调用该方法的对象进行处理。main方法抛出的异常由JVM
     * 来进行处理，JVM对异常的处理是打印堆栈信息，并终止程序的执行。
     * 10.throw抛出异常，这是根据具体的业务需要进行异常抛出。throw抛出的不是异常类而是异常实例类。throw抛出运行异常和检查异常。如果是运行时
     * 异常可以出现在任何地方，而检查时异常只能出现在try或者catch块中或者改方法用throws抛出异常。
     * 11.catch和throw结合使用的情况在大型企业级应用中非常常用。企业级应用对异常的处理通常分为两个部分:①应用后台需要通过日志来记录异常发生的
     * 详细情况；②应用还需要根据异常向应用使用者传递某种提示。在这种情况下，所有异常都需要两个方法共同完成，也就必须将catch和throw结合使用。
     * 12.异常栈跟踪，printStackTrace。
     */

/*
     * 1.Java提供的五个基本Annotation如下:Override,Deprecated,SupperessWarning,SafeVarargs,FunctionalInterface
     * 上面五个基本的Annotation中SafeVarargs是在java 7中新增的，而FunctionalInterface则是java 8新增的。
     * @Override 限定重写父类方法。该注解只能修饰方法，不能修饰其他元素。
     * @Deprecated 标示已过时。用于表示某个程序元素已过时，当其他程序使用已过时的类，方法时，编译器会给出警告。
     * @SuppressWarning 抑制编译器警告。被该注解修饰的程序元素取消显示指定的编译器警告。
     * @SafeVarargs 堆污染
     * @FunctionalInterface 函数式接口
     */

/*
     * 1.File类是java.io包下代表与平台无关的文件和目录，也就是说，如果希望在程序中操作文件和目录，都可以通过File类来完成。
     * 指的提出的是，不管是文件还是目录都使用File来操作的，File能新建，删除，重命名文件和目录，File不能访问文件内容本身。如果
     * 需要访问文件内容本身则需要使用IO流来操作。
     * 2.java程序支持将斜线/当成平台无关的路径分隔符。
     * 3.文件过滤接口FileNameFilter，该接口有一个方法boolean accept(File dir, String name);该方法将依次对指定File
     * 的所有子目录或者文件进行迭代，如果该方法返回true，则List方法则列出该文件或者目录。
     * 4.流的分类①按流来分类输入流:只能从中读取数据，而不能向其写入数据。输出流:只能向其输入数据而不能向其读取数据。②字节流和字符流:字节流和
     * 字符流的用法完全一样只是他们各自使用的单位不一样。即字节流每次操作是1字节，字符流操作是2字节。③节点流:程序直接和实际的数据源连接进行输入与读取。
     * 处理流:处理流是在节点流的基础上进行了包装，是的程序适应不同的场景。实际上，java使用的处理流来包装节点流是一种典型的装饰器设计模式，通过使用处理
     * 流来包装不同的节点流，及可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入/输出的功能，因此处理流也被称为包装流。
     * 5.IO流的基类InputStream/OutputStream-Reader/Writer(字节流和字符流)
     * 6.怎样识别处理流，很简单只要流的构造器参数不是一个物理节点而是一个已经存在的流，那么这种流就一定是处理流；而所有节点流都是直接以物理IO节点作为构造器参数的。
     * 7.在使用了处理流包装了底层节点之后，关闭输入输出流资源时，只要关闭最上层的处理流即可。关闭最上层的处理流时，系统会自动关闭该处理流包装的节点流。
     * 8.关于字节流与字符流的使用:如果进行输入/输出的内容是文本内容，则应该考虑使用字符流；如果进行输入/输出的内容是二进制内容，则应该考虑使用字节流。
     * 9.重定向标准的输入输出流，java的标准输入/输出流时System.In/System.out,在默认的情况下分别代表键盘和显示器。在System类里面提供了如下三个标准
     * 的输入/输出的方法。static void setErr(PrintStream err);重定向标准错误输出流。static void setIn(InputStream in);重定向
     * 标准的输入流。static void setOut(PrintStream out);重定向标准的输出流。
     * 10.RandomAccessFile，该类提供了丰富的方法来访问文件。支持随机访问模式，程序可以直接转到文件的任意地方来读写数据。由于支持随机的访问文件的任意位置
     * 所以需要访问问价的部分内容使用RandomAccessFile更好。并且可以向已存在的文件的末尾追加内容。
     */

public static void main(String[] args) {File file = new File("D://Java/picture/myPicture.jpg");//File file = new File("D://Java/picture");System.out.println("文件名:" + file.getName());System.out.println("文件路径:" + file.getPath());System.out.println("文件的绝对路径:" + file.getAbsoluteFile());System.out.println("文件的绝对路径名:" + file.getAbsolutePath());System.out.println("File对象的父目录是:" + file.getParent());System.out.println("文件或目录是否存在:" + file.exists());System.out.println("文件或者目录是否可以读:" + file.canRead());System.out.println("文件或者目录是否可以写:" + file.canWrite());System.out.println("是否为文件:" + file.isFile());System.out.println("是否为目录:" + file.isDirectory());System.out.println("是否为绝对路径:" + file.isAbsolute());System.out.println("文件最后的修改时间:" + new Date(file.lastModified()));System.out.println("文件的大小:" + file.length() + "B");// boolean createNewFile(),当次文件不存在的时候，这个方法则会创建一个该File对象所指的新文件，创建成功返回true，失败返回false// boolean renameTo(File newName)成功返回true失败返回false 将文件重新命名// boolean delete()：删除File对象所指的文件或者路径// static File createTempFile(String prefix, String suffix)：在默认的临时目录 下黄建一个临时的空文件。// void deleteExit():注册一个删除钩子，当虚拟机退出的时候就删除File对象所指的文件和目录。// boolean mkdir() 试图创建一个File对象所对应的目录，如果创建成功返回true。// String[] list():列出File对象所指的所有文件名和路径名，返回String数组// File[] listFiles():列出File对象的所有子目录和文件，返回File数组// static File[] listRoots():列出所有系统的根路径。// void mark(int readAheadLimit);在记录指针当前位置记录一个标志// boolean markSupported();判断次输入流是否支持mark操作。// void reset();将次流的指针重定向到上一次mark的位置// long skip(long n);记录指针向前移动n个字节/字符PathTest p = new PathTest();p.test();}}class PathTest {public void test() {Path p = Paths.get(".");System.out.println("Path里包含的路径数量:" + p.getNameCount());System.out.println("Path的根目录:" + p.getRoot());Path pp = p.toAbsolutePath();System.out.println(pp);System.out.println("pp 的根路径:" + pp.getRoot());System.out.println("pp里包含的路径数量:" + pp.getNameCount());Path ppp = Paths.get("G:", "public", "codes");System.out.println(ppp);}}

/*
     * 1.进程:几乎所有的操作系统都支持进程的概念，所有运行中的任务通常对应一个进程。当一个程序进入内存运行时，即编程一个进程。进程是处于运行过程中的程序，并且具有一定
     * 的独立功能，进程是系统进行资源分配和调度的基本单位。线程:也被称作轻量级进程，线程是进程的执行单元。就像进程在操作系统中的地位一样，线程在程序中是独立的，并发的
     * 执行流。当进程被初始化后，主线程就被创建了。对于绝大部分的应用程序来说，通常要有一个主线程，但也可以在该进程内创建多条顺序执行流。这些顺序执行流就是线程，每个线程
     * 也是互相独立的。
     * 2.线程跟进程的关系:线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不拥有系统
     * 资源，他与父进程的其他线程共享该进程拥有的全部资源。因为多个线程共享父进程里的全部资源，因此编程更加方便。线程可以完成一定的任务，可以与其他的线程共享父进程中的
     * 共享变量及部分环境，相互之间协同来完成进程所要完成的任务。
     * 3.创建线程的三种方法一是继承Thread重写run方法。而是实现Runnable接口，三是实现Callable接口，但需要用FutureTask包装作为Thread的target。
     * 4.线程的生命周期，新建，就绪，运行，阻塞，和死亡五种状态。 新建态和就绪态，当一个线程被创建时处于新建态，当调用了start方法后该线程就处于就绪态。线程会以
     * 三种方式结束，结束后就处于死亡状态。run或者call方法执行完成，线程正常结束。 线程抛出一个未捕获的异常或者错误。 直接调用线程的stop方法来结束该线程。
     * 5.不要对处于死亡状态的线程调用start()方法，程序只能对新建状态的线程调用start()方法，对新建状态的线程两次调用start也是错误的都会造成异常
     * IllegalThreadStateException。
     * 6.守护线程，也叫后台线程。JVM垃圾回收器就是典型的后台线程。后台线程有个特征，如果所有的前台编程都死亡，后台线程会自动死亡。调用Thread的setDeamon(true)
     * 可以将指定线程设置成后台线程。注意：要将一个线程设置成后台线程必须在调用该线程的start方法之前设置否则将引发IllegaThreadStateException异常。
     */
    // boolean isAlive(),测试线程是否死亡，当线程处于就绪，运行，阻塞态返回true。当线程处于新建态，死亡态返回false
    // void join()控制线程，Thread提供了让一个线程等待另一个线程完成的方法-join方法。当在某个程序执行流中调用其他线程的join方法是该线程将会被阻塞直到被调用
    // 的线程执行完成为止。
    // boolean isDeamon()，测试线程是否为后台线程
    // sleep(long millis); 让当前执行的线程暂停一段时间，并进入阻塞状态。该方法不会是线程发起所占有的资源，即获得的锁。
    // void yield(); 线程让步，这个方法会使的当前线程进入就绪状态。事实上当执行该方法后只有优先级比这个 线程更高或者相等的线程才会得到执行。
    // setPriority(); 设置线程的优先级，1-10 MAX_PRIORITY10,MIN_PRIORITY1,NORM_PRIORITY5
    // getPriority(); 获取线程的优先级