//本文参考菜鸟教程
设计模式主要分为三大类创建型模式，结构型模式，行为型模式，本文主要讲结构型模式
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
1.适配器模式
定义： 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。
interface MediaPlayer{
fun play(audioType:String,fileName:String)
}
interface AdvancedMediaPlayer{
fun playVlc(fileName: String)
fun playMp4(fileName: String)
}
class VlcImpl:AdvancedMediaPlayer{
override fun playVlc(fileName: String) {
println("playVlc is $fileName")
}
override fun playMp4(fileName: String) {
}
}
class Mp4Impl:AdvancedMediaPlayer{
override fun playVlc(fileName: String) {
}
override fun playMp4(fileName: String) {
println("playMp4 is $fileName")
}
}
class MediaPlayerAdapter(audioType: String) :MediaPlayer{
lateinit var advancedMediaPlayer: AdvancedMediaPlayer
init {
when(audioType){
"Mp4"->{
advancedMediaPlayer = Mp4Impl()
}
"Vlc"->{
advancedMediaPlayer = VlcImpl()
}
}
}
override fun play(audioType: String, fileName: String) {
when(audioType){
"Mp4"->{
advancedMediaPlayer.playVlc(fileName)
}
"Vlc"->{
advancedMediaPlayer.playMp4(fileName)
}
}
}
}
class MediaPlayerImpl:MediaPlayer{
lateinit var mediaPlayerAdapter: MediaPlayerAdapter
override fun play(audioType: String, fileName: String) {
when(audioType){
"mp3"->{
println("自己的mp3")
}
"Mp4","Vlc"->{
mediaPlayerAdapter = MediaPlayerAdapter(audioType)
mediaPlayerAdapter.play(audioType,fileName)
}
}
}
}
总结
主要是为了一个类负责加入独立的或不兼容的接口功能
2.装饰器模式
定义：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性。
1.Component（被装饰对象的基类）
定义一个对象接口，可以给这些对象动态地添加职责。
2.ConcreteComponent（具体被装饰对象）
定义一个对象，可以给这个对象添加一些职责。
3.Decorator（装饰者抽象类）
维持一个指向Component实例的引用，并定义一个与Component接口一致的接口。
4.ConcreteDecorator（具体装饰者）
具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责。
interface Shape{
fun draw()
}
class Round:Shape{
override fun draw() {
println("round----draw")
}
}
class Circle:Shape{
override fun draw() {
println("circle----draw")
}
}
abstract class ColorShape(private val shape: Shape):Shape{
override fun draw() {
shape.draw()
}
}
class RedColorShape(private val shape: Shape): ColorShape(shape) {
override fun draw() {
super.draw()
setColor()
}
private fun setColor(){
println("设置颜色")
}
}
fun main() {
val circleColorShape = RedColorShape(Circle())
circleColorShape.draw()
val roundColorShape = RedColorShape(Round())
roundColorShape.draw()
}
3.代理模式
定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
3.1静态代理
interface House{
fun bug()
}
class HouseImpl:House{
override fun bug() {
println("买房子")
}
}
class HouseProxyImpl(private val house: House):House{
override fun bug() {
println("看房子")
house.bug()
decorateHouse()
}
private fun decorateHouse(){
println("装饰房子")
}
}
fun main() {
val houseProxyImpl = HouseProxyImpl(HouseImpl())
houseProxyImpl.bug()
}
3.2动态代理
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
代理类不用再实现接口了。但是，要求被代理对象必须有接口。
class HouseTrendsProxy(private val obj: Any):InvocationHandler{
override fun invoke(proxy: Any, method: Method?, args: Array<out Any>?): Any? {
println("买房前准备")
val result = method?.invoke(obj,args)
println("买房后装修")
return result
}
}
fun main() {
val house:House = HouseImpl()
val proxyHouseImpl:House = Proxy.newProxyInstance(House::class.java.classLoader, arrayOf(House::class.java),HouseTrendsProxy(house)) as House
proxyHouseImpl.bug()
}
4.外观模式
定义： 隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。
class CPU{
fun start(){
println("cpu start")
}
fun shutDown(){
println("cpu shut down")
}
}
class Disk{
fun start(){
println("disk start")
}
fun shutDown(){
println("disk shut down")
}
}
class Memory(){
fun start(){
println("memory start")
}
fun shutDown(){
println("disk shut down")
}
}
class Compuate(private val disk: Disk,private val memory: Memory,private val cpu: CPU){
fun start(){
disk.start()
memory.start()
cpu.start()
}
fun shutDown(){
disk.shutDown()
memory.shutDown()
cpu.shutDown()
}
}
优点 - 松散耦合，用户只需要关注门面类compuate不需要再关注子类，子类也容易扩展
5.桥接模式
定义： 将抽象部分与它的实现部分分离，使它们都可以独立地变化。
interface DrawAPI {
fun drawCircle(radius: Int, x: Int, y: Int)
}
class RedCircle() : DrawAPI {
override fun drawCircle(radius: Int, x: Int, y: Int) {
println(
"Drawing Circle[ color: red, radius: "
+ radius + ", x: " + x + ", " + y + "]"
)
}
}
class GreenCircle() : DrawAPI {
override fun drawCircle(radius: Int, x: Int, y: Int) {
println(
"Drawing Circle[ color: green, radius: "
+ radius + ", x: " + x + ", " + y + "]"
)
}
}
abstract class BridgeShape protected constructor(protected var drawAPI: DrawAPI) {
abstract fun draw()
}
class BridgeCircle(private val x: Int, private val y: Int, private val radius: Int,drawAPI: DrawAPI) :
BridgeShape(drawAPI) {
override fun draw() {
drawAPI.drawCircle(radius, x, y)
}
}
fun main() {
val redCircle: BridgeShape = BridgeCircle(100, 100, 10, RedCircle())
val greenCircle: BridgeShape = BridgeCircle(100, 100, 10, GreenCircle())
redCircle.draw()
greenCircle.draw()
}
6.组合模式
定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性
class Employee(private val name: String, private val dept: String, private val salary: Int) {
private val subordinates: MutableList<Employee>
fun add(e: Employee) {
subordinates.add(e)
}
fun remove(e: Employee) {
subordinates.remove(e)
}
fun getSubordinates(): List<Employee> {
return subordinates
}
override fun toString(): String {
return ("Employee :[ Name : " + name
+ ", dept : " + dept + ", salary :"
+ salary + " ]")
}
//构造函数
init {
subordinates = ArrayList()
}
}
7享元设计模式
定义：主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。
interface IFlyweight {
fun print()
}
class Flyweight(val id: String) : IFlyweight {
override fun print() {
println("Flyweight.id = $id ...")
}
}
class FlyweightFactory {
private val flyweightMap: MutableMap<String?, IFlyweight?> = HashMap<Any?, Any?>()
fun getFlyweight(str: String?): IFlyweight {
var flyweight = flyweightMap[str]
if (flyweight == null) {
flyweight = Flyweight(str!!)
flyweightMap[str] = flyweight
}
return flyweight
}
fun getFlyweightMapSize(): Int {
return flyweightMap.size
}
}
fun main(args: Array<String>) {
val flyweightFactory = FlyweightFactory()
val flyweight1 = flyweightFactory.getFlyweight("A")
val flyweight2 = flyweightFactory.getFlyweight("B")
val flyweight3 = flyweightFactory.getFlyweight("A")
flyweight1.print()
flyweight2.print()
flyweight3.print()
println(flyweightFactory.getFlyweightMapSize())
}
