Java设计模式(单例设计,模板设计模式),抽象类和接口

一.设计模式

一.单例设计模式

设计模式(设计思想)

单例设计模式(单实例)(单对象)

核心: 在程序运行当中,无论怎样创建该对象,该对象都有且只有一个存在

写单例对象的**思路**

1.首先对象不能让用户自己创建(不能在本类以外创建)(构造方法私有化)

2.对象应该在类的内部创建

3.开放一个让用户在类外,可以拿到对象的方法

单例形式:饿汉式单例 懒汉式单例

区别: 创建单例对象的时机不同

恶汉式单例:不管你使用不使用开方法,都会将单例对象创建出来

懒汉式单例:只有你第一次调用开放方法,单例对象才会创建出来(延迟创建)

代码实例:

public class Kll {
    public static void main(String[] args) {
        //获取单例对象
        //获取单例对象内存图
        SingleHunger sh1 = SingleHunger.getInstance();
        SingleHunger sh2 = SingleHunger.getInstance();
        System.out.println(sh1);
        System.out.println(sh2);

}


} 

    //饿汉式单例 

    class SingleHunger{ 

        // 2.自己创建对象 

        private static SingleHunger hunger = new SingleHunger(); 

        // 1.构造方法私有化 

        private SingleHunger() { 

        } 

        // 3.开放方法 让外界能拿到对象 

        //外界不可能创建对象调用成员方法,所以要使用静态方法 

        //获取单例对象 方法名一般用getInstance 

        public static SingleHunger getInstance() { 

            return hunger; 

        } 

    } 

    //不完整式懒汉式单例(还不太完整,后边会接着讲的,需要加双锁) 

    class SingleL{ 

        private static SingleL l = null;//声明一个本类对象的引用 

        //私有化构造方法 

        private SingleL(){ 

        } 

        //开放访问的方法 

        public static SingleL getInstance() { 

            //判断是否创建了对象 

            if (l == null) { 

                //创建对象 

                l = new SingleL(); 

            } 

            return l; 

        } 

    }

内存运行图:

二.模板设计模式

模板设计模式

当你的程序大部分都相同,只有少部分需要修改时,可以使用模板设计模式(利用抽象类)

代码实例:

public class Kll {
    public static void main(String[] args) {
        Time time = new Loop();
        time.time();


}


} 

/*打印一个程序的执行时间(使用模板设计模式) 

 * 获取系统当前时间 

 * System.currentTimeMillis();//long类型,单位是毫秒 

 */

//计算程序执行时间模板 

abstract class Time{ 

    //计算时间的方法 

    public void time() { 

        //获取当前世间 

        long start = System.currentTimeMillis(); 

        //程序 

        program(); 

        //程序结束时间 

        long stop = System.currentTimeMillis(); 

        //打印执行时间 

        System.out.println(“执行时间:”+(stop - start)); 

    } 

    public abstract void program(); 

} 

class Loop extends Time{ 

    @Override 

    public void program() { 

        for (int i = 1; i <= 9; i++) { 

            for (int j = 1; j <= i; j++) { 

                System.out.print(j+“*”+i+“=”+i*j+“\t”); 

            } 

            System.out.println(); 

        }

}


}

二.抽象类

抽象:不知道该怎么具体描述该事物

关键词 abstract

修饰类 抽象类

修饰方法 抽象方法

注意:

1.抽象方法 没有实现部分

2.抽象方法 必须在抽象类中才能声明

3.抽象类中可以没有抽象方法

4.抽象类不能直接创建出对象 可以使用多态的形式创建对象

5.抽象类可以被继承,子类必须实现实现抽象类中的抽象方法

抽象类中可以有:

1.常量 变量

2.抽象方法

3.成员方法

4.构造方法

代码实例:

abstract关键字与哪儿些关键字不能共存?

private 不能

private 修饰抽象方法,子类就不能实现了抽象方法了,就是失去了存在的价值

final 不能

final 修饰抽象方法,就不能重写了,抽象方法就失去了存在的价值

static 不行

static 修饰抽象方法 就可以直接使用类名调用,但是抽象方法没有实现部分

public class Kll {
    public static void main(String[] args) {
        //抽象类可不可以创建对象 不能
        //抽象类有没有构造方法
        //抽象类如何使用
        //Animal animal = new Animal();
        //可以使用多态的形式创建对象
        Animal a =new Cat();
        a.eat();
        //向下转型
        Cat cat = (Cat)a;
        cat.mouse();
    }
}
abstract class Animal{
    //常量
    final static int num = 10;
    //无参构造方法
    public Animal() {
        System.out.println("父类无参构造方法");
    }
    //声明抽象方法吃
    public abstract void eat();
    //成员方法
    public void speak() {
    }
}
class Cat extends Animal{
    //实现抽象方法
    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
    //特有方法
    public void mouse() {
        System.out.println("抓老鼠");
    }
}

三.接口

接口

狭义:

关键字 interface 来定义接口

interface 接口名{}

广义:接口相当于一个规范 需要人来遵守

注意:

1.使用接口时,不是用继承,需要关键词 implements(实现)

2.接口类 不能直接创建对象

3.接口类不能声明成员方法

4.接口类 不能声明构造方法

5.使用多态的方式创建对象

接口中可以写:

1.只能写抽象方法(不太完善,后边会说的)

2.并且可以省去public和abstract两个关键词

3.只能写静态常量 并且可以省略public static final 三个关键词

代码实例:

public class Kll {
    public static void main(String[] args) {
        //使用多态的形式创建对象
        InterA aImpl = new InterAImpl();
        //
        aImpl.fun();
    }

}
    //声明一个接口
    interface InterA{
        public static final int num = 10;
        //抽象方法
        public abstract void fun();
    }
    //实现接口
    //实现接口类的类名规范:类名后缀Impl
    class InterAImpl implements InterA{
        //实现接口中的抽象方法
        @Override
        public void fun() {
            //num = 14;
            System.out.println(num);
        }

}</code></pre></div></article><body></body></html>