Java学习day10

单例设计模式

    设计模式：设计模式就是对普遍常见问题的通用的解决办法。

    核心思想：保证一个类在内存中的对象的唯一性。

    如何编写单例类：

    1.不让外界创建对象

    2.自己类内部来创建这个对象

    3.给类外部提供一个获取该类对象的方法

    单例的实际实现：    

    1.饿汉式

    只要该类被加载 就会在方法区的静态区中创建本类的对象

    代码展示：

class Single{
	// 声明一个本类的对象
	private static Single single = new Single(); 
	
	// 构造方法私有化
	private Single() {
		
	}
	
	// 对外提供一个访问的方法
	public static Single getInstance() {
		return single;
	}
}

    2.懒汉式（延迟加载）

    在类加载时不会创建对象，只有调用了获取该类对象方法的时候才会创建该类的对象

    代码展示：

class Single{
	// 声明一个本类对象的引用
	private static Single single = null;
	
	private Single() {
		
	}
	
	// 获取对象的方法
	public static Single getInstance() {
		// 判断 当这个对象不存在的时候 再创建
		if(single == null) {
			single = new Single();
		}
		return single;
	}
}    

    需要注意的是：使用懒汉式时，在多线程并发访问时，会出现线程安全问题。

抽象类

    关键字：abstract

    abstract修饰类，被修饰的类就是抽象类，abstract修饰方法，被修饰的方法就是抽象方法。

    抽象的特点：

    1.抽象的方法没有方法体，必须由抽象关键字所修饰。

    2.抽象方法一定存在于抽象类中。

    3.抽象类不可以实例化。因为调用抽象方法没有意义。

    4.子类必须覆盖抽象类的所有抽象方法后，子类才能实例化，否则该子类还是抽象类。

    5.抽象类在创建时使用多态的形式进行创建

    抽象类中有：

    1.可以有变量、常量；

    2.可以有构造方法（为了保证子类在继承时的完整性）；

    3.可以有抽象方法和成员方法。

    注意：abstract与final、private、static关键词组合。

模板设计模式

    大部分东西都一样，只需要修改一部分

    使用抽象类和抽象方法实现

    例如：

abstract class CalculateTime{
	// 计算时间模板
	public void calculateTime() {
		long start = System.currentTimeMillis();
		// 执行某一个程序
		fun();
		long end = System.currentTimeMillis();
		System.out.println("程序运行时间为" + (end - start) + "毫秒");
	}
	
	// 抽象方法
	public abstract void fun();
}

class Test extends CalculateTime{
	
	// 重写了计算时间类中的abstract方法
	@Override
	public void fun() {
		for (int i = 1; i <= 1000; i++) {
			for (int j = 1; j <= 1000; j++) {
				System.out.println(i + j);
			}
		}
	}
	
}

接口

    接口相当于一个规则、规范，是需要来遵守的。

    接口使用关键字interface来定义。

    特点：

    1.只可以声明抽象方法

    2.可以声明常量，声明变量时，默认是 public static final 修饰

    3.接口只能用来实现（不能继承）

    4.接口中没有构造方法

    5.声明抽象方法时，默认是public abstract（可省略）

    接口的编译和类相同，也会被翻译为.class文件执行。

    接口的实现：使用implements关键字来实现。

    接口的简单实例：

interface InterA{
	public static final int num = 10;
	public abstract void fun();
}

class InterAImpl implements InterA{

	@Override
	public void fun() {
		System.out.println("我是实现类的fun方法");
	}
	
}

    抽象类和接口的区别：

    1.使用方法：抽象类需要被继承，使用extends，接口则是被实现，使用implements。

    2.成员变量：抽象类中可以是常量也可以是变量，接口中只能是常量。

    3.成员方法：抽象类中可以是成员方法，接口中只能是抽象方法（JDK1.8后，加入了静态方法和默认方法）

    4.构造方法：抽象类中有构造方法，接口中没有

    类与接口之间的关系：实现关系，允许多实现。

    接口之间的关系：继承关系，可以多继承。