<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Lirx_Tech的专栏]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/Lirx_Tech</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; Lirx_Tech]]></copyright><item><title><![CDATA[[疯狂Java]面向对象：不可变类]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51763469</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51763469</guid><author>Lirx_Tech</author><pubDate>Sun, 26 Jun 2016 17:22:42 +0800</pubDate><description><![CDATA[1. final只是保证被修饰的变量的值不可变！
    1) 注意！保证的是值不可变，什么是值？对于一个引用来说，就是指针咯，即指针的值不变，即其指向不变，但是我还是可以通过这个指针来调用可以改变该对象成员的方法啊！！
    2) 即final如果修饰引用变量，只能保证该引用的指向不变，但不能保证该引用指向的对象不变，其指向的对象还是可以改变的！！
    3) 例如：final Per]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：final修饰符（修饰变量、方法、类）]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51763161</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51763161</guid><author>Lirx_Tech</author><pubDate>Sun, 26 Jun 2016 16:52:04 +0800</pubDate><description><![CDATA[1. final修饰变量：
    1) 当final修饰变量时，其功能类似C++的const，有不可变的意思（类似常量），但是其用法比C++的const灵活地多，功能也更丰富；
    2) 用final可以修饰任何变量（成员变量、静态成员变量、局部变量等）；
    3) final变量的三大规则：
         i. 定义和初始化可以分开：final不像C++的const必须在定]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：单例模式]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51763035</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51763035</guid><author>Lirx_Tech</author><pubDate>Sun, 26 Jun 2016 16:00:47 +0800</pubDate><description><![CDATA[1. 单例模式的应用：
    1) 单例类就是指该类最多只能创建一个对象，不能创建超过一个的对象；
    2) 这样做的原因：要么就是为了降低系统开销，要么这种类型的对象创建了多个没有任何意义，最多只需要一个就行，例如窗口管理器、假脱机打印设备、数据库引擎访问结点；


2. 单例模式的模板：
    1) 这种模式下构造器的使用肯定是受限的！因为不能让外界自由使用，否则就能创建多]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：常量池、equals标准模板]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51761844</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51761844</guid><author>Lirx_Tech</author><pubDate>Sun, 26 Jun 2016 11:04:23 +0800</pubDate><description><![CDATA[1. Java的常量池：
    1) 一般来说，常量对一个编程语言来说就是指编译时就可以确定的值，说白了就是字面值；
    2) 例如数字字面值5、1.3、5L、0xAFF，字符串字面值"lala"等；
    3) 和C/C++管理常量不同的是（C/C++直接将常量编译到代码段里了，例如b = val + 5就直接编译成add b, val, 5，这个5直接出现在代码段中），Java使]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：基本类型的包装器类型、自动装箱/拆箱、包装器类型大小/相等比较]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51759328</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51759328</guid><author>Lirx_Tech</author><pubDate>Sat, 25 Jun 2016 18:00:40 +0800</pubDate><description><![CDATA[1. 基本类型的包装器类型：
    1) Java并不是严格的面向对象语言就是因为存在8中基本类型数据（int、char、double、boolean等），它们并不是类对象；
    2) 提供这8中基本类型主要是为了照顾C程序员的传统习惯；
    3) 为了让这8中基本类型也能面向对象，Java为其提供了包装器类型，名称都是各个基本类型的首字母大写（Long、Double、Float、]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：构造器（this、super）]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51757599</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51757599</guid><author>Lirx_Tech</author><pubDate>Sat, 25 Jun 2016 11:18:40 +0800</pubDate><description><![CDATA[1. 构造器基本概念：
    1) Java构造器和C++基本一致；
    2) 主要特点：
         i. 名称和类名一样；
         ii. 不得有返回类型（其默认返回构造的对象本身（this）），如果你强行加返回类型，系统就会把它当做一个普通的方法了，必须通过引用来调用，而不是用new来调用了；
         iii. 会在初始化代码执行之后再执行：其实构造]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：自发性多态问题]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51754750</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51754750</guid><author>Lirx_Tech</author><pubDate>Fri, 24 Jun 2016 17:53:07 +0800</pubDate><description><![CDATA[1. 自发性多态：
    1) 自发性多态使用不当往往会造成意想不到的错误，所以编程时一定要注意！
    2) 先看示例：
class A {
	void show() { // 该方法将会在子类中被重写
		out.println("A");
	}
	
	void test() { // 在其中调用另一个会被子类重写的方法
		show();
	}
}

class B extends]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：初始化块、初始化代码、初始化顺序]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51753836</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51753836</guid><author>Lirx_Tech</author><pubDate>Fri, 24 Jun 2016 17:24:41 +0800</pubDate><description><![CDATA[1. 初始化块：
    1) 在类中可以定义和方法平行的代码块，例如：public class A { { /* 初始化块 */ } ... }，即直接用花括号括起来的代码块；
    2) 这种代码块就是初始化代码块，用于给数据成员初始化，里面可以调用方法，使用if、for等Java语句，也就是说初始化块本质上和普通方法没有区别；
    3) 初始化块会在构造器之前执行，对数据成员初始]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：多态、编译时类型、运行时类型、向上兼容、兼容下反转、instanceof]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51751377</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51751377</guid><author>Lirx_Tech</author><pubDate>Fri, 24 Jun 2016 11:43:37 +0800</pubDate><description><![CDATA[1. 想明白多态必须先理解两个概念：编译时类型和运行时类型
    1) 这两种类型都是针对引用变量的；
    2) 编译时类型：
         i. 是声明引用变量时的类型；
         ii. 例如：String s;  // 那么s的编译时类型就是String
    3) 运行时类型：
         i. 是引用实际指向的对象的类型，和编译时类型完全没有任何关系]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：继承、覆盖、super]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51746870</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51746870</guid><author>Lirx_Tech</author><pubDate>Thu, 23 Jun 2016 21:59:58 +0800</pubDate><description><![CDATA[1. 类的继承：
    1) Java使用extends关键字来继承一个类，例如：public class Son extends Father { ... }表示Son类继承Father类；
    2) Java不支持C++非常麻烦的多继承，即extends只能继承一个父类；
    3) Java使用extends来表示继承，从词义来看继承也是一种对父类的扩展，即子类可以获得父类的全]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：封装（JavaBean）、包（package）、import（导入和静态导入）]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51742649</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51742649</guid><author>Lirx_Tech</author><pubDate>Thu, 23 Jun 2016 13:29:35 +0800</pubDate><description><![CDATA[1. 封装的关键——访问控制符：
    1) Java有4种访问控制级别，范围从小到大（从严到宽）依次为：private、default（包）、protected、public
    2) 4中访问控制符的限定范围：
         i. public：最宽松，对于一切都是可以访问的；
         ii. private：最严，只有在当前类中可见，类外的一切都不可见（都无法访问]]></description><category></category></item><item><title><![CDATA[[疯狂Java]面向对象：命名规范、重载、值传递、可变参数、static/this]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51741451</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51741451</guid><author>Lirx_Tech</author><pubDate>Thu, 23 Jun 2016 11:37:26 +0800</pubDate><description><![CDATA[1. 命名规范：
    1) 类：由多个单词连缀而成，单词之间不要分隔符，每个单词首字母大写，其余小写；
    2) 数据成员：应该是名词，多个单词连缀而成，首字母小写，其余单词首字母大写，其余小写，中间不要使用分隔符；
    3) 方法：应该以英文动词开头，命名规则和数据成员相同；


2. 方法重载：
    1) 重载在所有语言中的最基本要求是一致的，必须、至少要求方法名]]></description><category></category></item><item><title><![CDATA[[疯狂Java]正则表达式：捕获组、反向引用、捕获组命名]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51721491</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51721491</guid><author>Lirx_Tech</author><pubDate>Mon, 20 Jun 2016 16:12:47 +0800</pubDate><description><![CDATA[1.]]></description><category></category></item><item><title><![CDATA[[疯狂Java]正则表达式：Java正则表达式语法、贪婪模式/勉强模式]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51720266</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51720266</guid><author>Lirx_Tech</author><pubDate>Mon, 20 Jun 2016 15:10:31 +0800</pubDate><description><![CDATA[1. 基本字符和特殊字符：
    1) 正则表达式前面讲过了，是需要先编译再执行的，因此从某种方面来将正则表达式其实也是一种特殊的编程语言；
    2) 既然是编程语言（特殊的编程与语言）那么它就有它自己的源代码字符、关键字等概念了；
    3) 正则表达式没有像其它编程语言一样的关键字（像if、else、while等），它的关键字是特殊字符，因此正则表达式的源码分为基本字符和特殊字符]]></description><category></category></item><item><title><![CDATA[[疯狂Java]正则表达式：Pattern、Matcher、String对正则表达式的支持]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51672021</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51672021</guid><author>Lirx_Tech</author><pubDate>Tue, 14 Jun 2016 16:47:21 +0800</pubDate><description><![CDATA[1. 正则表达式引擎：
    1) 正则表达式其实跟SQL语句一样，其实本质都是查询命令，需要先编译然后再用相应的执行引擎启动并查询；
    2) 为什么正则表达式的本质是命令？
         i. 由于正则表达式中包含很多特殊字符，如*、^等，它们并不属于普通的纯文本字符；
         ii. 它们对于引擎来讲其实是一种特殊的命令（动作），例如*会被解释为“连续0个或多个任]]></description><category></category></item><item><title><![CDATA[[疯狂Java]泛型：泛型的底层原理（类型擦除、原生类型、编译前检查）]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51606651</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51606651</guid><author>Lirx_Tech</author><pubDate>Tue, 07 Jun 2016 21:07:43 +0800</pubDate><description><![CDATA[1.]]></description><category></category></item><item><title><![CDATA[[疯狂Java]泛型：泛型构造器、泛型方法的重载问题、泛型数组的问题（应该摒弃）、?下限的典型应用]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51603531</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51603531</guid><author>Lirx_Tech</author><pubDate>Tue, 07 Jun 2016 14:42:35 +0800</pubDate><description><![CDATA[1. 泛型构造器：
    1) 构造器也是方法，既然有泛型方法，那么构造器也可以定义为泛型方法，那么就变成了泛型构造器；
    2) 由于构造器也是方法，因此反省构造器的定义和普通泛型方法的定义完全相同，例如：public  MyClass(T t) { ... }
    3) 使用泛型构造器：
          i. 和使用普通泛型方法一样没区别，一种是显式指定泛型参数，另一种是]]></description><category></category></item><item><title><![CDATA[[疯狂Java]泛型：泛型方法、泛型方法VS类型通配符（?）]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51596684</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51596684</guid><author>Lirx_Tech</author><pubDate>Mon, 06 Jun 2016 17:09:44 +0800</pubDate><description><![CDATA[1. 定义泛型方法：
    1) 如果你定义了一个泛型（类、接口），那么Java规定，你不能在所有的静态方法、静态初块等所有静态内容中使用泛型的类型参数！！例如：
class A {
	public static void func(T t) { // 错误！在所有静态内容中不得使用泛型的类型参数
		
	}
}！！这个原因会在泛型底层原理中详细介绍，这里就只要先记住这个规则就行了！！]]></description><category></category></item><item><title><![CDATA[[疯狂Java]泛型：类型参数多态问题、类型通配符（?）、类型通配符的上下限、类型参数的上限（类、接口）]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51594703</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51594703</guid><author>Lirx_Tech</author><pubDate>Mon, 06 Jun 2016 13:06:16 +0800</pubDate><description><![CDATA[1. 泛型类型参数的多态问题：
    1) Java泛型有一个很奇怪的特点：那就是如果A是B的父类，那么泛型类Generic却不是Generic的父类，这就意味着不能把Generic的对象赋给Generic的引用了！！
！！和泛型不一样的是数组就不存在这个问题，如果A是B的父类，那么A[]也是B[]的父类，在多态赋值的时候就不存在任何问题；
    2) 可是Java的泛型为什么要这样设定]]></description><category></category></item><item><title><![CDATA[[疯狂Java]泛型：泛型的定义（类、接口、对象）、使用、继承]]></title><link>https://blog.csdn.net/Lirx_Tech/article/details/51570138</link><guid>https://blog.csdn.net/Lirx_Tech/article/details/51570138</guid><author>Lirx_Tech</author><pubDate>Thu, 02 Jun 2016 21:12:44 +0800</pubDate><description><![CDATA[1. 设计泛型的初衷：
    1) 主要是为了解决Java容器无法记忆元素类型的问题：
         i. 由于Java设计之初并不知道会往容器中存放什么类型的元素，因此元素类型都设定为Object，这样就什么东西都能放了！
         ii. 但是这样设计有明显的缺点：
             a. 取出元素的时候必须进行强制类型转换（尽管集合在运行时里面元素的“运行时类型]]></description><category></category></item></channel></rss>