javaSE阶段重要知识点梳理

JavaSE

1、 基础语法

一、        基本数据类型

　　一、

数据类型	字节数	二进制位数
byte	1	8
short	2	16
int	4	32
long	8	64
float	4	32
double	8	64
char	2	16
boolean	1	1

　　boolean类型的值只有true和false两种逻辑值，在编译后会使用1和0来表示，这两个数在内存中按位算，仅需1位（bit）便可存储，位是计算机最小的存储单位。

　　数据类型char在中文编码GBK-2312中占2个字节，在UTF-8中占3个字节。

二、判断与循环

逻辑运算符	做用
&	与做用，左右两边两个判断结果都为true就是true，不然是false
|	或做用，左右两边两个判断结果只要有一边为true，结果就是true，不然就是false
^	异或，你为true我就是false
&&	左右两边，左边若是为false，右边不执行，直接返回结果false
||	同理：左边若是为true，右边不执行直接返回true

　　第一种：

　　if(条件表达式){

　　　　语句块1

　　}else{

　　　　语句块2

　　}

　　第二种：

　　if(条件表达式){

　　　　语句块1

　　}else if{

　　　　语句块2

　　} else {

　　以上条件均不知足而执行的默认的逻辑

　　}

　　第三种：

　　switch(被判断的变量)

　　{

　　case 条件1:

　　　　执行条件1的逻辑

　　　　break;

　　case 条件2:

　　　　执行条件2的逻辑

　　　　break;

　　case n:

　　　　执行条件n的逻辑

　　　　break;

　　default:

　　　　以上条件均不知足而执行的默认的逻辑

　　}

　　第四种：

           While(判断语句){

   　　　　 循环体

　　　}

 

　　Do{

    　　循环体

　　}while(判断语句)；

　　While是先判断后执行，do while 是先执行循环体语句，而后进行判断语句，就是说不管判断是否为true都会至少执行一次循环体语句。

三、数组

　　一、 数组是对应的容器集合，须要存储同类的数据，在一个容器中。

　　二、 数组使用中，须要规定数组的长度，长度从1开始，设置后长度不可变。

　　三、 数组使用中，定义数据的类型为：Object，能够存储全部类型：，不然根据须要定义类型，能够是对象也能够是基本数据类型

　　四、 数组要想遍历（一个个的拿到数据内的数据），咱们须要for循环来完成，知道循环的次数，一个个的获取。数组获取中，若是超过角标，那么就会报错：角标越

　　　　界异常：indexoutofboundsException,由于角标从0开始

　　五、 排序算法：（选择和冒泡）

　　一、冒泡排序算法

 

 

 

       二、选择排序算法

     

 

 

2、 面向对象

一、        封装

　　　　一、封装属性：对属性的访问权限进行了封装，私有的只能本身用，公共的谁均可以用。

              二、封装方法：普通方法也可使用关键字进行封装，效果同样，私有的方法别人不能用。

              三、对私有的属性，能够封装一套获取方法和设置方法，分别是set和get

                     Set别人设置我当前的私有属性的数据。

                     Get别人获取使用我当前的私有属性的数据。

 

              四、在建立对象的时候进行封装：构造方法

                     建立对象的过程当中，我须要建立出来的对象是空对象，那么就用空参构造方法。

                     建立对象的过程当中，我须要建立出来的对象是带有数据的对象，不是一个空对象，那么咱们就使用有参构造方法来建立。

                     若是对象中不写构造方法，默认就有空参，若是写了那么就使用写了的，若是只写有参不写空参，那么就没法使用空参建立对象。默认的空参在你写了有参的时候就会消失，须要手动再写空参才能正常使用。

              五、构造方法和普通方法同样，能够方法名相同，可是参数数据类型与数量不能相同，必须在同一个对象中，咱们称之为是方法的重载。

                     重载：方法名必须相同，参数类型不一样。

                     重载：能够修改方法的访问修饰符，能够修改返回类型，无返回仍是有返回。

　　　　六、封装四个关键字使用的范围

位置	private	默认的	protected	public
同一个类	是	是	是	是
同一个包内的类	否	是	是	是
不一样包内的子类	否	否	是	是
不一样包而且不是子类	否	否	否	是

       　　注意：当前属性若是须要彻底给别人使用，咱们就须要设置公共的：public

     　　  注意：当前属性若是只能本身完成，别人不能使用，咱们就须要设置私有的：private

     　　  注意：private 使用：方法：get方法与set方法，能够被别人使用。

 

 

二、        继承

　　一、 继承：子类继承父类，子类可使用父类的全部的非私有的属性和方法

 

       二、方法的重写，须要注意事项：

                     一、方法名必须相同。

                     二、必须是继承或者实现关系。

                     三、重写方法传递的形参必须与父类的方法保持一致，不能设置其余形参。

　　　　　　四、重写的方法，访问权限封装关键字：子类的访问权限能够修改，可是权限的大小必定要比父类大。不能比父类小。

 

              三、方法的重载和重写的区别

　　　　　　一、方法的重写：必须有子父类的关系，子类重写父类的方法，提高方法的功能，重写方法中，修饰符子类须要比父类更大不能更小，也能够相同。方法名必须相

　　　　　　同，参数和返回值也必须相同。

 

　　　　　　二、方法的重载：在当前自身对象中，提供多种相同的方法，可是有区别的是，修饰符能够不同、返回值能够不同、可是方法名必须相同、小括号内参数，参

　　　　　　数类型不一样或者参数数量不一样来区分。

 

                     一个是发生在本身当前对象的：方法重载：overload

                     一个是发生在子父类对象的：方法重写：override

 

三、        多态

　　 一、多态建立出来的对象，能够执行调用父类的非私有的属性和方法。

 

　　 二、使用多态，若是要想调用子类的方法，那么子类的方法，必须是父类重写的方法。不然没法调用。

　　　　当前使用多态建立出来的对象，若是当前的方法，是子类重写父类的方法，那么就优先调用执行。若是当前的方法，子类没有重写父类的方法，

　　　　那么调用的就是父类的方法。

 

        三、多态调用执行：

                一、多态优先调用子类重写父类的方法。

                二、多态能够调用父类的非私有方法。

                三、多态能够调用父类的非私有属性。

                四、多态不能调用子类的非私有属性。

                五、多态不能调用子类的非私有方法。

 

        四、解决多态不能调用子类的非私有属性和方法。

若是使用多态想要调用子类的特有属性和方法的话。咱们须要将多态建立出来的对象，进行强制类型转换。将父类转换成子类。

 

        五、多态使用的细节总结：

              一、使用多态必须是有继承或者实现关系的。

　　　　二、使用多态咱们若是须要调用子类的方法，必须是重写方法，重写方法的权限最大。

　　　　三、使用多态建立出来的对象，不能调用子类的特有属性和方法，若是真想调用，咱们就须要使用到强转。

　　　　注意：在强转的过程当中，你们颇有可能会出现一个异常：ClassCaseException：类型转换异常。

　　　　四、注意：为了不后期你们出现类型转换的错误，咱们事先能够先测试判断一下类型转换是否正确：instanceof

　　　　五、当前咱们可使用到，关键字进行判断，判断出来的结果，就是正确或者错误，咱们判断当前转换的类型，是否合格，若是合格咱们就转换，若是不合格咱们

　　　　就不转换，就能解决类型异常的问题。

 

四、        抽象类

　　  一、抽象类：光定义方法但不实现方法。

 

　　  二、抽象方法，只能出如今抽象类或者是接口中，不能出如今普通方法中。抽象方法：当前只定义，不实现。例：父亲的愿望须要儿子去实现（俗称：负债子还）。

   

        三、建立一个抽象类：关键字：abstract。

抽象类，其实和普通类相似，能够有属性、构造方法、普通方法、get方法set方法等等。可是，抽象类中还能够定义抽象方法。

 

        四、在抽象类中，定义抽象方法

 

 

 

 

　　五、子类若是实现的是抽象类，那么必须实现抽象方法（必定要对抽象方法进行重写）

        若是子类不重写父类的抽象方法，就会一直报错。

 

        六、建立对象的过程当中，抽象类是不容许被建立出来的

            抽象的对象，是不容许直接被new建立的。

            抽象类，若是要想建立，咱们就须要使用对应的实现类（儿子建立）

 

 

　　七、 抽象类的出现：抽象类当中存在抽象方法，若是要想实现，那么就须要子类完成。可是抽象类，又不能直接初始化，仍是得用多态来初始化。

 

        多态的产生，其实有两部分的缘由：

　　　　一、 多态让建立对象，变的更加的灵活，根据用户的选择能够动态的进行建立。

 

　　　　二、 抽象类与接口是不能直接被建立的，而是须要经过多态的建立方式，让子类具体实现，完成建立工做。

 

        八、抽象类总结：

            一、抽象类不能被final修饰，由于抽象类必需要有儿子。

    　　 二、抽象类不能在方法中使用 final修饰，由于抽象类的抽象方法必需要被重写。

            三、抽象类能够继承抽象类，全部的抽象方法须要在实现类中一块儿实现。

            四、抽象类中能够有抽象方法，也能够有普通方法、属性、构造方法。

五、        接口

　　一、定义接口关键字：interface

 

       二、接口中方法都是抽象方法，不能有方法体。不能有普通方法，不能有构造方法。当前的接口中，只能有抽象方法，不能有实体方法。

 

       三、定义接口中的属性：接口中不能有变量，只能存在常量。当前的属性也可使用静态来修饰。

       使用静态修饰的好处：接口对象名称调用属性能够直接调用。

 

    四、接口可否被final修饰？

　　一、接口是不能被final修饰的。

　　二、接口中的方法不能被final修饰。

　　三、接口中的属性能够被final修饰，由于默认就是使用的final。

 

　五、使用接口：接口是不能直接被new出来的。因此当前必须先有实现类。

 

　六、Java的关系映射：单继承、多实现。

　　单继承：对象与对象间，继承只能继承1次。

　　多实现：对象与接口，一个对象能够实现多个接口。

 

　七、接口和抽象类的区别：

 

　　  一、抽象类能够有普通方法和抽象方法。

         二、抽象类中定义的属性是变量。

         三、抽象类能够继承抽象类或者普通类。

         四、抽象类能够实现接口，可是没有必要。

         五、抽象类不能直接建立，须要用多态的方法建立。

 

　　一、接口中只能有抽象的方法。

　　二、接口中属性是常量定义。

　　三、接口能够继承接口，但不能实现。

　　四、接口继承是多继承，抽象类继承是单继承。

　　五、无论是接口仍是抽象类，对象不能使用final修饰。方法不能使用final修饰。

 

　　　　由于后期在Java中开发项目，项目后期确定要维护升级的，咱们若是使用抽象类，就只能单继承，不方便维护，让项目加大了局限性。而使用接口的话，实现的接口数

　　量不限，能够多实现，解决了项目后期更新的局限性问题。

 

　　理解：

         抽象类就至关因而领导，领导定义任务，员工完成。

         接口就至关因而规范，接口制定规范，全部员工须要遵照。

六、        关键字

　　一、 this关键字

　　this对象：this关键字就是当前对象的引用关键字，用来区分传递形参与当前对象内的参数区别开来。

 

　　二、 super关键字

　　一、构造方法中使用super：

　　Super必须放在前面。

　　Super须要带有小括号。带有小括号就会调用父类对应的构造方法。

       二、super在普通方法中使用

　　Super若是在普通方法中使用，那么直接使用super便可，不须要添加小括号，不添加小括号的super，是直接引用的父类对象，不是构造方法。

 

　　三、 static关键字

　　一、static关键字修饰方法，咱们无需new对象，便可经过类名调用方法。

       二、static关键字修饰属性，咱们无需new对象，便可经过类名调用属性。

       三、缘由：static修饰的属性和方法，在生成.class文件的时候就会被初始化出来。

       四、static能够设置一个静态代码块：

Static{    }：运行的方式，是程序执行的时候，第一次就调用的，运行权限比构造方法还要大。程序一运行，第一个就调用的是静态代码块。

              使用场景：后期初始化数据的时候，咱们会使用到。

       五、static缺点：若是是static修饰的属性和方法，声明周期就会拉长，内存数据回收就会变得不方便，有些占用内存，后期在项目中，若是数据庞大的状况下，仍是尽可能少使用。

 

　　四、 final关键字

　　　　一、final能够修饰class属性对象，被final所修饰的对象，将不能被继承。

              二、final能够修饰属性，被修饰的属性，就从变量变成了常量，不可修改。

              三、final修饰的方法，当前的方法只能使用，不能被重写。

 

七、        内部类

　　一、内部类：在当前的对象内，再建立一个对象，称之为内部类

 

　　二、咱们建立内部类对象规则：

　　内部类，必须在类对象的括号内建立，命名不能带有小括号。

 

　　三、初始化内部类。

　　注意：由于当前的对象是内部对象，因此先要将外部对象建立出来，再来建立内部对象，外部对象建立内部对象中，使用到了调用，因此建立内部对象的时候，前面须要带

　　上小点，进行调用。

 

　　四、内部对象，是否会生成.class文件：

　　会生成一个Animal$Cat.class文件，由于是否生成class文件，取决因而否使用了class关键字

 

　　五、内部类同样和外部类使用，只是内部类是写在对象内的。同样也能够封装、继承、多态

 

　　六、匿名对象：就是没有名字的对象，通常使用在建立对象的时候。

　　注意：当前调用的方法与建立的对象，只会执行一次，它是一次性写法。由于没有给对象在建立的时候命名，因此方法执行完，对象也会随着消失销毁在内存中。因此若是

　　须要再次调用方法，那么就须要从新再次建立对象。

 

　　七、匿名内部类：在当前类中建立一个类，可是不给名称。（由于抽象类与接口不能直接被new，要先直接初始化其实也有方法，咱们当前就须要使用匿名内部类）

 

　　八、匿名内部类，也会生成一个class文件，虽然没有明文写出，生成的class文件仍是会出来，命名使用的是1命名。

 

3、 经常使用API

一、引用数据类型：

              一、基本数据类型：8种：

                     整数类型：byte、short、int、long

                     浮点类型：float、double

                     判断类型：boolean

                     字符类型：char

 

              二、引用数据类型：9种：

                     整数类型：Byte、Short、Integer、Long

                     浮点类型：Float、Double

                     判断类型：Boolean

                     字符类型：Character

                     字符串：String

 

　　　　三、字符和字符串的区别：

                     一、字符是基本数据类型，字符串是引用数据类型。

       　　　　二、字符定义的字符能够转换为对应的ascii表，对应的数字，能够进行加减乘除。

　　　　　　三、字符串由于是常量，数据是在常量池中，只能作对应的加法，是拼接。其他的减乘除都是不行的，由于String是不支持的

             　　 四、String对象，建立的几种不一样方式。

                     直接建立：从常量池就能直接拿到对应的常量数据

                     经过new关键字建立：常量池常量传递给堆，堆再给栈。

 

　　　　　　五、String建立的字符串都是常量，不能修改，修改的话就是从新在来生成一个，原有的就会等待回收机制回收。

 

　　　　　　六、String构造方法中，咱们能够给空的、也能够给具体的String字符串、还能够给对应的数组让数组对应的字符或者数字来生成一个字符串。

      

　　　　　　七、 自动装箱与自动拆箱

　　　　　　基本数据类型，转换为引用数据类型，自动装箱。

　　　　　　引用数据类型，转换为基本数据类型，自动拆箱。

 

二、StringBuffer和StringBuilder

    　一、String：字符串常量

　　　　StringBuffer：字符串变量

　　　　StringBuilder：字符串变量

       二、线程安全

　　　　StringBuilder：线程非安全的

　　　　StringBuffer：线程安全的

       三、三者使用：

　　　　1.若是要操做少许的数据用 = String

　　　　2.单线程操做字符串缓冲区 下操做大量数据 = StringBuilder

　　　　3.多线程操做字符串缓冲区 下操做大量数据 = StringBuffer

       四、

              一、StringBuffer对象，默认长度是：16

              二、StringBuilder对象，默认长度是：16

三、Date

　　一、Date日期对象，咱们就是经过它将对应的毫秒值转化为咱们看的懂的日期对象。

 

　　二、Date对象中，重写了toString方法，里面含有对应的返回日期格式。咱们看完后，查看到了对应的英文字母，这些就是定义日期格式的关键字符。

 

　　三、当前咱们若是须要本身定义日期显示的样式，咱们就须要对应设置本身所须要的字母关键字符，可是Date里面是没有给咱们提供设置方法的，咱们须要使用到日期的帮助类：SimpleDateFormat

 

　　四、SimpleDateFormat对象，对Date日期对象进行了一个显示内容的封装，让当前的日期，能够根据用户自身的需求进行自定义格式。可是自定义格式中，咱们须要经过字母将格式设置完成后，才能使用。

 

　　五、当前Date与SimpleDateFormat对象两个相结合，最终就能获得咱们想要的日期格式，日期格式显示出来的内容，就是根据毫秒值来转换的。

 

　　六、日期为何须要使用毫秒值，避免时间重复，时间计算是须要很是精准的。由于任何项目若是时间戳出了问题，就会产生不可逆的异常。

4、 集合

一、        三个集合的区别

List	ArrayList	底层是数组	查询速度快，增删改慢	线程不安全	效率高
	LinkedList	底层是双向链表	增删速度快，查询慢	线程不安全	效率高
	Vector	底层是数组	查询快，增删慢	线程安全	效率低
	ArrayList 初始容量为10，自增加度是（10*3/2）+ 1。 Vector 内部数据数组的大小为10，其标准容量增量为零。

 

Set	HashSet	底层是HashMap	存取速度快，	线程不安全	无序，不可重复	能够存储null，但只能放入一个null
	TreeSet	底层是红黑树	排序存储	线程不安全	有序，不可重复	不能够存储null
	HashSet其底层HashMap实例的默认初始容量是16，加载因子是0.75

 

Map	HashMap	底层是Hash表（数组+链表）	效率高	线程不安全	键值能够存储null,但只能存储一次，否则会被覆盖
	HashTable	底层是Hash表（数组+链表）	效率低	线程安全	不能够存储null
	HashMap   默认初始容量是16，加载因子是0.75 HashTable默认初始容量是11，加载因子是0.75

 

二、        集合的关系图

 

 

 

 

　　一、汇总：

              Collection：是集合中的一个接口父类，它是一个分支，子类实现接口中：List和Set

 

              Map：也是集合中的一个接口父类，子类中是：HashMap、HashTable

 

       二、Map接口集合，与Collection区别：

              Map结构分为：k v，俗称键值对。

              K：key：键

              V：value：值

              在map集合中，k就是键，是主键的意思，不能重复。V就是值，值能够重复。

              在List集合中，角标就是键，里面的内容就是值。角标从0开始，没有重复的。

 

5、 IO流

一、咱们所学习的全部IO：

              FileWriter：文件的字符输出流，是Writer的子类。

              FileReader：文件的字符输入流，是Reader的子类。

 

              BufferedWriter：字符高效输出流，当前默认有缓冲区。

              BufferedReader：字符高效输入流，当前默认有缓冲区。

 

              FileOutputStream：文件字节输出流，当前是万能输出流。

              FileInputStream：文件字节输入流，当前是万能输入流。

 

              BufferedOutputStream：文件高效字节输出流，当前默认有缓冲区。

              BufferedInputStream：文件高效字节输入流，当前默认有缓冲区。

      

              ObjectOutputStream：对象输出流

              ObjectInputStream：对象输入流

              只能将支持 java.io.Serializable 接口的对象写入和读取到流中。

 

二、文件的嵌套复制，递归

　　在文件夹复制的工做中，文件夹中还有存在子文件夹，嵌套存在深度不一致多，有的多有的少。咱们须要复制过程当中考虑全面，就须要将代码嵌套比较的多，效率极低。

              当前解决的办法：使用的是递归来解决文件夹嵌套建立的问题。

 

              递归的好处：不断调用自身，进行文件夹建立。

 

　　递归使用的注意事项：

　　　　须要递归的过程当中，设置出口，中止定义，不然就会一直调用致使堆栈溢出。

              递归的算法：当前重复调用方法，直到拿到预期的目标跳出递归，进入出口。

 

              递归的使用中：

                     入口：调用自身。

                     出口：获得预期的目标，跳出进入出口，结束调用本身。

 

三、        IO流，分为字节流和字符流

　　一、字节流和字符流

　　字符流：只能对文本文档操做的流对象，由于当前读写设置的是char类型的容器。

 

　　字节流：是万能流，不只能够对文本文档操做，还能对其余类型的文档操做，好比图片、视频、音频等等，由于当前读写设置的容器类型为byte类型，根据字符的编码存储编码的序号数字，进行转译。

 

　　二、字节流与字符流，当前的效率字节流要快于字符流。

　　字节流复制文件，一个须要800多毫秒便可，可是字符流复制文件，一个须要7秒，一样的大小200多MB的文件。

　　　　一、 在公司中开发，咱们经常使用的是字节流，由于字节流对应功能局限性小，效率高。

　　　　二、 当前咱们学习字符流和字节流中，咱们还学习了对应的高效输出输入流。

　　　　三、 字节高效的输入输出流，要快于普通字节流，快的速度800毫秒能够缩短到300毫秒。

 

　　　　字符流也是同理，高效的要高于普通的，由于高效的能够读取一行，直接写入，须要换行写入的时候能够插入换行。

 

　　三、为何高效的要快：由于当前底层设置了缓冲区，咱们能够建立高效流的同时使用默认缓冲区，或者自定义缓冲区，咱们通常使用默认便可，由于默认已经足够咱们使用了。

              默认缓冲区大小：8192字节。

 

6、 多线程

一、        多线程的开启方式

　　一、方法一：本身建立一个对象，继承多线程对象，进行建立多线程。

 

 

 

 

              二、方法二：经过实现一个接口Runnable接口，让多线程对象使用。

 

 

 

 

二、        多线程设置同步锁

　　一、方式一：使用同步代码块：关键步骤上锁

　　注意：锁对象必须是一致的，通常使用class文件，保持一致。或者使用单例设计模式建立对象。

 

       二、方式二：同步方法：将整个方法进行上锁

　　注意：当前线程能够开启多个，可是runnable实现类必须只有一个，不能实现多个实现类，不然同步方法无效

　　方法三：静态同步方法，全部的对象都上锁，一锁锁全部

　　注意：当前若是要实现多个runnable实现类，不一样的对象间使用方法锁的话，可使用静态同步方法，这样的话就可以解决方法二不能锁住的问题。

 

       三、方法三：静态同步方法，全部的对象都上锁，一锁锁全部

　　注意：当前若是要实现多个runnable实现类，不一样的对象间使用方法锁的话，可使用静态同步方法，这样的话就可以解决方法二不能锁住的问题。

三、        两种设计模式

　　一、 单例设计模式

　　懒汉式：

 

 

 

　　饿汉式：

 

 

 

　　二、 生产者与消费者模式

　　一、生产者生产数据到缓冲区中，消费者从缓冲区中取数据。

　　若是缓冲区已经满了，则生产者线程阻塞；

　　若是缓冲区为空，那么消费者线程阻塞。

 

　　二、wait：等待方法

　　被等待的线程是自身唤醒的，必须得依靠别的线程或者对象唤醒，唤醒经过锁对象调用唤醒方法。

 

　　三、notify：唤醒方法（唤醒单个）

        唤醒单个：随机唤醒等待的线程中的一个线程

       

　　四、notifyAll：唤醒方法（唤醒所有）

　　唤醒所有：将当前全部等待的线程进行唤醒，唤醒后不必定全部线程都执行，具体谁执行还须要看CPU给谁分配了资源抢占了锁对象。

　　注意：当前锁对象若是不是同一把锁，就没法唤醒，同时也可能产生一直等待的状态，线程堵塞

 

　　五、sleep方法，当前休息睡眠必定的时间后，本身就可以清醒过来，进行继续运行。

　　区别：等待唤醒机制，若是当前处于等待的状态，就会释放锁对象，丢给其余对象使用而且执行，当前自身处于等待不执行的状态。 睡眠方法，则不一样，当前线程若是是睡眠方法，那么在睡眠的过程当中是不会释放锁资源的，等清醒后，继续操做执行，直到执行结束，结束操做，释放锁资源，提供给其余对象使用。

7、 网络编程

　　一、网络编程的三要素：IP地址、端口号、网络协议。

 

　　二、网络协议：底层协议：UDP、TCP

              UDP：直接链接的网络协议，通常使用的场景：视频、语音、聊天室。

 

              TCP：三次握手链接，通常使用的场景：传输图片、发送聊天文字等等。

 

              区别：

                     UDP：效率快，可是数据丢失没法找回，数据传输不稳定。

                     TCP：效率相对慢，传输的数据，稳定丢失比较低。

 

              使用网络协议传输的过程当中，咱们基本上使用的都是流对象传输。

 

8、 反射与正则表达式

一、反射

　　一、对象反射的方式一共有：三种

              第一种：建立出来对象，经过对象的引用获取。

              第二种：经过类的包名 + 类名直接寻找。

              第三种：直接经过类名调用class关键字。

       二、暴力访问，将setAccessible的状态设为true，而后就能够获取私有的属性和方法。

      

　　二、正则表达式

       一、使用一个正则对象

static Pattern

compile(String regex)           将给定的正则表达式编译到模式中。

 

Matcher

matcher(CharSequence input)           创匹配给定输入与此模式的匹配器。

 

boolean

matches()           尝试将整个区域与模式匹配。

 　　使用示例：