城管希课堂之抽象类和接口

1.抽象类

 * 关键词:abstract
 * abstract 可以修饰类 该类就是 抽象类 
 * abstract 可以修饰方法 该方法就是 抽象方法
 * 当你对这个方法 描述的不是特清楚(不知写啥)
 * 就可以直接吧该方法 声明成 抽象方法
 * 注意:抽象方法 没有方法的实现部分
 * 注意:
 * 1.有抽象方法的类 必须是抽象类
 * 2.但是抽象类中 不一定要有抽象方法
 * 3.抽象类 不能直接创建对象 
 * 4.强制子类 重写父类抽象方法
 * 5.使用多态的形式 进行创建

抽象类中有

1.变量 常量

2.可以有构造方法

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

abstract关键字与哪些关键字不能共存?

 * final 修饰抽象方法 方法不能被重写 不能共存 
 * private 不行 修饰抽象方法 只能本类访问
 * 抽象类 强制子类去重写抽象方法
 * 访问不到 就谈不到重写了
 * static  修饰抽象方法 使用类名调用 
 * 抽象方法没有实现部分的 不能直接调用 

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

 * 核心思想:在程序的运行当中 该类的对象 不管怎么创建 
 * 始终保持 有且只有一个 该类的对象
 * 
 * 单例可以进行 传值 
 * 
 * 编写单例类思路
 * 1.不让外界创建对象 (私有化构造方法)
 * 2.自己类内部 来创建这个对象(让这个对象只创建一次)
 * 3.给类外部 提供一个获取 
 *   该对象的方法(相当于提供一个get方法)
 *   
 * 1.饿汉式(只要该类 被加载 就会在方法区的静态区中 创建本类的对象)
 * 2.懒汉式(延迟加载)
 * (在类被加载的时候 不会去创建对象 只有当 你调用了获取该类对象的方法的时候 才会创建该类的对象)

例:

public class Demo01 {
	public static void main(String[] args) {
		//获取单例对象
		SingleE.getInstance();	
	}
}
/*
 * 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;
	}
}

3.模板设计模式

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

例子: 

public class Demo01 {
	public static void main(String[] args) {
		LOStudy lsk = new LSK();
		lsk.study();
		LOStudy pq = new PQ();
		pq.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");
	}
}

4.接口

 * 狭义:java中的接口
 * 使用interface关键词来声明
 * interface 接口名 {
 * 
 * }
 * 广义:相当于一个规则 规范 是需要来遵守的 
 * (蓝鸥学生手册)(保密协议)
 * 
 * 接口
 * 1.只可以声明 抽象方法(是不太准确的)(静态方法 默认方法)
 * 2.可以声明变量
 * 3.接口只能用来实现(不能继承)
 * 4.抽象类中是没有构造方法的
 * 5.接口声明变量 默认是public static final 
 *   默认就是静态常量
 *   建议:先写全了 写熟了再说 主要看公司的规定
 * 6.声明抽象方法时 默认是 public abstract(可省略)
 * 
 * 接口咋运行的? 跟类一样 也会被翻译成.class文件被执行

 * 抽象类和接口的区别
 * 1.使用方法 
 * 抽象类:继承
 * 接口:实现 implements
 * 2.成员变量
 * 抽象类:可以是常量 也可以是变量
 * 接口:只能常量
 * 3.成员方法
 * 抽象类:可以是 抽象方法 也可以是成员方法
 * 接口:只能是抽象方法 --- (静态方法 和 默认方法)
 * 4.构造方法
 * 抽象类:有
 * 接口:没有
 * 类与类之间的关系(亲爹的关系)
 * 只允许单继承 
 * 
 * 类和接口关系(干爹的关系)
 * 实现的关系 多继承 
 * 
 * 接口和接口的关系
 * 可以单继承 也可以多继承
 * 
 * java是单继承 还是多继承

 * JDK1.8之后的新特性 操作工
 * 接口中扩充了 静态方法 和 默认方法
 * 如何分析新特性?  
 * 1.怎么写
 * 2.怎么调 
 * 3.为什么这么调

public class Demo06 {
	public static void main(String[] args) {
		// 调用接口中的 静态方法
		InterX.staticFun();
		//创建实现类的对象(多态方式)
		InterX impl = new InterXimpl();
		impl.defaultFun();
		//实现类中的静态方法
		InterXimpl.staticFun();
		//调用实现类的特有方法
		InterXimpl ximpl = (InterXimpl) impl;
		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("我是实现类中 default方法");
	}
	
	//实现类中 自己的静态方法
	public static void staticFun(){
		System.out.println("我是实现类中 staticFun方法");
	}
	//自己方法(能不能调用 父类的默认方法)
	public void print(){
		InterX.super.defaultFun();
		System.out.println("我是打印方法");
	}
}