超牛牪犇Java之单例设计模式和模(mú)板设计模式&接口

一.单例设计模式(是一种思想)

核心思想:在程序的运行当中该类的对象不管怎么创建始终保持有且只有一个该类的对象

编写单例类思路:

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

2.自己类内部来创建这个对象(让这个对象只创建一次)

3.给类外部提供一个获取该对象的方法(相当于提供一个get方法)

1️⃣.饿汉式

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

example:

class SingleHungry{
	//声明一个本类的对象
	private static SingleHungry singleHungry = new SingleHungry();

	//构造方法私有化
	private SingleHungry() {
		
	}
	//对外提供一个访问的方法(就是为了返回本类的对象)
	public static SingleHungry getInstance() {
		return singleHungry;
	}
}

2️⃣.懒汉式(延迟加载)

在类被加载的时候不会去创建对象

只有当你调用了获取该类对象的方法的时候才会创建该类的对象

(不完整线程安全问题双锁控制可以解决)

example:

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

二.抽象类

关键词:abstract

abstract可以修饰类该类即为抽象类

abstract可以修饰方法该方法就是抽象方法

当你对这个方法描述的不是很清楚(不知道该怎么写清楚的时候)就可以直接把该方法声明成抽象方法

注意:抽象方法没有方法的实现部分

注意:

1.有抽象方法的类必须是抽象类

2.但是抽象类中不一定要有抽象方法

3.抽象类不能直接创建对象

4.强制子类重写父类的抽象方法

5.使用多态的形式进行创建

抽象类的作用:

核心:抽象类不能直接使用只能使用抽象类的子类

抽象类中有什么:

1.可以有变量常量

2.可以有构造方法

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

example:

public class Demo{
	public static void main(String[] args) {
		//创建一个动物对象
   //	   Animal animal = new Animal() {};(会报错!)
		//抽象类如何使用
		//需要使用多态的创建方式
		//父类引用指向子类对象
		Animal animal = new LiNaiAng();
		animal.speak();
	}
}
abstract class Animal{
	//构造方法
	public Animal() {
		System.out.println("我是Animal无参的构造方法");
	}
	//声明一个抽象方法
	public abstract void speak();
	
	public void fun() {
		System.out.println("我是fun方法");
	}
}
//抽象类的子类
class LiNaiAng extends Animal{
	//子类重写父类的抽象方法
	@Override
	public void speak() {
		System.out.println("汪汪汪");
	}
}

tips:

1.abstract关键词与哪些关键词不能共存?

2.final 不可以:修饰抽象方法方法不能被重写

3.private 不可以:private修饰方法只能本类访问

抽象类强制子类去重写抽象方法访问不到就谈不上重写了

4.static 修饰抽象方法可以用类名去调用

抽象方法是没有实现部分的不能直接调用

三.模(mú)板设计模式

场景:大部分东西一样只需要修改一部分内容

example:

abstract class LOStudy{
	//学习方法
	public void study() {
		System.out.println("报名");
		//选择学科是需要变化的 声明一个方法
		//调用抽象方法
		chooseSubject();
		System.out.println("找工作");
	}
	//声明抽象方法
	public abstract void chooseSubject();
}
class LNA extends LOStudy{
	//重写方法
	@Override
	public void chooseSubject() {
		System.out.println("学Unity3D");
	}
}
class LYC extends LOStudy{
	//重写方法
	@Override
	public void chooseSubject() {
		System.out.println("学java");
	}
}

example:

计算某一段程序的执行时间

public class Demo02 {
	public static void main(String[] args) {
                //获取系统时间
		//当前时间距离1970年的1月1日 的时间 单位是毫秒
		Time time = new Test();
		time.fun();
	}
}
abstract class Time{
	public void fun() {
		long start = System.currentTimeMillis();
	//执行某一个程序
	program();
	long stop = System.currentTimeMillis();
	System.out.println("该程序耗时" + (stop - start) + "毫秒");
	}
	public abstract void program();
}
class Test extends Time{
	@Override
	public void program() {
		for (int i = 0; i < 1000; i++) {
			for (int j = 0; j < 1000; j++) {
				System.out.println(i + j);
			}
		}
		
	}
}

四.接口

狭义:

java中的接口

使用interface关键词来声明

写法:interface 接口名{ }

广义:

相当于一个规则规范是需要来遵守的

接口:final 默认是静态的常量

1.只可以声明抽象方法(是不准确的)

2.声明变量

3.接口只能用来实现(不能继承)

4.接口中是没有构造方法的(使用的是实现这个关键词不是继承)

5.接口中声明的变量默认是public static

6.声明抽象方法的时候默认是 public abstract修饰(可省略)

接口是怎么运行的?

和类一样也会被翻译成.class文件被执行

接口使用 implements 关键词实现

接口的实现类类名一般都以Impl结尾

public class Demo03 {
	public static void main(String[] args) {
			//创建接口  使用多态的形式创建
		InterA a = new InterAImpl();
		a.fun();
	}
}
//声明一个接口
interface InterA{
	int num = 10;
	public void fun();
}
class InterAImpl implements InterA{
    //实现接口中的抽象方法
	@Override
	public void fun() {
		//num = 15;
		System.out.println(num);
		System.out.println("我是实现类的fun方法");
	}
}

接口中是没有构造方法的

抽象类和接口有什么区别?

1.使用方法

抽象类:继承 extends

接口:实现 implements

2.成员变量

抽象类:可以是常量也可以是变量

接口:只能是常量

3.成员方法

抽象类:可以是抽象方法也可以是成员方法

接口:只能是抽象方法(静态方法和默认方法)

4.构造方法

抽象类:有

接口:没有

1.类与类之间的关系(亲Dad的关系)

只允许单继承

2.类和接口的关系(干Dad的关系)

实现的关系可以实现多个接口

3.接口和接口的关系

可以单继承也可以多继承

//类和接口的关系
interface InterB{
	public abstract void fun1();
}
interface InterC{
	public abstract void fun2();
}
class TestA implements InterB,InterC{
	@Override
	public void fun2() {
		// TODO Auto-generated method stub	
	}
	@Override
	public void fun1() {
		// TODO Auto-generated method stub	
	}
}

//接口和接口的关系
interface InterD{
	public abstract void fun1();
}
interface InterE{
	public abstract void fun2();
}
interface InterF extends InterD,InterE{
	
}
class InterFImpl implements InterF{

	@Override
	public void fun1() {
		
	}
	@Override
	public void fun2() {
		
	}
}

JDK1.8后的新特性

接口中扩充了静态方法和默认方法

public class Demo06 {
	public static void main(String[] args) {
		//调用接口中的 静态方法
		InterX.staticFun();
		//创建实现类的对象(多态方式)
		InterX x = new InterXImpl();
		x.defaultFun();
		//实现类中的静态方法
		InterXImpl.staticFun();
		//调用实现类的特有方法
		InterXImpl xImpl = (InterXImpl)x;
		xImpl.print();
	}
}
interface InterX{
	//抽象方法
	public abstract void fun();
	//静态方法
	public static void staticFun() {
		System.out.println("我是接口中的staticFun方法");
	}
	//默认方法 default 关键词
	//不是必须在实现类中重写
	public default void defaultFun() {
		System.out.println("我是接口中的defaultFun");
	}
}
class InterXImpl implements InterX{
	//实现接口中的抽象方法
	@Override
	public void fun() {
		System.out.println("我是实现类中的fun方法");
	}
	//重写默认方法
	@Override
	public void defaultFun() {
		//调用父类中的 默认方法
		//接口名.super.默认方法名
		InterX.super.defaultFun();
		System.out.println("我是实现类中的defaultFun方法");
	}
	//静态不重写 实现类自己的静态方法
	public static void staticFun() {
		System.out.println("我是实现类中的staticFun方法");
	}
	//自己的方法(能不能调用 父类默认方法)
	public void print() {
		InterX.super.defaultFun();
		System.out.println("我是打印方法");
	}
}