黑马程序员——设计模式+正则表达式

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

设计模式

解决某一类问题行之有效的方法

Java中共有23种设计模式

设计模式分类(三类)：

创建型模式(五种)：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

结构型模式(七种)：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式

行为型模式(十一种)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

单例设计模式

解决一个类在内存只存在一个对象

保证对象唯一条件：

1、为了避免其他程序过多建立该类对象，先禁制其他程序建立该类对象

2、为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象

3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

具体代码体现：

1、将构造函数私有化

2、在类中创建一个本类对象

3、提供一个方法可以获取该对象

单例设计模式有两种方式：饿汉式和懒汉式

第一种

饿汉式：先初始化对象

Single类一进入内存，就已经创建好了对象

class Single {
	private Single() {}
	private static Single s = new Single();
	public static Single getIntance() {
		return s;
	}
}

第二种  

懒汉式：对象是在方法被调用时，才初始化，也叫对象的延时加载

Single1类进入内存，对象还没有存在，只有调用了getInstance方法时，才建立对象

class Single {
	private static Single s = null;
	private Single() {}
	public static Single getInstance() {
		if (s == null) {
			// 通过上锁机制解决同时运行多个线程时存在的安全问题
			synchronized (Single.class) {
				if (s == null)
					s = new Single();
			}
		}
		return s;
	}
}

懒汉式和饿汉式的区别：

懒汉式的特点是延迟加载，实例的延迟加载；

当多线程访问出现安全问题时，通过同步解决。

用同步函数和同步代码块都行，但稍微有些低效；

用双重判断的形式能解决效率问题。

加同步的时候使用的锁是该类所属的字节码文件对象即类名.class。

              在定义单例时建议使用饿汉式。

 

模板方法设计模式

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去，由该类的子类去完成。

需求：获取一段程序运行的时间

原理：获取程序开始和结束的时间并且相减即可

获取时间：System.currentTimeMillis();

abstract class GetTime {
	public final void getTime()// final防止子类复写该功能
	{
		long start = System.currentTimeMillis();
		runcode();
		long end = System.currentTimeMillis();
		System.out.println("毫秒：" + (end - start));
	}

	public abstract void runcode();
}

class SubTime extends GetTime {
	public void runcode() {
		for (int x = 0; x < 4000; x++) {
			System.out.print(x);
		}
	}
}

class TemplateDemo {
	public static void main(String[] args) {
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

装饰设计模式

当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。

class Person
{
     public void chifan()
     {
         System.out.println("吃饭");
     }
}
 
class SuperPerson {
	private Person p;
	SuperPerson(Person p) // SuperPerson通过构造函数接受Person对象，并加强该功能
	{
		this.p = p;
	}

	public void superChifan() {
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
		System.out.println("水果");
	}
}

class PersonDemo {
	public static void main(String[] args) {
		Person p = new Person();
		p.chifan();

		SuperPerson sp = new SuperPerson(p);
		sp.superChifan();

	}
}

通过装饰来优化体系结构

装饰模式和继承的区别

装饰模式比继承要灵活,避免了继承体系臃肿。而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。

包(package)

特点：

对类文件进行分层管理

给类提供多层命名空间

写在程序文件的第一行

类名的全称是：  包名.类名

包也是一种封装形式

包与包之间访问

1、包与包之间进行访问，被访问的包中的类以及类中的成员都需public修饰

2、不同包中的子类还可以直接访问父类中被protected权限修饰的成员

3、包与包之间可以使用的权限只有两种：publicprotected

   

 常见权限大小

public     protected       default      private

  同一个类中    ok            ok              ok                 ok

  同一个包中    ok            ok              ok

  子类             ok            ok

  不同包中        ok

 

import导入的是包中的类。

注意：import packb.*;导入packb中的类

import packb.haha.*;导入packb.haha中的类

建议不要写通配符*，需要用到包中的哪个类就导入哪个类

当导入不同包中的类出现同名时，这个类必须加包名

建议：定包名不要重复，可以使用url来完成定义，url是唯一的

 

如果原文件中有package关键字定义包，则在使用javac命令时要加参数

package  pack;

-d   指定包所存放的位置

javac -d . Xx.java     杠d空格点空格     自动将pack包创建在当前目录下

javac –d c:\myclass Xx.java     将pack包存放在c:\myclass目录下

包的出现可以让java的运行文件和源文件相分离

 

正则表达式

符合一定规则的表达式

作用：用于专门操作字符串

特点：用一些特定的符号来表示一些代码操作，这样就简化书写，学习正则表达式，就是在学习一些特殊符号的使用

好处：可以简化对字符串的复杂操作

弊端：符号定义越多，正则越长，阅读性越差

具体操作功能：

1、匹配：String matches方法，用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false

2、切割：String split();

3、替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组

4、获取:将字符串中的符合规则的子串取出

需求：对QQ号码进行校验（匹配应用）要求：5~15 0不能开头，只能是数字

第一种：用正则表达式(匹配)

<span style="white-space:pre">	</span>public static void checkQQ() {
		String qq = "123a454";
		String regex = "[1-9]\\d{4,14}";
		boolean flag = qq.matches(regex);
		if (flag)
			System.out.println(qq + "...isok");
		else
			System.out.println(qq + "...不合法");
	}

需求：手机号段只有 13xxx 15xxx 18xxxx（匹配应用）

public static void checkTel() {
	String tel = "16900001111";
	String telReg = "1[358]\\d{9}";
	System.out.println(tel.matches(telReg));
}

切割应用

splitDemo("zhangsan.lisi.wangwu","\\.");按照.切割

splitDemo("c:\\abc\\a.txt","\\\\");按照\\切割

splitDemo("erkktyqqquizzzzzo","(.)\\1+");按照叠词完成切割

替换应用

         String str ="wer1389980000ty1234564uiod234345675f";

         replaceAllDemo(str,"\\d{5,}","#");连续数字超过五个就用#替换

         String str1 = "erkktyqqquizzzzzo";

         replaceAllDemo(str1,"(.)\\1+","$1");将重叠的字符替换成单个字母

获取应用

操作步骤：

1、将正则表达式封装成对象

2、让正则对象和要操作的字符串相关联

3、关联后，获取正则匹配引擎

4、通过引擎对符合规则的子串进行操作，比如取出

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
	public static void main(String[] args) {
		getDemo();
	}

	public static void getDemo() {
		String str = "ming tian jiu yao fang jia le ,da jia。";
		System.out.println(str);
		String reg = "\\b[a-z]{3}\\b";// 将三个字母组成的单词取出来

		// 将规则封装成对象
		Pattern p = Pattern.compile(reg);

		// 让正则对象和要作用的字符串相关联,获取匹配器对象
		Matcher m = p.matcher(str);
		while (m.find()) {
			System.out.println(m.group());
			System.out.println(m.start() + "...." + m.end());
		}
	}
}

需求：将下列字符串转成：我要学编程.

思路：

1、如果只想知道该字符是否对是错，使用匹配

2、想要将已有的字符串变成另一个字符串，替换

3、想要按照自定的方式将字符串变成多个字符串，切割,获取规则以外的子串

4、想要拿到符合需求的字符串子串，获取，获取符合规则的子串

public static void test()
{
    String str ="我我...我我...我要..要要...要要...学学学....学学...编编编...编程..程.程程...程...程";
    /*
    将已有字符串变成另一个字符串，使用 替换功能
    1、可以先将 . 去掉
    2、在将多个重复的内容变成单个内容
    */
    str =str.replaceAll("\\.+","");
    System.out.println(str);
    str =str.replaceAll("(.)\\1+","$1");
    System.out.println(str);
}

需求：对邮件地址进行校验

public static void checkMail()
{
    String mail ="abc12@sina.com";
    mail ="1@1.1";
    String reg ="[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";//较为精确的匹配。
    reg ="\\w+@\\w+(\\.\\w+)+";//相对不太精确的匹配。
    //mail.indexOf("@")!=-1
    System.out.println(mail.matches(reg));
}

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------