单例设计模式：保证类在内存中只有一个对象。
*
* * 如何保证类在内存中只有一个对象呢？
* * (1)控制类的创建，不让其他类来创建本类的对象。private
* * (2)在本类中定义一个本类的对象。Singleton s;
* * (3)提供公共的访问方式。 public static Singleton getInstance(){return s}
* * 单例写法两种：
* * (1)饿汉式 开发用这种方式。public class testThread1 {public static void main(String []args){Single s1=Single.s;Single s2=Single.s;System.out.println(s1==s2); //成员变量被私有/*Single s1=Single.getS();Single s2=Single.getS();System.out.println(s1==s2);*/}
}//饿汉式class Single{private Single() { //1.私有该类的构造方法，其他类不能访问该构造}private static Single s=new Single(); //2.在本类中创建本类对象public static Single getS() { //3.对外提供公共的访问方法来啊获取实例return s;}
}* * (2)懒汉式 面试写这种方式。多线程的问题？//懒汉式class Single{private Single() { //1.私有该类的构造方法，其他类不能访问该构造}private static Single s; //2.在本类中声明一个引用public static Single getS() { //3.对外提供公共的访问方法来啊获取实例if (s==null){s=new Single();}return s;}
}
* (3)第三种格式
class Single{private Single() { //1.私有该类的构造方法，其他类不能访问该构造}private static final Single s=new Single(); //2.在本类中声明一个对象
}饿汉式与懒汉式区别
* 1.饿汉式是空间换时间
* 懒汉式是时间换空间
*
* 2.在多线程访问时，饿汉式不会创建多个对象，
* 而懒汉式有可能会创建多个对象
A:简单工厂模式概述
* * 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
* * B:优点
* * 客户端不需要在负责对象的创建，从而明确了各个类的职责
* * C:缺点
* * 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
* * D:案例演示
* * 动物抽象类：public abstract Animal { public abstract void eat(); }package com.xy.bean;/*** @Classname Animal* @Description TODO* @Date 2019/2/14 0014 19:13* @Created by Administrator* @Version 1.0*/
public abstract class Animal {public abstract void eat();
}
* * 具体狗类：public class Dog extends Animal {}
package com.xy.bean;/*** @Classname Dog* @Description TODO* @Date 2019/2/14 0014 19:14* @Created by Administrator* @Version 1.0*/
public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃肉");}
}
* * 具体猫类：public class Cat extends Animal {}
package com.xy.bean;/*** @Classname Cat* @Description TODO* @Date 2019/2/14 0014 19:13* @Created by Administrator* @Version 1.0*/
public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}
}
* * 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。
package com.xy.Model;import com.xy.bean.Animal;
import com.xy.bean.Cat;
import com.xy.bean.Dog;/*** @Classname AnimalFactory* @Description TODO* @Date 2019/2/14 0014 19:17* @Created by Administrator* @Version 1.0*/
public class AnimalFactory {
// public static Cat creatCat(){
// return new Cat();
// }
// public static Dog creatDog(){
// return new Dog();
// }//发现方法定义很多，复用性很差public static Animal creatAnimal(String name) {if (name.equals("cat")) {return new Cat();} else if (name.equals("dog")) {return new Dog();}else return null;}
}
测试类
public class testModel1 {public static void main(String []args){/*Cat c=AnimalFactory.creatCat();Dog d=AnimalFactory.creatDog();System.out.println(c);System.out.println(d);*/Cat c=(Cat) AnimalFactory.creatAnimal("cat");Dog d=(Dog) AnimalFactory.creatAnimal("dog");System.out.println(c);c.eat();System.out.println(d);d.eat();}
}
A:工厂方法模式概述
* * 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
* * B:优点
* * 客户端不需要在负责对象的创建，从而明确了各个类的职责，
* 如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
* * C:缺点
* * 需要额外的编写代码，增加了工作量
* * D:案例演示
Factory接口:
package com.xy.Model;import com.xy.bean.Animal;public interface Factory {public Animal creatAnimal();
}CatFactory类:
package com.xy.Model;import com.xy.bean.Animal;
import com.xy.bean.Cat;/*** @Classname CatFactory* @Description TODO* @Date 2019/2/14 0014 19:35* @Created by Administrator* @Version 1.0*/
public class CatFactory implements Factory{@Overridepublic Animal creatAnimal() {return new Cat();}
}
DogFactory类:
package com.xy.Model;import com.xy.bean.Animal;
import com.xy.bean.Dog;/*** @Classname DogFactory* @Description TODO* @Date 2019/2/14 0014 19:35* @Created by Administrator* @Version 1.0*/
public class DogFactory implements Factory {@Overridepublic Animal creatAnimal() {return new Dog();}
}
目录
3.适配器设计模式
a.什么是适配器
* * 在使用监听器的时候, 需要定义一个类事件监听器接口.
* * 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
* * 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
* * b.适配器原理
* * 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
* * 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
* * 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.public class testModel3 {public static void main(String []args){Student s=new Student();s.eat();}
}
interface student {public void eat();public void study();public void play();public void work();
}
class Root implements student{@Overridepublic void eat() {}@Overridepublic void study() {}@Overridepublic void play() {}@Overridepublic void work() {}
}
class Student extends Root{@Overridepublic void eat() {System.out.println("吃饭");}
}
模板设计模式
* * A:模版设计模式概述 * * 模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现 * * B:优点和缺点 * * a:优点 * * 使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求 * * b:缺点 * * 如果算法骨架有修改的话，则需要修改抽象类 * 1,装饰 * 2,单例 * 3,简单工厂 * 4,工厂方法 * 5,适配器 * 6,模版
public class testTemplate {public static void main(String []args){long start =System.currentTimeMillis();Demo d=new Demo();long end=System.currentTimeMillis();System.out.println(d.getTime());}
}
abstract class GetTime{public final long getTime(){long start =System.currentTimeMillis();test();long end=System.currentTimeMillis();return end-start;}public abstract void test();
}class Demo extends GetTime{@Overridepublic void test() {for (int i = 0; i <1000000 ; i++) {System.out.println("x");}}
}
