标签：
package cn.itcast_01; public abstract class Animal { public abstract void eat(); }
Dog类：
package cn.itcast_01; public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃肉"); } }
Cat类：
package cn.itcast_01; public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } }
工厂类：
package cn.itcast_01; public class AnimalFactory { private AnimalFactory() { } // public static Dog createDog() { // return new Dog(); // } // // public static Cat createCat() { // return new Cat(); // } public static Animal createAnimal(String type) { if ("dog".equals(type)) { return new Dog(); } else if ("cat".equals(type)) { return new Cat(); } else { return null; } } }
测试类：
package cn.itcast_01; public class AnimalDemo { public static void main(String[] args) { // 具体类调用 Dog d = new Dog(); d.eat(); Cat c = new Cat(); c.eat(); System.out.println("------------"); // 工厂有了后，通过工厂给造 // Dog dd = AnimalFactory.createDog(); // Cat cc = AnimalFactory.createCat(); // dd.eat(); // cc.eat(); // System.out.println("------------"); // 工厂改进后 Animal a = AnimalFactory.createAnimal("dog"); a.eat(); a = AnimalFactory.createAnimal("cat"); a.eat(); // NullPointerException a = AnimalFactory.createAnimal("pig"); if (a != null) { a.eat(); } else { System.out.println("对不起，暂时不提供这种动物"); } } }
package cn.itcast_02; public abstract class Animal { public abstract void eat(); }
工厂类：
package cn.itcast_02; public interface Factory { public abstract Animal createAnimal(); }
Dog类：
package cn.itcast_02; public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃肉"); } }
Dog工厂类：
package cn.itcast_02; public class DogFactory implements Factory { @Override public Animal createAnimal() { return new Dog(); } }
Cat类：
package cn.itcast_02; public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } }
Cat工厂类：
package cn.itcast_02; public class CatFactory implements Factory { @Override public Animal createAnimal() { return new Cat(); } }
测试类：
package cn.itcast_02; public class AnimalDemo { public static void main(String[] args) { // 需求：我要买只狗 Factory f = new DogFactory(); Animal a = f.createAnimal(); a.eat(); System.out.println("-------"); //需求：我要买只猫 f = new CatFactory(); a = f.createAnimal(); a.eat(); } }
package cn.itcast11; /** * Created by gao on 16-1-7. */ public class Student { // 构造私有 private Student(){ } // 静态方法只能访问静态成员变量，加静态; 为了不让外界直接访问修改这个值，加private private static Student s = new Student(); // 提供公共的访问方式 // 为了保证外界能够直接使用该方法，加静态 public static Student getStudent(){ return s; } }
测试类：
package cn.itcast11; /** * Created by gao on 16-1-7. */ /* * 单例模式：保证类在内存中只有一个对象。 * * 如何保证类在内存中只有一个对象呢? * A：把构造方法私有 * B:在成员位置自己创建一个对象 * C:通过一个公共的方法提供访问 */ public class StudentDemo { public static void main(String[] args) { // Student s1 = new Student(); // Student s2 = new Student(); // System.out.println(s1 == s2); // false Student s1 = Student.getStudent(); Student s2 = Student.getStudent(); System.out.println(s1 == s2); //true System.out.println(s1); // cn.itcast11.Student@6ffe8714 System.out.println(s2);// cn.itcast11.Student@6ffe8714 } }
package cn.itcast11; /** * Created by gao on 16-1-7. */ public class Teacher { private Teacher(){} private static Teacher t = null; public synchronized static Teacher getTeacher(){ if (t == null){ t = new Teacher(); } return t; } }
测试类：
package cn.itcast11; /** * Created by gao on 16-1-7. */ /* * 单例模式： * 饿汉式：类一加载就创建对象 * 懒汉式：用的时候，才去创建对象 * * 面试题：单例模式的思想是什么?请写一个代码体现。 * * 开发：饿汉式(是不会出问题的单例模式) * 面试：懒汉式(可能会出问题的单例模式) * A:懒加载(延迟加载) * B:线程安全问题 * a:是否多线程环境 是 * b:是否有共享数据 是 * c:是否有多条语句操作共享数据 是 */ public class TeacherDemo { public static void main(String[] args) { Teacher t1 = Teacher.getTeacher(); Teacher t2 = Teacher.getTeacher(); System.out.println(t1 == t2); //true System.out.println(t1); //cn.itcast11.Teacher@6ffe8714 System.out.println(t2); //cn.itcast11.Teacher@6ffe8714 } }
标签：
原文地址：http://www.cnblogs.com/yangyquin/p/5110675.html
