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);
}
}