Java语法回顾大结局之设计模式
读了那么多年的书让我明白一个道理。人要稳重,不要想到啥就做啥。做一行越久即使你不会,几年之后慢慢的你也会了,加上一点努力你或许你能成为别人眼中的专家。
设计模式简介
通过很多类抽取出来的一个模型,即设计模式。
设计模式一般分为三种:
创建型:创建对象。工厂模式,单例模式。
结构型:对象间的关系。装饰模式。
行为型:对象能够做什么。模板模式。
- 工厂模式(简单工厂模式,工厂方法模式)
- 单例模式(饿汉式,懒汉式)
- 装饰模式
- 模板方法模式
工厂模式
比如说,我们现在有很多动物类,猫,狗,猪...而这些动物有相同的行为,eat()。抽取一个共同的父类。动物。
简单工厂模式
需求,有一个动物类,动物类中包括,狗,猫……同样,动物都具备吃的方法。
Animal
|--Dog
|--Cat
AnimalFactory
public static Animal createAnimal(String type){
if("dog".equals(type)){
return new Dog();
}else if("cat".equals(type)){
return new Cat();
}else {
return null;
}
}
动物类
public abstract class Animal {
//让具体子类去实现
public abstract void eat();
}
动物的子类(狗和猫)
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃老鼠");
}
}
动物的工厂类
public class AnimalFactory {
//工厂类,我不希望你创建我的对象,所以把构造方法私有化
private AnimalFactory() {
}
//创建狗的对象
// public static Dog createDog() {
// // Dog d = new Dog();
// // return d;
// 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;
}
}
}
动物类的测试类
public class Test {
public static void main(String[] args) {
// Dog dog = new Dog();
// Cat cat = new Cat();
// dog.eat();
// cat.eat();
//通过抽象类来实现
// Animal a = new Dog();
// a.eat();
// a = new Cat();
// a.eat();
// 通过工厂类来实现,创建对象交个工厂类,让他来初始化一些操作。
// Dog dog = AnimalFactory.creatDog();
// dog.eat();
//面向对象的设计原则:开闭原则。对修改关闭,对扩展开放。所以我们还要改一下动物的工厂类
// Object dog = AnimalFactory.obj("dog");注意返回的不是obj对象,需要修改动物工厂类
Animal dog = AnimalFactory.creatAnimal("dog");
dog.eat();
//但是我们发现这还不是工厂模式,这只是一步步趋向工厂模式
}
}
工厂方法模式
工厂方法模式:
Animal
|--Dog
|--Cat
|--Pig
AnimalFactory
|--DogFactory
|--CatFactory
|--PigFactory
动物类
public abstract class Animal {
public abstract void eat();
}
动物子类——狗
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
动物工厂类
public abstract class AnimalFactory {
private AnimalFactory() {
}
//只提供一个创建工厂类的方法,让其子类去实现这个工厂类
public abstract Animal creatAnimal();
}
动物工厂类的子类——狗
public class DogFactory extends AnimalFactory {
@Override
public Animal creatAnimal() {
return new Dog();
}
}
动物类的测试类
public class Test {
public static void main(String[] args) {
//通过new狗的工厂类,拿到动物工厂类的对象
AnimalFactory af = new DogFactory();
Animal dog = af.creatAnimal();
dog.eat();
//以此类推,可以通过af动物工厂类去new其他动物的工厂类。
}
}
单例模式
就是指类在内存中只能有一个对象。
举例:windows的打印服务,网站计数器
应用:线程池,数据库连接池
面试题:请写出一个单例设计模式。
单例模式的基本要求:
类在内存中只能有一个对象。
A:外界不能够随意创建对象。把构造方法私有
B:类本身要创建一个对象。
C:通过公共的方式提供给别人。
单例模式之饿汉式
饿汉式:类加载就创建对象(开发用)
饿汉式代码测试
public class Student {
// 把构造方法私有,是为了不让外界随意创建
private Student() {
}
//但是类本身需要创建一个对象
// 为了不让外界通过类名直接访问s成员变量,就加私有
private static Student s = new Student();
// 提供公共的方式让别人使用
// 为了让外界能够直接通过类名访问该方法,需要对该方法加静态
public static Student getStudent(){
// return new Student(); //不能在这里new Student,那样就有问题了。
return s;
}
//提供一个方法做测试,看地址值是否一样。
public void show() {
System.out.println(s.toString());
}
}
public class Test {
public static void main(String[] args) {
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
s1.show();//内存地址值是一样的。
s2.show();
System.out.println(s1==s2);//true
}
}
单例模式之懒汉式
public class Teacher {
private Teacher() {
}
//初始值为null
private static Teacher t = null;
//这只是面试时用,实际开发时不用,因为它会引起线程安全问题。
public synchronized static Teacher getTeacher(){
// t1,t2,t3三个线程过来了
// 如果t是null的时候,才创建对象
if (t == null) {
//t1进来了,CPU的执行权就被t2抢到了,同理t3
t = new Teacher();
}
return t;
}
}
public class TeacherTest {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1 == t2);// true
t1.show();
t2.show();
}
}
装饰模式
对类原有的功能进行了修饰或者扩充。
装饰设计模式。
A:被装饰的抽象事物 Phone
B:具体的事物 PhoneImpl
实现Phone接口,具体实现类
C:装饰类 PhoneDecorate
实现Phone接口,调用实现。
private Phone phone;
public PhoneDecorate(Phone phone) {
this.phone = phone;
}
@Override
public void call() {
this.phone.call(); // 具体的手机打电话功能
}
Phone(接口)
|--PhoneImpl(具体实现类)
|--PhoneDecorate(抽象类)
|--ColorPhoneDecorate(具体装饰类)
|--GuangGaoPhoneDecorate(具体装饰类)
抽象的手机类
public interface Phone {
public abstract void call();
}
手机的实现类
public class PhoneImpl implements Phone {
@Override
public void call() {
System.out.println("手机打电话");
}
}
手机抽象装饰类
public abstract class PhoneDecorate implements Phone {
private Phone p;
public PhoneDecorate(Phone p) {
this.p = p;
}
@Override
public void call() {
this.p.call();
}
}
手机装饰类的实现
//想手机具备什么样的功能,你就可以创建什么样的类,继承自装饰手机类
public class CanLIngPhone extends PhoneDecorate {
public CanLIngPhone(Phone p) {
super(p);
}
@Override
public void call() {
System.out.println("播放彩铃");
super.call();
}
}
手机类的测试类
public class Test {
public static void main(String[] args) {
// PhoneImpl pi = new PhoneImpl();
// pi.call();
// PhoneDecorate phoneDecorate = new PhoneDecorate(new PhoneImpl());
//直接new子类的实现
CanLIngPhone canLIngPhone = new CanLIngPhone(new PhoneImpl());
canLIngPhone.call();
}
}
模板方法模式
在此不做赘述,说简单点,就是相同功能抽取在一起。
结束语:至此,Java语法复习完成,接下来,开始学习Android基础内容。