面向对象的一些重要设计模式：
1）简单工厂模式：
简单来讲就是创建一个工厂类并提供一些静态方法间接的去创建具体类对象
下面我们用一个例子来简单说明一下：
例如：
先创建一个抽象Animal类：
package com.westos_01;
/**
*创建一个抽象动物类，并提供抽象方法
*/
public abstract class Animal {
public abstract void eat() ;
}
再创建两个子类：
package com.westos_01;
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗爱吃骨头...");
}
}
package com.westos_01;
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫爱吃鱼...");
}
}
再去创建一个工厂类：
package com.westos_01;
/**
*创建一个动物工厂类
*并提供一些静态方法
*/
public class AnimaiFactory {
//创建该类的私有无参构造,使它不能在创建类对象
private AnimaiFactory() {
}
/*
//创建一个返回狗类的静态方法
public static Dog createDog() {
return new Dog();
}
//创建一个返回猫类的静态方法
public static Cat createCat() {
return new Cat();
}
*/
//改进方法
public static Animal createAnimal(String type) {
if("cat".equals(type)) {
return new Cat();
}else if("dog".equals(type)) {
return new Dog();
}
return null;
}
}
最后创建一个测试类：
package com.westos_01;
/**
* @author 杰哥
*简单工厂模式--->静态工厂方法模式
* 创建一个工厂类：
* 工厂类提供一些静态方法,间接的去创建具体的对象
*/
public class AnimalDome {
public static void main(String[] args) {
/*
//**
* 创建工厂类的优点：
* 不需要刻意的去创建具体类的对象，把它交给工厂类去创建就可以了
* 创建工厂类的弊端：
* 如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
*
//调用工厂类的静态方法
Dog dog = AnimaiFactory.createDog();
Cat cat = AnimaiFactory.createCat();
dog.eat();
cat.eat();
*/
/**
* 所以我们需要对上述的问题进行改进优化
*/
Animal dog = AnimaiFactory.createAnimal("dog");
dog.eat();
//这里并没有返回Animal类，只是将它给了dog
dog=AnimaiFactory.createAnimal("cat");
dog.eat();
Animal cat = AnimaiFactory.createAnimal("cat");
cat.eat();
//当我们在createAnimal方法中输入的类型并没有创建，我们应该进行非空判断
cat=AnimaiFactory.createAnimal("pig");
if(cat!=null) {
cat.eat();
}else {
System.out.println("您输入的类型不存在，请重新输入...");
}
}
}
运行结果：
狗爱吃骨头...
猫爱吃鱼...
猫爱吃鱼...
您输入的类型不存在，请重新输入...
上面学习了一个简单工厂模式，下面我们看一个工厂方法模式：
工厂方法模式
提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)
具体对象的创建工作由继承抽象工厂的具体类实现
优点:
客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
弊端:
书写代码量大了!
下面我们用代码实现：
创建一个抽象动物类：
package com.westos_02;
public abstract class Animal {
//创建抽象方法
public abstract void play();
}
创建两个子类继承它
package com.westos_02;
public class Dog extends Animal{
@Override
public void play() {
System.out.println("狗喜欢玩泥巴...");
}
}
package com.westos_02;
public class Cat extends Animal{
@Override
public void play() {
System.out.println("猫喜欢玩泥鳅...");
}
}
创建一个工厂接口：
package com.westos_02;
/**
*创建一个工厂接口
*然后让它的子实现类去实现它，
*这些子实现类就是Animal类的子类的工厂类
*/
public interface Factory {
public abstract Animal createAnimal();
}
创建两个子工厂实现类：
package com.westos_02;
public class DogFactory implements Factory{
@Override
public Animal createAnimal() {
return new Dog();
}
}
package com.westos_02;
public class CatFactory implements Factory{
@Override
public Animal createAnimal() {
return new Cat();
}
}最后创建一个测试类：
package com.westos_02;
/**
*工厂方法模式
* 提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)
* 具体对象的创建工作由继承抽象工厂的具体类实现
*
*优点:
* 客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，
* 如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
弊端:
书写代码量大了!
*
*
*/
public class AnimalDome {
public static void main(String[] args) {
//使用多态的方式去创建Factory接口的对象
Factory f=new DogFactory();
Animal dog = f.createAnimal();
dog.play();
System.out.println("---------------");
dog=new CatFactory().createAnimal();
dog.play();
System.out.println("----------------");
Factory f2=new CatFactory();
Animal cat = f2.createAnimal();
cat.play();
}
}
运行结果：
狗喜欢玩泥巴...
---------------
猫喜欢玩泥鳅...
----------------
猫喜欢玩泥鳅...
设计模式之单例模式
单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!
单例模式分类:
1)饿汉式 2)懒汉式(类似于多线程环境..)
两种分类在设计上几乎一样:
1)定义个类,将该类的无参构造方法私有化
2)在该类的成员位置创建该类对象 并且一定要私有化,防止外界更改这个对象
3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰
我们先来看看饿汉式：
package com.westos_03;
public class Student {
/*
//创建学生类无参构造
public Student() {
}
*/
//进行改进
//创建私有化学生类无参构造,目的是不让它创建对象
private Student() {
}
//创建学生类对象，因为下面的方法是静态的，返回了s，所以创建学生类对象时也得添加static
private static Student s=new Student();
//创建学生类方法,添加static可以直接用类名调用方法
public static Student getStudent() {
return s;
}
}
package com.westos_03;
/**
* @author 杰哥
*
*饿汉式:
* 在加载那个类的时候,对象的创建工作就已经完成了!
*
*优点：线程是安全的，加载类时对象已经创建好了，而且不会在变
*缺点：无论需不要，只要加载类就会创建对象，在内存上有点浪费多余
*/
public class StudentDome {
public static void main(String[] args) {
/*
//创建学生类对象
Student s1=new Student();
Student s2=new Student();
System.out.println(s1==s2);//运行结果：false
*/
/**
* 当我们给学生对象赋值为null时
* s1,s2的运行结果都是null
* 为了防止外界随意更改数据我们应该在创建学生类时让它私有化
*/
// Student.s=null;
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2);
System.out.println(s1);
System.out.println(s2);
}
}
运行结果：
true
com.westos_03.Student@70dea4e
com.westos_03.Student@70dea4e
让我们再来看看懒汉式：
懒汉式:
符合单例模式核心思想
1)自定义一个类,将无参构造私有化
2)在成员位置声明变量
3)提供公共静态功能,在里面判断的创建该类对象,返回该类对象
如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)
如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)
面试题:
你使用过单例模式吗?简单介绍一种单例模式,请用代码设计
面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..
懒汉式(延迟加载 -->懒加载)
可能会出现问题
---> 多线程的问题
1)是否是多线程环境
2)是否有共享数据
3)是否有多条语句对共享数据进行操作 (使用同步机制进行操作)
例如：
package com.westos_03;
/**
* @author 杰哥
*懒汉式与饿汉式的相同在于：
* 创建私有无参构造
* 创建私有类对象
* 创建公共静态方法
*
*不同之处在于：
* 饿汉式随着该类的加载会一直创建类对象
* 懒汉式会根据需求来创建类对象
*/
public class Teacher {
//创建私有Teacher类无参构造
private Teacher() {
}
//创建私有变量，先赋值为null
private static Teacher t=null;
/*
//创建公共静态方法
public static Teacher getTeacher() {
//加入同步锁
synchronized(Teacher.class) {
if(t==null) {
t= new Teacher();
}
return t;
}
}
*/
public synchronized static Teacher getTeacher() {
if(t==null) {
t=new Teacher();
}
return t;
}
}
package com.westos_03;
public class TeacherDome {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1==t2);
System.out.println(t1);
System.out.println(t2);
}
}
运行结果：
true
com.westos_03.Teacher@70dea4e
com.westos_03.Teacher@70dea4e
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
public static Runtime getRuntime()返回与当前 Java 应用程序相关的运行时对象
public Process exec(String command)
throws IOException在单独的进程中执行指定的字符串命令。
例如：
package com.westos_03;
import java.io.IOException;
public class RuntimeDome {
public static void main(String[] args) throws IOException {
//常见RunTime类实例
Runtime rt=Runtime.getRuntime();
//开启某一个进程
rt.exec("calc");
rt.exec("notepad") ;
rt.exec("mspaint") ;
}
}