java面向对象之设计思想

模板设计思想

模板设计模式(思想)

程序由确定的部分 和 不确定的部分组成

这时可以把不确定的部分抽象出来

然后对外开放可以放可以访问的方式

重写抽象方法 来完成不确定部分

需求 ：

计算一个程序的执行时间

abstract class GetTime{
    public void getTime(){
        long s = System.currentTimeMillis();
        fun();


        long s = System.currentTimeMillis();
        System.out.println(s-m+"毫秒");
    }
        // 把要执行的程序抽取成方法
    // 不知道怎么写实现部分 可以先不写
    // 定义成抽象方法 强制子类去重写方法
    public abstract void fun();

}
// 使用继承
class subTime extends GetTime{
    // 重写fun方法
    public void fun() {
        // TODO Auto-generated method stub
        // 写20000次循环
        for (int i = 0; i < 20000; i++) {
            System.out.println("i");
        }

    }
}

复合

一个类中有另一个类的对象

在一个类中 成员变量 如果还包括一些具体的属性

这个成员变量需要被定义成一个类 那么就需要用

复合 的思想

举个例子

需求
1.人类 吃

2.男人类 姓名 性别 有女朋友 吃肉 介绍女朋友是谁

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

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

人类

abstract class People{
    public String name;
    public String gender;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public People(){

    }
    public People(String name,String gender){
        this.name = name;
        this.gender = gender;
    }

    public abstract void eat();
    public abstract void have();
    public abstract void intruduce();
    }

男人类

abstract class People{
    public String name;
    public String gender;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public People(){

    }
    public People(String name,String gender){
        this.name = name;
        this.gender = gender;
    }

    public abstract void eat();
    public abstract void have();
    public abstract void intruduce();
    }


class Man extends People implements MakeMoney{
    // 定义一个成员变量 是女人类的对象
    private  Woman gf;

    public Man(){

    }
    public  Man(String name,String gender) {
        super(name, gender);
    }
    // 给 gf 写 set/get方法
    public void setGF(Woman gf) {
        this.gf = gf;
    }
    public Woman getGF() {
        return gf;
    }

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("吃肉");
    }

    @Override
    public void have() {
        // TODO Auto-generated method stub
        System.out.println("我有女朋友");
    }

    @Override
    public void intruduce() {
        // TODO Auto-generated method stub
        System.out.println("我是："+this.getName());
        System.out.println("我的女朋友是:"+gf.getName());
    }

    @Override
    public void makeMoney() {
        // TODO Auto-generated method stub
        System.out.println("等我几年 我会换掉你的 ");
    }


}

女人类

class Woman extends People{
    private Man bf;

    public Woman() {

    }
    public Woman(String name,String gender) {
        super(name, gender);
    }
    public void setBF(Man bf) {
        this.bf = bf;
    }
    public Man getBF() {
        return bf;
    }

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("吃素");
    }

    @Override
    public void have() {
        // TODO Auto-generated method stub
        System.out.println("有男朋友");
    }

    @Override
    public void intruduce() {
        // TODO Auto-generated method stub
        System.out.println("我是："+this.getName());
        System.out.println("我的男朋友是:"+bf.getName());
    }
    // 整容
    public void zhengRong(String body) {
        intruduce();
        System.out.println("我要整容"+body);

    }
    public void letMakeMoney(Man bf) {
        System.out.println("让"+bf.name +"挣钱");
    }



}

测试类

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Man man = new Man("凉凉","男");
        Woman woman = new Woman("如花","女");

        //给凉凉找个妹子
        // 创建一个女的出来
        //

        man.setGF(woman);
        man.intruduce();
        //找个男的
        woman.setBF(man);

        woman.intruduce();
        //
        Woman gf = man.getGF();
        //获取类的对象后就可以使用找个类的对象中所有方法
        gf.zhengRong("丰唇");
        //让男的去挣钱
        gf.letMakeMoney(man);
        //从女的类的对象 中 获取bf
        Man bf = woman.getBF();
        bf.makeMoney();

    }

}

单例设计思想–(重点在于思想)

核心：在整个程序执行期间 不管你创建这个类的对象多少个

整个程序有且只有一个 该类的对象 单实例对象

手机听歌

不管你是前台听歌 还是后台听歌 访问的都是

一个对象(同一个音乐播放器)

如何写一个单例思路

1.不让外界创建对象 (把构造犯法 私有化)

2.自己来创建这个对象(写个创建对象自定义方法)

3.对外开放访问该对象权限 把对象的访问方法

(只对外提供获取方法)

他在内存中的表现

// 单例类(饿汉式)
class Single{
    //创建单例对象
    private static Single single = new Single();
    // 私有化构造方法
    private Single() {

    }
    // 对外暴露访问接口(get方法)
    public static Single getInstance() {
        return single;
    }
}
// (单例)懒汉式 与 饿汗式写法不同
// 模板 工厂 反射工厂 适配器
/*
 * 懒汉式特点：延迟加载(懒加载)
 * 只有你调用单例方法时 才会创建对象
 * 而不是跟恶汉式一样随着类的加载而加载
 * 
 */
class SingleLan{
    // 创建
    // 私有化构造方法
    // 对外开放访问的方法
    private static SingleLan single = null; ;
    private SingleLan() {

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