Java码农坎坷之路~单例&抽象类&接口

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

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

编写单例的思路:

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

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

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

编写的方式:

1.饿汉试

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

2.懒汉式(延迟加载)

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

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

public class Demo01 {
	public static void main(String[] args) {
		//获取单例对象
		SingleE.getInstance();
	}
}

//饿汉式(只要该类 被加载 就会在方法区的静态区中 创建本来的对象)
class SingleE{
	//声明一个本类的对象
	private static SingleE singleE = new SingleE();
	
	//构造方法私有化
	private SingleE() {
		
	}
	//对外提供一个访问的方法(就是为了返回本类的对象)
	public static SingleE getInstance(){
		return singleE;
	}
}
//懒汉式(不完整 线程安的问题 双锁控制)
class SingleL{
	//声明一个对象的引用
	private static SingleL singleL = null;
	private SingleL() {
		
	}
	//获取对象的方法
	public static SingleL getInstance(){
//		singleL = new SingleL();
		//判断 当这个对象不存在的时候 再创建
		if (singleL == null) {
			singleL = new SingleL();
		}
		return singleL;
	}
}

二抽象类

关键词:abstract

abstract可以修饰类,该类就是抽象类

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

当你对这个方法无法具体描述的时候,把该方法声明成抽象方法

注意:

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

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

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

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

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

抽象核心:

抽象类,不能直接使用,只能使用抽象类的子类

为什么抽象类中要有构造方法?继承的完整性

抽象类中有

1.可以有变量,常量

2.可以有构造方法

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

	Animal animal = new Animal();
//		animal.speak();
		
		//抽象类如何使用
		//需要使用多态的创建方法
		//父类引用指向子类对象
		Animal aCat = new Cat();
		aCat.speak();
	}
}
abstract class Animal{
	
	final int num = 10;
	
	//构造方法
	public Animal() {
		// TODO Auto-generated constructor stub
		System.out.println("我是Animal 无参的构造方法");
	}
	//声明一个抽象方法
	public abstract void  speak();
	
	public void fun() {
		System.out.println("我是fun方法");
	}
}
//抽象类的子类
class Cat extends Animal{
	//子类重写父类的 抽象方法
	@Override
	public void speak() {
		// TODO Auto-generated method stub
		System.out.println("喵喵喵");
	}
}

abstract关键词与一下这些关键词无法共存:

final 修饰抽象方法的话,方法无法被重写

private 抽象类强制子类去重写抽方法,而private修饰方法,只能本类访问,是子类无法重写方法

static 修饰抽象方法,就能使用类名去调用,抽象方法是没有实现部分的,不能直接调用

三模板设计模式

思想:大部分东西一样,只需要修改一部分的内容

eg: 来坎坷之路学习编程

1.报名缴费

2.选择学科(H5,Java,U3D)

3.毕业找工作

此时,只需要一个模板,然后每个报名的学员也就选择的学科不同,其他步骤都一致

public class Demo01 {
	public static void main(String[] args) {
		LOStudy lsk = new LSK();
		lsk.study();
	}
}
abstract class LOStudy{
	//学习方法
	public void study() {
		System.out.println("报名缴费");
		//选择学科是需要变化的
		//调用抽象方法
		chooseSubject();
		System.out.println("毕业找工作");
	}
	//声明抽象方法
	public abstract void chooseSubject();
}

class LSK extends LOStudy{
	//重写抽象方法
	@Override
	public void chooseSubject() {
		// TODO Auto-generated method stub
		System.out.println("学Java");
	}	
}
class PQ extends LOStudy{
	//重写抽象方法
	@Override
	public void chooseSubject() {
		// TODO Auto-generated method stub
		System.out.println("学H5");
	}	
}

四接口

狭义:java中的接口,使用interface关键词来声明

interface 接口名{ }

广义:相当于一个规则,需要来遵守

接口:

1.可以声明抽象方法

2.可以声明一个变量

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

4.接口中是没有构造方法的

5.接口声明变量默认是public final static 静态常量

6.声明抽象方法默认是public abstract(可省略)

创建接口,使用多态的形式创建

接口是使用implements 关键词实现

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

接口与抽象类的区别:

1.使用方法:

抽象类:继承

接口:实现

2.成员变量

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

接口:无论是否定义为变量,都会变成常量

3.成员方法

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

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

4.构造方法

抽象类:要有

接口:没有构造方法

类与类的关系:只允许单继承

类和接口的关系:实现的关系,可以多实现

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 fun3();
}
interface InterE{
	public abstract void fun4();
}
interface InterF extends InterD ,InterE{
	
}