Tout d'abord, un aperçu des modèles de conception et classement
1, un aperçu des modèles de conception des
modèles de conception (motif Design) est réglé à une utilisation répétée, connu pour la plupart des gens, après le catalogage, le résumé de l' expérience de conception de code.
Utilisez des modèles de conception à code réutilisable, rendre le code plus facile à comprendre par d' autres, ainsi que pour assurer la fiabilité de la structure de code du code plus clair.
2, classification de motifs conçu
pour créer un schéma (créer un objet): modèle Singleton, modèle de fabrique abstraite, le modèle de constructeur, modèle d'usine, le modèle prototype.
Type de modèle (Fonctions d'objet): le mode adaptateur, mode pont, motifs décoratifs, mode combiné, le modèle d'apparence, Flyweight, mode proxy.
modèle structurel (composée d'objets): patron de méthode, le mode de commande, le motif itérateur, modèle d'observateur, modèle intermédiaire, le mode de mémoire, le motif de l' interprète, le motif d'état, motif de stratégie, à chaîne cyclique, motif de visiteur.
Deuxièmement, le simple aperçu du modèle de l'usine et de l'utilisation
1. Vue d' ensemble: également connu sous le nom de modèle méthode usine statique qui définit une classe d'usine de béton est responsable de la création d' instances d'une classe.
2, les avantages: L'avantage d'utiliser un modèle d'usine statique est de parvenir à la répartition des responsabilités, le noyau du modèle est la classe d'usine, classe d'usine contient la logique de sélection nécessaires, dont des exemples peuvent décider quand un produit est créé, et le client est retiré directement Création responsabilité des produits, mais seulement les produits de consommation. Ce modèle d'usine statique sans modifier le code client peut ajouter dynamiquement des produits. Il a défini les responsabilités de la classe.
3, Inconvénients: Cette classe usine statique est responsable de la création de tous les objets, s'il est d'ajouter de nouveaux objets, ou différentes façons de créer des objets, vous devez modifier en permanence la classe d'usine, ne favorise pas le maintien de la fin.
En troisième lieu, en utilisant la méthode de l'usine, et un mode aperçu
1. Présentation: usine modèle Méthode classe abstraite d'usine est responsable de la définition de l'interface pour créer des objets, créer un objet spécifique de travail est réalisé par une classe de béton Hériter l'usine abstraite.
2, les avantages: Le client n'a pas besoin d'être responsable de la création d' un objet, qui définit les responsabilités de chaque classe, si l' on veut ajouter de nouveaux objets, il suffit d'ajouter une classe spécifique et la classe usine de béton ne peut pas affecter le code existant , après un entretien plus facile, améliore l' évolutivité du système
3, les inconvénients: la nécessité pour le codage supplémentaire, ce qui augmente la charge de travail
4, des présentations de cas
En quatrième lieu, le singleton
1, Catégorie: paresseux et affamés la formule Formule
2, et la distinction de faim formule formule paresseux
单例模式之饿汉式
public class Student {
private static Student student=new Student();
//1.私有化构造
private Student() {
}
//2.提供一个公共的静态方法，让外界通过这个方法，来获取一个该类的对象
public static Student getStudent(){
return student;
}
}测试类
public class MyTest {
public static void main(String[] args) {
Student student = Student.getStudent();
Student student1 = Student.getStudent();
System.out.println(student==student1);
}
}单例模式之懒汉式
public class Teacher {
private static Teacher teacher=null;
//1.私有化构造
private Teacher() {
}
//2.提供公共的静态方法，让外界获取该类的一个对象
//t1 t2
public synchronized static Teacher getTeacher(){
if(teacher==null){
teacher=new Teacher();
}
return teacher;
}
}
测试类
public class Test {
public static void main(String[] args) {
//懒汉式：体现的是一种延迟加载，当需要用的时候，我再帮你去创建这个对象
//实际开发中 常用饿汉式
Teacher teacher = Teacher.getTeacher();
Teacher teacher1 = Teacher.getTeacher();
System.out.println(teacher==teacher1);
}
}3 deux idées, singletons:
A: la sécurité fil pensée
b: retard de chargement pensé
4, classe singleton code Java Runtime incarnait
A, vue d' ensemble de la classe Durée: Chaque application dispose d' une instance Java Runtime de classe de l'application à l'environnement est liée à ses opérateurs. Vous pouvez obtenir les objets d'exécution en cours par la méthode getRuntime. L'application ne peut pas créer sa propre instance de classe Runtime.
b, présentations de cas: exec publique du processus (commande String) // exécution de la commande Dos
public class Demo {
public static void main(String[] args) throws IOException {
//这个类，采用的是单例模式之饿汉式
Runtime runtime = Runtime.getRuntime();
//Process exec (String command)
//在单独的进程中执行指定的字符串命令。
//runtime.exec("calc");//打开计算机
//runtime.exec("mspaint");//打开画图
//runtime.exec("notepad");//打开记事本
//定时关机
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
try {
runtime.exec("shutdown -s -t 0");
} catch (IOException e) {
e.printStackTrace();
}
}
}, 1000 * 60 * 1);
}
}
En cinquième lieu, utiliser des modèles et des modèles de conception Vue d'ensemble
1 Vue d' ensemble: Template motif Méthode consiste à définir un algorithme du squelette, et le retard algorithmique spécifique aux sous - classes pour obtenir
2, Exigences: calcul de temps pour l' exécution de la boucle
trois avantages: un mode de procédé de stencil, dans la définition de l'épine dorsale de l' algorithme en même temps, il peut être très flexible pour atteindre algorithme spécifique pour répondre aux besoins de l'utilisateur flexible
4 inconvénient: si l'algorithme a modifié le squelette, alors vous devez modifier la classe abstraite
5, des présentations de cas: l' utilisation des modèles de conception de modèle
public abstract class CalcTime {
public long testTime() throws IOException {
long start = System.currentTimeMillis();
testTimer();
long end = System.currentTimeMillis();
return end-start;
}
public abstract void testTimer() throws IOException;
}public class TestFor extends CalcTime{
@Override
public void testTimer() {
for (int i = 0; i < 1000; i++) {
System.out.println(i);
}
}
}
public class MyTest {
public static void main(String[] args) throws IOException {
CalcTime testFor = new TestFor();
long l = testFor.testTime();
System.out.println("耗时" + l + "毫秒");
}
}
Sixième, l'utilisation de motifs décoratifs et vue d'ensemble
1 Vue d' ensemble: motif décoratif est utilisé par l'instance d'une sous - classe de la décoration, l'instance client de cette sous - classe à la fin décorative. Hérité autre
deux avantages: l'utilisation de motifs décoratifs, peut fournir plus souple que les objets étendus fonctionnalité Hériter, qui peut ajouter dynamiquement la fonction d'objet, et ces fonctions peuvent être librement combinés.
3, Moins: Tout simplement parce que vous pouvez mélanger librement, donc il peut sembler logique déraisonnable.
Sept mode observateur et de l'utilisation Vue d'ensemble
1: Cas: trouver un chasseur de têtes pour trouver un emploi
2: Abonnés observateurs = + Editeur
demandeurs d'emploi recherche classe (méthode d'enregistrement, méthode d'annulation, la méthode de distribution)
public class HeaderHunt { //猎头
//定义两个集合，来装求职者，和工作岗位
private ArrayList<Worker> mans=new ArrayList<>();
private ArrayList<Job> jobs = new ArrayList<>();
//提供注册的方法
public void addMan(Worker man){
mans.add(man);
}
//提供注销的方法
public void removeMan(Worker man){
mans.remove(man);
}
//添加岗位
public void addJob(Job job){
jobs.add(job);
//岗位一旦有了之后，我就得通知每一个求职着
noticeToMan(job);
}
//通知的方法
private void noticeToMan(Job job) {
for (Worker man : mans) {
System.out.println(man.getName()+"你好! 有一份"+job.getName()+"月薪"+job.getMoney()+"诚邀你前去面试");
}
}
}public class Job {
private String name;
private double money;
public Job() {
}
public Job(String name, double money) {
this.name = name;
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
public class Worker {
private String name;
public Worker() {
}
public Worker(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}测试类
public class Test {
public static void main(String[] args) {
Worker man1 = new Worker("张三");
Worker man2 = new Worker("李四");
Worker man3 = new Worker("王五");
Worker man4 = new Worker("赵六");
//把每个人的信息注册到猎头那里
HeaderHunt headerHunt = new HeaderHunt();
headerHunt.addMan(man1);
headerHunt.addMan(man2);
headerHunt.addMan(man3);
headerHunt.addMan(man4);
//猎头一旦工作岗位更新后 ，就会通知每一个求职者
headerHunt.addJob(new Job("软件开发工程师",25000));
headerHunt.removeMan(man3); //移除求职着
System.out.println("----------------------------");
headerHunt.addJob(new Job("大数据工程师", 35000));
}
}
