java基础学习之设计模式 十七

设计模式：
通过很多东西抽取出来的一个模型

设计模式分类：
创建型：创建对象，工厂模式，单例模式
结构型：对象间的关系，装饰模式

行为型：对象能够做什么，魔板模式

简单的工厂模式：

package fanctory;

public abstract class Animal {
public abstract void eat();
}

package fanctory;

public class Cat extends Animal {

@Override
public void eat() {
System.out.println("猫吃鱼。。。。");
}

}

package fanctory;

public class Dog extends Animal{

@Override
public void eat() {
System.out.println("狗吃骨头");
}

}

AnimalFactory

package fanctory;

public class AnimalFactory {
private AnimalFactory() {
// TODO Auto-generated constructor stub
}
public static Dog getDog(){
return new Dog();
}

public static Cat getCat(){
return new Cat();
}

public static Animal creatAnimal(String type){
if("dog".equals(type)){
return new Dog();
}else if("cat".equals(type)){
return new Cat();
}else{
return null;
}
}
}

AnimalTest

package fanctory;
/**
*
* @author Angus
*	工厂模式
*/
public class AnimalTest {
public static void main(String[] args) {
//		Dog d = new Dog();
//		d.eat();

//可以考虑别人来创建对象，既工厂创建。。。
Dog d = AnimalFactory.getDog();
d.eat();

Cat c = AnimalFactory.getCat();
c.eat();

//这样基本的工厂模式完成。。
//但是发现如果有新的动物需要添加，我们就要新建一个类，修改工厂类，添加功能

Animal a = AnimalFactory.creatAnimal("dog");
a.eat();
}
}

工厂方法模式

package factory2;

public abstract class AnimalFactory {
public abstract Animal creatAnimal();
}

package factory2;

public class DogFactory extends AnimalFactory{

@Override
public Animal creatAnimal() {

return new Dog();
}

}

package factory2;

public class CatFacttory extends AnimalFactory{

@Override
public Animal creatAnimal() {
// TODO Auto-generated method stub
return new Cat();
}

}

AnimalTest

package factory2;
/**
*
* @author Angus
*	工厂方法模式
*	 这样没添加一个动物 只需要增加一个动物类和一个动物工厂类  不会修改代码。。
*	java思想：扩展不修改。。
*/
public class AnimalTest {
public static void main(String[] args) {
//狗
AnimalFactory af = new DogFactory();
Animal a = af.creatAnimal();
a.eat();

//猫
af = new CatFacttory();
a = af.creatAnimal();
a.eat();

}
}

单例模式

饿汉式：

package single;
/**
* 单例模式
* @author Angus
* 在内存中只存在一个对象。。。
* 1：外界不能随意创建对象,私有构造方法
* 2;类本身创建一个对象
* 3：通过公共的方式给别人使用
*/
public class SingleDemo {

public static void main(String[] args) {
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2); //true

s1.show();
s2.show();
}

}
/*
* 饿汉式
*/
class Student{
//私有构造方法 这样就无法new对象
private Student(){

}
//私有静态防止外部使用
private static Student s = new Student();
//公共方法使用
public static Student getStudent(){
return s;
}
public void show(){
System.out.println("show");
}
}

结果：





懒汉式：

package single;
/**
* 单例模式
* @author Angus
* 在内存中只存在一个对象。。。
* 1：外界不能随意创建对象,私有构造方法
* 2;类本身创建一个对象
* 3：通过公共的方式给别人使用
*/
public class SingleDemo {

public static void main(String[] args) {
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2); //true

s1.show();
s2.show();
}

}
/*
* 懒汉式
* 延迟加载，
* 但是多线程会有安全问题，所以加锁
*/
class Student{
//私有构造方法 这样就无法new对象
private Student(){

}
//私有静态防止外部使用
private static Student s = null;
//公共方法使用
public synchronized static Student getStudent(){
if(s ==null){
s = new Student();
}
return s;
}
public void show(){
System.out.println("show");
}
}

其它模式就不多做笔记。。。重在理解。。。
至此java基础复习完毕。。。。

未来三个月到四个月内复习完j2EE所有内容。。