java -- 模板设计、复合模式、单例设计

一、模板设计思想
模板设计思想重点在于思想；
程序有确定和不确定的方法，这时候就可以把不确定的方法抽象出来，然后开放对外访问的方法，子类重写父类不确定的方法，具体实现这个不确定的方法

设计一个程序时间计算器

abstract class GetTime{
    public void getTime(){
        //  记录开始的初始时间
        long startTime = system.currentTimeMills();
        //  程序
        fun();
        //  记录程序结束的时间
        long endTime = system.currtTimeMills();
    }
    //  输出最后的程序执行的时间（结束时间 - 开始时间）0
system.out.println("程序最后执行" + （endTime - startTime） + "毫秒")
}

class SubTime extends getTime(){
    public void getTime(){
        for(int i = 0; i < 20000; i++){
            system.out.println(i);
        }
    }
}

二、复合模式设计思想

设计要求

1.人类 吃
2.男人类 姓名 性别 有女朋友 吃肉 介绍女朋友是谁
3.女人类 姓名 性别 有男朋友 吃素 介绍男朋友是谁
4.男人挣钱给女朋友花(接口实现)

// 人类
class Person{
    private string name;
    private string gender;
    //  构造方法 set/get
    public Person(){}
    public Person(string name,string gender){
        this.name = name;
        this.gender = gender;
    }
    public void setName(string name){
        this.name = name;
    }
    public string  getName(){
        return name;
    }
    public void setGender(string gender){
        this.gender = gender;
    }
    public void string getGender(){
        return gender;
    }
    //抽象成员方法
    public abstract void eat();
}
//男人类
//男人类 姓名 性别  有女朋友 吃肉 介绍女朋友是谁
class Man extends Person implements MakeManey{
//创建一个女人类的成员变量
    private Woman gf;
    //Man 构造方法
    public Man(){}
    public Man(string name, string gender){
        super(name,gender)
    }
    //  gf的set/get方法
    public void setWoman(Woman gf){
        this.gf = gf;
    }
    public Woman getWoman(){
        return gf
    }
    public void eat(){
        system.out.print("吃肉");
    }
    public void sayHi(){
        system.out.println("我是：" + this.getName)；
        system.out.println("我的女朋友是：" + gf.getName);
    }
    //接口实现
    public void makeManey(){
        system.out.println("会挣钱")
    }
}

//女人类
//女人类 姓名 性别  有男朋友 吃素 介绍男朋友是谁

class Woman extends Person{
    private Man bf;
    //构造方法
    public Woman(){}
    public Woman(string name, string gender){
        super(name,gender)
    }
    //bf  set/get
    public void setMan(Man bf){
        this.bf = bf;
    }
    public Man getMan(){
        return bf;
    }

    public void sayHi(){
        system.out.println("我是：" + this.getName);
        system.out.println("我的男朋友是：" + bf.getName);
    }
    //测试 通过男人类能不能调用女人类的方法
    public void zhengRong(string body){
        this.sayHi();
        system.out.println("我要整容" + body)
    }
}

//接口
//男人挣钱给女朋友花(接口实现)

interface MakeManey{
    public abstract void makeManey();
}

//  测试类

public static void main(string[] args){
    Man m = new Man("凉凉"，"男")；
    Woman w = new Woman("如花"，"女")；
    m.getWoman(w);
    m.sayHi();

    w.getMan(m);
    w.sayHi();

    //通过男人类创建女人类的对象，并调用女人的方法
    Woman gf = m.getWoman;
    gf.zhengRong();
    //通过女人创建男人的对象，并调用男人的方法
    Man bf = w.getMan;
    bf.makeManey();
}

练习1：

新建类：汽车类(Car) 引擎类(Engine)
汽车类特征：汽车名称carName 汽车颜色carColor 汽车价格carPrice 引擎carEngine
汽车类行为：介绍sayHi：汽车名称 汽车颜色 汽车价格 引擎名称 引擎类型
引擎类特征：引擎名称engineName 引擎类型engineType

创建轮胎类Tire
将四个轮胎装载在汽车上 输出轮胎装到汽车上的哪个位置
左前轮 右前轮 左后轮 右后轮
轮胎类
成员变量 轮胎名称tireName 轮胎类型tireType 轮胎位置tirePosition

class Car{
    private string carName;
    private string carColor;
    private string carPrice;
    //添加引擎对象作为Car的成员变量
    private Engine carEngine;
    // 轮胎式汽车的成员变量，把轮胎放到数组中
    private Tire[] tires = new Tire[4];
    //  构造方法  set/get
    public Car() {}
    public Car(String name, String color, String carPrice, Engine carEngine) {
    this.carEngine = carEngine;
    this.carPrice =carPrice;
    this.color = color;
    this.name = name;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public String getColor() {
    return color;
}
public void setColor(String color) {
    this.color = color;
}
public String getCarPrice() {
    return carPrice;
}
public void setCarPrice(String carPrice) {
    this.carPrice = carPrice;
}
// 轮胎的set/get
public void setTires(Tire[] tires) {
    this.tires = tires;
}

public Tire[] getTires() {
    return tires;
}
//需要一个方法 对汽车中的轮胎数组 一一的赋值
//定义 int position 是数组的下标 也是轮胎的位置
public void setTire(Tire[] tire, int position){
    this.tires[position] = tire;
switch (position) {
    case 1:
        tire.setTirePosition("左上");
        break;
    case 2:
        tire.setTirePosition("左下");
        break;
    case 3:
        tire.setTirePosition("右上");
        break;
    case 0:
        tire.setTirePosition("右下");
    break;
    default:
        break;
    } 
}
public void sayHi(){
    System.out.println(name); 
    System.out.println(color);
    System.out.println(carPrice);
    // 介绍引擎
    carEngine.sayHi();
    //  循环介绍轮胎
    for (int i = 0; i < tires.length; i++) {
         Tire t = tires[i];
         t.sayHi();
    }
}
}


//  引擎类
//引擎类特征：引擎名称engineName 引擎类型engineType
class Engine{
    string engineName;
    stirng engineType;

    //构造方法  set/get
    public Engine() {}
    public Engine(String engineName,String engineType) {
        this.engineName = engineName;
        this.engineType = engineType;
    }
    public String getEngineName() {
        return engineName;
    }
    public void setEngineName(String engineName) {
        this.engineName = engineName;
    }
    public String getEngineType() {
        return engineType;
    }
    public void setEngineType(String engineType) {
        this.engineType = engineType;
    }
public sayHi(){
    system.out.println(engineName);
    system.out.println(engineType);
    }
}

//轮胎类
/*
*创建轮胎类Tire 
*将四个轮胎装载在汽车上 输出轮胎装到汽车上的哪个位置
*左前轮 右前轮 左后轮 右后轮
*    轮胎类
*    成员变量 轮胎名称tireName 轮胎类型tireType  轮胎位置tirePosition
*/

class Tire{
    private string tireName;
    private string tireType;
    private string tirePosition;

    public Tire() {

}
//  轮胎出厂的时候 没有轮胎装配的位置  所以不用初始化
public Tire(String tireName,String tireType) {
    this.tireName = tireName;
    this.tireType = tireType;
}
public String getTireName() {
    return tireName;
}
public void setTireName(String tireName) {
    this.tireName = tireName;
}
public String getTireType() {
    return tireType;
}
public void setTireType(String tireType) {
    this.tireType = tireType;
}
public String getTirePosition() {
    return tirePosition;
}
public void setTirePosition(String tirePosition) {
    this.tirePosition = tirePosition;
}

public void sayHi() {
    System.out.println(tireName);
    System.out.println(tireType);
    System.out.println(tirePosition);
}
}

//测试类
public static void main(String[] args) {

    Engine engine = new Engine("v8","涡轮增压");
    Car car = new Car("奥迪R8","红的","5万",engine);



    for (int i = 0; i < 4; i++) {
        Tire tire = new Tire("米其林","干胎");
        car.setTire(tire, i);
    }
    car.sayHi();
}
}

单例设计模式 – （重点在于思想）
核心：在整个程序的执行期间，不管你创建这个类的对象多少个
整个程序有且只有一个 该类的对象 单实例对象

手机听歌（网易云 酷狗 虾米）
不管你是前台听歌 还是后台听歌 访问的都是同一个对象（同一个音乐播放器）

如何写一个单例出来？思路
不让外界来创建对象（把构造方法私有化）
自己来创建这个对象（写个创建对象自定义方法）
对外开放访问该对象权限（把对象的访问访问方法暴露出去）
（只对外提供获取方法）
(面试)

public static void main(String[] args) {
    Single s = Single.getInstence();
}
}
  //  单例类（饿汉式）
class Single{
//  创建单例对象
private static Single single = new Single();
// 私有化构造方法
private Single() {
}
//  对外暴露访问的方法（get方法）
public static Single getInstence() {
    return single;
}
}

（单例）懒汉式 与 饿汉式写法不同

懒汉式特点：
延迟加载（懒加载）
只有你调用单例方法的事后 才会创建对象
而不是跟饿汉式一样 随着类的加载而加载

class SingleLan{
//  声明一个单例对象
private static SingleLan singleLan = null;
//  私有化构造方法
private SingleLan() {

}
//  对外开放访问的方法(当用户调用get方法事后 在创建对象)
public static SingleLan getInctence() {
    //  当单例对象为空时 会创建对象
    //  一旦单例对象创建出来了就不为空
    //  所以 这个单例对象 只会创建一次
    if (singleLan == null) {
        singleLan = new SingleLan();
    }
    return singleLan;
}
}