java基础（2）

清理手机空间的时候发现了以前做的笔记，还有一些总结的其他大佬的

请求方法:
get:获取查询数据(查询)
post:数据的提交，新增操作(增加)
put:向服务端发送数据、改变信息，侧重点在于对数据的修改操作
delete:数据库数据的删除
head:一般用来判断类型、根据返回状态确定资源是否存在、资源是否更新以及更新的时间等

super

Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。

因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误。

因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法
 “Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”

先说说对构造函数的理解：

1，函数名与类名相同。

2，没有返回值。

3，没有return。

4，每个类都有一个默认无参的构造函数，初始化该类的时候，先走构造函数，用于初始化成员变量和方法。

5，一个类如果自定义了构造函数，则默认的无参构造函数没有了，如果需要无参的构造函数，必须手动添加。

再说说子类和父类关于super()方法的调用：

1，super(); 就是调用父类的构造函数。

2，如果父类自定义了有参的构造函数，子类必须自定义构造函数，并且在构造函数的第一行调用父类的带参的构造函数super();。（这块我个人理解为，如果子类没有自定义构造函数，那默认的是无参的构造函数，无参的构造函数默认调用父类的无参的构造函数，但是父类自定义了有参的构造函数，就没有无参的构造函数了，所以这个编译是失败的。）

3，如果父类只自定义了无参的构造函数，那么子类如果自定义了构造函数，不论有参没参，都默认调用父类无参的构造函数，这个时候，子类构造函数不用加super();
类的继承知识点

(1)java不支持多重继承，也就是说子类至多只能有一个父类

(2)子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法

(3)子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承

(4)子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。
 #getSuperClass()
getSuperClass()方法在java.lang包中可用。
getSuperClass()方法用于返回Class，该Class表示此Class表示的任何类，接口，原始类型或任何void类型的超类。
getSuperClass()方法是一个非静态方法，只能通过类对象访问，如果尝试使用类名称访问该方法，则会收到错误消息
getSuperClass()方法在返回超类时不会引发异常。

super只在子类中出现
super有三种用法
【1】 super.xxx;
xxx可以是类的属性。
例如super.name;即从子类中获取父类name属性的值

【2】 super.xxx();
xxx()可以是类中的方法名。
super.xxx();的意义是直接访问父类中的xxx()方法并调用

【3】 super();
此方法意义是直接调用父类的构造函数。
super(无参/有参）即调用父类中的某个构造方法，括号里的内容根据你所调用的某个构造函数的变化而改变

枚举

(1) 枚举型是一个集合，集合中的元素(枚举成员)是一些命名的整型常量，元素之间用逗号,隔开。

(2) DAY是一个标识符，可以看成这个集合的名字，是一个可选项，即是可有可无的项。

(3) 第一个枚举成员的默认值为整型的0，后续枚举成员的值在前一个成员上加1。

(4) 可以人为设定枚举成员的值，从而自定义某个范围内的整数。

(5) 枚举型是预处理指令#define的替代。

(6) 类型定义以分号;结束。

注意：同一个程序中不能定义同名的枚举类型，不同的枚举类型中也不能存在同名的命名常量。

包装类

一、包装类说明
为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。

基本数据类型与相应的包装类

byte     Byte
 
short    Short
 
int      Integer
 
long     Long
 
float    Float
 
double   Double
 
char     Character
 
boolean  Boolean

二、包装类主要功能
该包装对象主要用基本类型和字符串之间的转换。

（1）基本类型--->字符串
1、基本类型数值+""

2、用String类中的静态方法valueOf(基本类型数值);

3、用包装类的静态方法valueOf(基本类型数值);

（2）字符串--->基本类型
1、使用包装类中的静态方法:xxx parseXxx("xxx类型的字符串");

eg:

int parseInt("intstring");
 
long parseLong("longstring");
 
boolean parseBoolean("booleanstring");

备注：只有Character没有parse方法，本身就是封装了字符，无须转换

2、如果字符串被xxx包装类进行对象的封装。

可使用另一个非静态的方法，xxxValue();

将一个xxx包装类对象转成基本数据类型值。

三、JDK1.5自动装箱拆箱
（1）拆箱装箱概念
装箱：自动将基本数据类型转换为包装器类型；

拆箱：自动将包装器类型转换为基本数据类型。

（2）jdk1.5后包装类新特性

Integeri=4;//自动装箱，简化书写：Integer i=new Integer(4);
i=i+6;//i=new Integer(i.intValue+6);//自动拆箱
System.out.println(i.intValue());//10

（3）拆箱装箱实现
装箱：自动将基本数据类型转换为包装器类型；装箱过程是通过调用包装器的valueOf方法实现的

拆箱：自动将包装器类型转换为基本数据类型。拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。

【1】实现代码案例

public class Autoboxing_Unboxing {
    public static void main(String[] args) {
    Integer i = 10;//装箱
        int n = i;//拆箱
    }
}

【2】反编译代码发现
反编译class文件之后得到如下内容：
　从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

其他的也类似，比如Double、Character

【3】结论
　　因此可以用一句话总结装箱和拆箱的实现过程：

装箱过程是通过调用包装器的valueOf方法实现的，拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。

四、包装类装箱之valueOf方法之思
1、创建对象与valueOf方法【装箱】
思考：由于装箱过程是调用包装器的valueOf方法实现的，

即：当Integer i=3过程，创建Integer对象的时候，这样一个装箱过程，就会调用包装器的valueOf方法。所以，我们在此重点讨论这个valueOf方法。

2、valueOf方法结论
主要得出几个结论：

2.1不同包装类之间，有共性的地方。分为三大派别：
【1】Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。比较特殊，根据数值的大小范围而获得对象的方式不同

【2】Double、Float的valueOf方法的实现是类似的，每次都返回不同的对象。

【3】Boolean的valueOf方法实现，每次返回的都是同一个对象

2.2对于类别【1】
（1）有两种创建对象的情况：
《1》在一些特定取值范围内，创建的对象是共享的，即：该数值范围的对象，在内存中只创建一个（一次），以后想创建该数值的对象，直接获取即可，不需要去new新的。

这个范围的取值情况是：

相同对象范围：在该范围内，同数值情况下，对象是相同的，是同一个。

Integer    相同对象范围  [-128,127]

Short      相同对象范围  [-128,127] 

Byte      相同对象范围  [-128,127]  

Character  相同对象范围  [0,127]    

Long      相同对象范围 [-128,127]  

《2》除了上述的取值范围内，对象只创建一个，这里所说的范围内，对象不会共享，相同数值情况下，会创建不同的对象

这个范围的取值情况是：

不同对象范围：在该范围内，同数值情况下，对象是不同的，是多个不同的。

Integer    不同对象范围 i<128||i>=128

Short     不同对象范围 s<128||s>=128

Byte      不同对象范围  无

Character  不同对象范围  c>=128

Long      不同对象范围 L<128||L>=128

综合《1》《2》得

Integer    相同对象范围 [-128,127] 不同对象范围i<128||i>=128

Short     相同对象范围 [-128,127] 不同对象范围s<128||s>=128

Byte      相同对象范围 [-128,127] 不同对象范围无

Character  相同对象范围 [0,127]   不同对象范围c>=128

Long     相同对象范围 [-128,127] 不同对象范围 L<128||L>=128

（2）Integer的valueOf源码

【1】valueOf工厂方法

public static Integer valueOf(int i) {   
        if(i >= -128 &&i<=IntegerCache.high)   
          //如果i在-128~high之间,就直接在缓存中取出i的Integer类型对象 
          return IntegerCache.cache[i + 128];   
        else 
          return new Integer(i); //否则就在堆内存中创建  
    }   

【2】IntegerCache内部类
 

private static class IntegerCache {//内部类，注意它的属性都是定义为static final 
        static final inthigh; //缓存上界 
        static final Integer cache[];//cache缓存是一个存放Integer类型的数组 
 
        static {//静态语句块 
           final int low = -128;//缓存下界，值不可变 
 
           // high valuemay beconfigured by property 
           int h = 127;// h值，可以通过设置jdk的AutoBoxCacheMax参数调整(参见(3)) 
           if (integerCacheHighPropValue!=null) { 
               // UseLong.decode here to avoid invoking methods that 
               // requireInteger's autoboxing cache to be initialized 
               // 通过解码integerCacheHighPropValue，而得到一个候选的上界值 
               int i = Long.decode(integerCacheHighPropValue).intValue(); 
               // 取较大的作为上界，但又不能大于Integer的边界MAX_VALUE 
               i = Math.max(i, 127);//上界最小为127 
               // Maximumarray size is Integer.MAX_VALUE 
               h = Math.min(i, Integer.MAX_VALUE - -low); 
           } 
           high = h; //上界确定，此时high默认一般是127 
           // 创建缓存块，注意缓存数组大小 
           cache =new Integer[(high - low) +1]; 
           int j = low; 
           for(int k = 0; k 
               cache[k] =new Integer(j++);// -128到high值逐一分配到缓存数组 
       } 
 
        private IntegerCache() {}//构造方法,不需要构造什么 
    } 

分析：取值范围[-128,127]共享对象，之外创建独立对象

（3）Short的valueOf源码
 

public static Short valueOf(short s) {
        final int offset = 128;
        int sAsInt = s;
        if (sAsInt >= -128 &&sAsInt <= 127) { // must cache
            return ShortCache.cache[sAsInt +offset];
        }
        return new Short(s);
}

分析：取值范围[-128,127]共享对象，之外创建独立对象

（4）Long的valueOf源码

public static Long valueOf(long l) {
        final int offset = 128;
        if (l >= -128 &&l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
}

分析：取值范围[-128,127]共享对象，之外创建独立对象

（5）Byte的ValueOf源码

public static Byte valueOf(byte b) {
        final int offset = 128;
        return ByteCache.cache[(int)b +offset];
}
 
private static class ByteCache {
        private ByteCache(){}
        static final Byte cache[] =new Byte[-(-128) + 127 + 1];
        static {
            for(int i = 0; i < cache.length;i++)
                cache[i] =new Byte((byte)(i - 128));
        }
    }

分析：取值范围[-128,127]共享对象

备注：基本数据类型byte的取值范围[-128,127]

（6）Character的valueOf源码

public static Character valueOf(char c) {
        if (c <= 127) {//must cache
            return CharacterCache.cache[(int)c];
        }
        return new Character(c);
}

分析：取值范围[0,127]共享对象，之外创建独立对象

（7）一些测试案例
《1》案例一

public class CharacterTest {
 
    //测试结论： 0-127范围，对象共享；128开始，创建不同的新对象
    public static void main(String[] args) {
 
       Character c1=(char) 128;
       Character c2=(char)128;
       System.out.println(c1==c2);//false
       System.out.println(c1.equals(c2));//true
 
       Character c11=(char) 127;
       Character c12=(char)127;
       System.out.println(c11==c12);//true
       System.out.println(c11.equals(c12));//true
 
       Character c21=(char) 0;
       Character c22=(char)0;
       System.out.println(c21==c22);//true
       System.out.println(c21.equals(c22));//true
 
 
    }
 
}

《2》案例二

public class ByteTest {
 
    //测试结论：byte取值的范围：-128-127
    //而在byte的范围内的对象都是可以共享的
 
    public static void main(String[] args) {
       //byte最大
       Byte b1=127;
       Byte b2=127;
       System.out.println(b1==b2);//true
       System.out.println(b1.equals(b2));//true
 
       //byte最小
       Byte b11=-128;
       Byte b12=-128;
       System.out.println(b11==b12);
       System.out.println(b11.equals(b12));
 
       //对于超出byte取值范围[-128,127]的，最终都会转为byte范围内的数字，所以一样得到了true的结果
 
//     Byte b12=128;//报错
       Byte b13=(byte) 128;
       //int（32位）的128强制类型转为byte（8位）型，其中会把多余的24位剔除，从而转换成byte范围的数
       Byte b23=(byte) 128;
       System.out.println(b13==b23);//true
       System.out.println(b13.equals(b23));//true
 
       Byte b21=(byte) -129;
       Byte b22=(byte) -129;
       System.out.println(b21==b22);//true
       System.out.println(b21.equals(b22));//true
 
    }
 
}

2.3对于类别【2】Double、Float的valueOf方法的实现是类似的，每次都返回不同的对象】
（1）Double 的ValueOf源码

 

 public static Double valueOf(double d) {
        returnnew Double(d);
}

分析：每次都创建不同的对象

（2）Float 的ValueOf源码

 

public static Float valueOf(floatf) {
        return new Float(f);
    }

分析：每次都创建不同的对象

2.4对于类别【3】Boolean的valueOf方法实现，每次返回的都是同一个对象
Boolean 的ValueOf源码

  public static final Boolean TRUE =new Boolean(true);
    public static final Boolean FALSE =new Boolean(false);
    public static Boolean valueOf(booleanb) {
        return (b ?TRUE : FALSE);
}

分析：每次的对象都是同一个，因为那个对象是创建好的常量。

五、包装类的equals方法
1、方法结论
1.1结论
equals方法为true时，需要满足两个条件：

1、类型相同  2、内容相同

1.2源码分析
（1）Integer的equals源码
  

public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

（2）Short的equals源码

 

 public boolean equals(Object obj) {
        if (obj instanceof Short) {
            return value == ((Short)obj).shortValue();
        }
        return false;
    }

（3）Long的equals源码

public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }

（4）Character的equals源码
  

public boolean equals(Object obj) {
        if (obj instanceof Character) {
            return value == ((Character)obj).charValue();
        }
        return false;
    }

（5）Byte的equals源码

 

 public boolean equals(Object obj) {
        if (obj instanceof Byte) {
            return value == ((Byte)obj).byteValue();
        }
        return false;
    }

（6）Float的equals源码

 public boolean equals(Objectobj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) ==floatToIntBits(value));
    }

（7）Double的equals源码

public boolean equals(Objectobj) {
        return (obj instanceof Double)
               && (doubleToLongBits(((Double)obj).value) ==
                      doubleToLongBits(value));
    }

（8）Boolean的equals源码

 public boolean equals(Objectobj) {
        if (obj instanceof Boolean) {
            returnvalue == ((Boolean)obj).booleanValue();
        }
        return false;
    }

六、包装类一些结论总结
1、当一个基础数据类型与封装类进行==运算时，会将封装类进行拆箱

2、+运算时，会将封装类进行拆箱

3、当封装类与基础类型进行==运行时，封装类会进行拆箱，拆箱结果与基础类型对比值；

而两个封装类进行==运行时，与其它的对象进行==运行一样，对比两个对象的地址，也即判断是否两个引用是否指向同一个对象。

4、陷阱一：有拆箱操作时一定要特别注意封装类对象是否为null，如果为空，则不能调用对象的任何方法，否则会报错

5、陷阱二：不同范围数值的对象产生情况不同（详情看：四、包装类装箱之valueOf方法之思）

该结论来自以下参考文章，如果想了解详细，请看该文

博文：详解Java的自动装箱与拆箱(Autoboxingand unboxing)

博主：Mirhunana

网址：链接

七、包装类综合实例应用

public class Test {
 
    public static void main(String[] args) {
       /*
        * 当 "=="运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，
        * 而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。
        * 另外，对于包装器类型，equals方法并不会进行类型转换
        */
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;//大于一个字节表示范围（byte:-128-127）
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
 
 
        //如果装箱的是一个字节，该数据会被共享不会重新开辟空间
        System.out.println(c==d);//true
        System.out.println(e==f);//false 
 
        /*
         * a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），
         * 因此它们比较的是数值是否相等。
         * 
         * 而对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，
         * 也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，
         * 便调用Integer.valueOf方法，再进行equals比较。同理对于后面的也是这样，
         * 不过要注意倒数第二个和最后一个输出的结果（如果数值是int类型的，
         * 装箱过程调用的是Integer.valueOf；如果是long类型的，装箱调用的Long.valueOf方法）
         */
 
        /*
         * 3=（1+2）
         * a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），
         * 因此它们比较的是数值是否相等。
         */
        System.out.println(c==(a+b));//true
 
        /*
         * 3.equals(1+2)
         * 先自动拆箱，左边数值为3，右边数值为3；
         * 然后出发自动装箱，装箱过程中调用Integer.valueOf方法，
         * 即：如果装箱的是一个字节，该数据会被共享不会重新开辟空间
         * 过左边和右边是同一个空间的地址，所以相等
         */
        System.out.println(c.equals(a+b));//true
 
//       System.out.println("3L==(1+2)--"+(3L==(1+2)));
 
        /*
         * 3L==(1+2)
         * a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），
         * 因此它们比较的是数值是否相等。
         * 左边为3L 右边为3 ，两者的值相等吗？
         * 相等：int与 long进行运算、比较时 int 会自动进行类型提升为 long类型
         *      类型自动提升
         */
        System.out.println(g==(a+b));//true
        /*
         * 3L.equals(1+2)
         * 先自动拆箱，左边数值为3L，右边数值为3；
         * 然后出发自动装箱，装箱过程中左边调用Double.valueOf方法，右边调用Integer.valueOf方法
         * 左边为Long型，右边为Integer型(原因：类型不同，内容相同)
         */
        System.out.println(g.equals(a+b));//false
 
        /*
         * 3L.equals(1+2L)
         * 先自动拆箱，左边数值为3L，右边数值为3L(运算的时候，由于自动类型转换，所以为3L)；
         * 然后出发自动装箱，装箱过程中两边都调用Double.valueOf方法
         * 两边数值相等，故相等(类型和内容相同)
         */
        System.out.println(g.equals(a+h));//true
    }
 
}

正则表达式

在很多技术领域（如：自然语言处理，数据存储等），正则表达式可以很方便的提取我们想要的信息，所以正则表达式是一个很重要的知识点！

一、概念

正则表达式（Regular Expression）是用于描述一组字符串特征的模式，用来匹配特定的字符串。通过特殊字符+普通字符来进行模式描述，从而达到文本匹配目的工具。

正则表达式目前被集成到了各种文本编辑器/文本处理工具当中

二、应用场景

（1）验证：表单提交时，进行用户名密码的验证。

（2）查找：从大量信息中快速提取指定内容，在一批url中，查找指定url。

（3）替换：将指定格式的文本进行正则匹配查找，找到之后进行特定替换。

三、基本要素

（1）字符类

（2）数量限定符

（3）位置限定符

（4）特殊符号

注意：正则表达式基本是与语言无关的，我们可以结合语言/工具与正则表达式进行文本处理，在后面的博客中，我将使用grep来进行验证。（grep是一款Linux下按行匹配文本的工具，如下，使我们常使用的两个选项）

-E：使用扩展正则匹配

--color：将匹配得到的内容进行语法高亮

1.字符类

注意：1.grep采用的贪心匹配，它会匹配当前行中的所有匹配内容

2.echo $?表示是否匹配成功（如果成功返回值为0，不成功返回值为1）

2.数量限定符

由此，我们可以看出，“前面的单元”默认是指？或+前面的字符

注意：该结果为匹配失败，在相关文档中并未出现，应该啊是错误或者废弃的用法

3.位置限定符

4.特殊符号

假如我们去掉-E选项，会有什么现象呢？

此时，不难发现，去掉-E选项之后没有进行正常的正则匹配，这种现象需要我们引入如下的两个概念！

5.基本正则表达式&扩展正则表达式

区别：正则表达式的扩展正则（Extended规范）和基本正则（Basic规范）下，有些字符应该解释为普通字符，要表示上述特殊含义则需要加“\”转义字符。反之，在扩展规范下，应被理解为特殊含义，要取其字面值，也要对其进行“\”转义。

因此，grep工具带上-E选项，表示使用扩展正则来进行匹配，若没有该选项，则表示使用基准正则来进行匹配

5.其他普通字符集及其替换

综上，正则表达式有以下三个分类：

（1）基本正则表达式：Basic即BPEs

（2）扩展正则表达式：Extended即EREs

（3）Perl的正则表达式：PREs

因此，当grep指令不跟任何参数时，表示要使用BREs，后面跟“-E”表示使用EREs，后面跟“-P”参数，表示使用PREs

四、贪婪模式与非贪婪模式

1.贪婪模式：正则表达式匹配时，会尽量多的匹配符合条件的内容

注意：grep默认采用贪婪匹配，可能会对我们的测试结果造成干扰，大家可以上网使用“正则在线转换工具”进行测试

2.非贪婪模式：正则表达式匹配时，会尽量少的匹配符合条件的内容，也就是说，一旦发现匹配符合要求，立马就匹配成功，而不会继续匹配下去（除非有g，开启下一组匹配）

五、零宽断言

1.所谓断言，是用来声明一个应该为真的事实。在正则表达式中，只有当断言为真时才会继续进行匹配。

2.零宽断言：像用于查找某些内容之前或者之后的东西，其中一些特殊字符如“\b、^、$”等用于指定一个位置，这个位置应满足一定的条件。

3.分类：

（1）零宽度正预测先行断言（?=exp）

它断言自身出现的位置之后能匹配的表达式exp。如：\b\w+(?=ing\b),表示匹配以ing结尾的单词的前面的部分（除ing以外的部分）。当我们要查找“I'm singing while you're dancing.”时，它会匹配sing和danc

（2）零宽度正回顾后发断言（?>=exp）

它断言自身出现的位置的前面能匹配的表达式exp。如：（?<=\bre）\w+\b会匹配以re开头的单词的后半部分（除er以外的部分），例如：在查找“reading a book”时，它匹配ading

 上面这些是以前记录在手机上的，也忘记了哪些是自己写的，哪些是网上的大佬的。

如果有人知道，请帮忙艾特出来，我会在文章上面都放上原文链接。

下面的是清理空间时找到的一些以前存的励志句子，分享一下：

＃想让优秀的人奔向你，先考个专业前十试试，成绩不同，交际圈也会发生变化。
＃爱人之前先自己变得强大。
＃不要别人一问起关于你的什么，就毫无保留的说给别人听，学会拒绝。
＃不是做什么都需要人陪着的。
＃自先沉稳，而后爱人。
＃现在谈拥有，太幼稚。
＃不回应就代表拒绝。
＃合群是堕落的开始，优秀的开始是孤行。
＃与其硬挤进一个圈子，不如独自高贵。
＃大多数人都是先看你的五官再去了解你的三观。
＃智者不入爱河，你可以永远保持自己对美好爱情的向往，但一定要爱自己。
＃当一个人配不上你给的温柔时，那你也就没有必要对她温柔了，即便你们的关系以前有多好。
＃你的注意力应该转向生活中那些宏观的方面，花时间来审视自己对未来的总体计划。理想对你来说尤为重要，不要因为自己的情绪而耽误了更重要的事情，理想在你的整个生活中是非常重要的。
＃不说自己错事，不说自己目标，不说自己钱财，不说自己家事。
＃出言有尺，嬉闹有度，做事有余，说话有德。
＃世界上99%的人的成长过程就像一场慢性自杀：每天杀掉一点天真，杀掉一点认真，杀掉一点热情；多一点伪装，多一点顺从，多一点现实。
因为他们没有强大的内核，因此只能苟活于世，只能随波逐流，最终活成了模子里出来的模具，生活在绝望的平静里。
世界上只有1%的人能够活出自我，因为他们的内核足够强大，这种内核衍生出了核心竞争力，衍生出清晰的定位和目标，衍生出强大的能力去保护自己的天真和真性情，他们才有资格做真实的自己。
未来一个人的核心竞争力，就是他的“内核”。
＃当你真正明白了自己的使命，它们顿时消失。一个人，越早知道自己要成为谁，就会越快的接近高频率的自己。
#往往跟你唠的来的那个人是为了迎合你而有别的目的。

还有以前百度到的一些资料：

java范例大全：https://pan.baidu.com/s/1xYtkXyDqWJVM34vkjtIKHw     提取码：l1mv

c语言书籍：https://pan.baidu.com/s/1H8ajZfc7QdsSjRp5Sif1kg        提取码：ahhp

【解码国家安全章节答案智慧树知到】链接

【U校园新视野大学英语视听说教程2第三版完整答案】https://mbd.baidu.com/ma/s/LDnZujAS

网上自动生成springboot：https://start.spring.io/

智慧树解码国际安全

2022知到答案 解码国家安全 最新知到智慧树满分章节测试答案 – 网课小帮手

英语视听说2:

新视野大学英语(第三版)视听说教程2答案 - 百度文库

淘宝镜像下载Git（Windows版）

CNPM Binaries Mirror

Spring官方文档

Spring Boot Reference Guide

阿里网盘网页版

阿里云盘

上面的这些我都用不到了，就分享给大家了，同时作为我的笔记。