java之单例、抽象、模板、接口

  单例设计模式

      核心思想:在程序的运行当中 该类的对象 不管怎么创建

     始终保持有且只有一个该类的对象

     编写单例类思路

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

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

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

      1.饿汉式

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

     2.懒汉式(延迟加载)

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

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

   饿汉式

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() {
		//判断 当这个对象不存在的时候 再创建
		if (singleL==null) {
			singleL=new SingleL();
		}
		return singleL;
	}
}

  抽象类

    描述不清楚就是抽象 

    关键词:abstract

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

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

      当你对这个方法描述的不是特清楚(不知道写啥)

      就可以直接把该方法声明成抽象方法

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

      注意:

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

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

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

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

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

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

     抽象类中

     1.可以有变量 常量

     2.可以有构造方法

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

      abstract关键词与那些关键词不能共存?

      final   修饰抽象方法 方法不能被重写

      private 修饰方法只能本类访问

      抽象类 强制子类去重写抽象方法

      访问不到 就谈不到重写了

      static 修饰抽象方法 就能使用类名去调用

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

public class Demo02抽象类 {
	public static void main(String[] args) {
		//创建一个动物对象
		//Animal animal=new Animal();
		//抽象类如何使用
		//需要使用多态的创建方法
		//父类的引用指向子类对象
		Animal aCat=new Cat();
		aCat.speak();	
	}
}

//抽象类
abstract class Animal{
	int num;
	//构造方法
	public Animal(){
		System.out.println("我是Animal 无参的构造方法");
	}
	//声明一个抽象方法
	public abstract void speak();
	
	public void fun() {
		System.out.println("我是fun方法");
	}
}
//抽象类的子类
class Cat extends Animal{
	//子类重写父类的 抽象方法
	@Override
	//方法重写一下
	public void speak() {
		System.out.println("喵喵喵");
	}
}

   模板设计模式

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

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() {
		System.out.println("学Java");
	}
}

class PQ extends LOStudy{
	@Override
	public void chooseSubject() {
		System.out.println("学H5");
	}
}

  接口

       狭义:

      java中的接口

      使用interface关键词来声明

      interface 接口名

      广义:相当于一个规则 规范 

          是需要来遵守的

      接口

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

      2.可以声明变量

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

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

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

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

      接口是怎么运行的?跟类一样 也会被翻译.class文件被执行

public class Demo03接口 {
	public static void main(String[] args) {
		//创建接口
		InterA a=new InterAImpl();
		a.fun();
		System.out.println(InterA.num);
	}
}

//声明一个接口
interface InterA{
	public static final int num=10;
	public abstract void fun();	
}

//接口 使用implements 关键词 实现
//接口的实现类 类名 一般都以Impl结尾
class InterAImpl implements InterA{
	//实现接口中 抽象方法
	@Override
	public void fun() {
		//num=15;
		System.out.println(num);
		System.out.println("我是实现类的fun方法");
	}
}

    抽象类和接口的区别

      1.使用方法

      抽象类:继承    

      接口:实现(implements)

      2.成员变量

      抽象类:可以是常量 变量   

      接口:只能是常量

      3.成员方法

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

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

      4.构造方法

      抽象类:有   

      接口:没有

      类与类之间的关系

      只允许单继承

      类和接口关系

      实现的关系 可以多实现

      接口和接口的关系

      可以单继承 也可以多继承