【JavaSE】抽象类、接口及两者区别

概念部分

1 实际开发中不要去继承实现好的类，而应该去继续抽象类或者接口
2 抽象类
	普通类的基础上扩充了一些抽象方法，即只声明而未实现的方法
	抽象方法用abstract关键字声明，不包含方法体，无具体实现，不能直接产生实例化对象。
	使用原则：
		必须有子类、子类必须覆写所有抽象方法、方法覆写的权限全用public；
		抽象类的对象可通过对象多态性利用子类为其实例化。
		实例化子类时一定要先调用父类构造方法。
3 对象实例化
	核心步骤：类加载->类对象的空间开辟->类对象中的属性初始化(构造方法)
4 模板设计模式
	模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供具体实现。
	最具代表性的是Servlet用。
	一个完整的模板模式超类定义：
	
	//基类声明为抽象类的原因是便于修改；其子类必须实现其具体操作
	abstract class AbstractClass{
		//模板方法，被声明为final以免子类改变这个算法的顺序
		final void templateMethod(){
		
		}
		//具体操作延迟到子类中实现
		abstract void primitiveOperation1();
		abstract void primitiveOperation2();
		//具体操作且共用的方法定义在超类中，可以被模板方法或子类直接使用
		final void concreateOperation(){
			//实现
		}
		//钩子方法是一类“默认不做事的方法”，子类可以视情况决定是否覆盖它们。
		void hook(){
			//钩子方法
		}
	}
	
5 接口
	可以约定子类的实现并且避免单继承局限。
	接口优先原则！
	接口就是一个抽象方法和全局常量（不常见）的集合。
	interface关键字定义，接口实现用implements关键字。
	一个子类可以实现多个接口。
	对于接口的子类必须覆写接口中全部抽象方法，随后可由子类向上转型通过实例化子类来得到接口的实例化对象。
	接口中只允许public权限，无论属性或方法。
	当子类需要同时实现接口和继承抽象类时，先extends，再implements。
		例：class MessageImpl extends News implements IMessage
	实际开发中三大核心应用环境：
		定义操作标准、表示能力、分布式开发中暴露远程服务方法
6 工厂设计模式
	开发中程序的修改不应该影响客户端，程序->JVM->操作系统，new是最大的耦合原因，解耦就要引入第三方Factory。
	JDK中用到工厂模式的典型操作：
		Collection中的iterator方法（集合类中的迭代器）
		java.util包中相关sql操作。
7 代理设计模式
	两个子类共同实现一个接口，其中一个子类负责真实业务实现，另一个子类完成辅助真实业务主题的操作。
	本质：所有的真实业务操作都会有一个与之辅助的工具类共同完成。
8 抽象类与接口的区别***
	结构组成上：前者~普通类+抽象方法；后者~抽象方法+全局常量
	权限上：前者~各种权限；后者~仅可用public
	子类使用上：前者~extends继承；后者~implements实现
	关系上：前者~一个抽象类可以实现若干个接口；后者~接口不能继承抽象类，但接口可继承多个父接口
	子类限制：前者~一个子类只能继承一个；后者~一个子类可实现多个
	
	总结：开发中优先用接口，避免单继承限制；抽象类是模板有层次感，接口更关心行为与混合。

需记程序

1 写星巴克师傅冲茶和泡咖啡的例子~模板模式方法
//首先是超类实现
abstract class CaffeineBeverage{
    //用final修饰主要是不想让子类改变顺序
    //这是一个整体的做饮料方法
    final void prepareRecipe(){
        boilWater();
        brew();
        pourInCup();
        //如果用户想要才调用加调料方法
        if (customerWantsCondiments()){
            addCondiments();
        }
    }
    //写出需要特殊实现的各个抽象方法
    abstract void brew();
    abstract void addCondiments();
    //这两个方法时通用法，所以在超类中实现
    void boilWater(){
        System.out.println("Boiling Water...");
    }
    void pourInCup(){
        System.out.println("Pouring into cup...");
    }
    //钩子方法，超类中通常是默认实现，子类可以选择性覆写
    boolean customerWantsCondiments(){
        return true;
    }
}
//子类实现
class Tea extends CaffeineBeverage{
    @Override
    void brew() {
        System.out.println("Steeping the tea...");
    }
    @Override
    void addCondiments() {
        System.out.println("Adding Lemon...");
    }
}
class Coffee extends CaffeineBeverage{
    @Override
    void brew() {
        System.out.println("Dripping Coffee through filter...");
    }
    @Override
    void addCondiments() {
        System.out.println("Adding Sugar and Milk...");
    }
    //在此覆写钩子函数，实现自定义功能
    public boolean customerWantsCondiments(){
        String answer = getUserInput();
        if (answer.equals("Y")){
            return true;
        }else {
            return false;
        }
    }
    private String getUserInput(){
        String answer = null;
        System.out.println("Can you want to add milk or sugar（Y/N）?");
        Scanner input = new Scanner(System.in);
        answer = input.nextLine();
        return answer;
    }
}
//测试类
public class Test{
    public static void main(String[] args) {
        CaffeineBeverage tea = new Tea();
        CaffeineBeverage coffee = new Coffee();
        System.out.println("\nMaking tea...");
        tea.prepareRecipe();
        System.out.println("\nMaking coffee...");
        coffee.prepareRecipe();
    }
}

2 写多个子类实现一个接口的例子
//定义一个USB标准
interface USB{
    public void setup();    //安装USB驱动
    public void work();     //进行工作
}
//定义电脑类
class Computer{
    public void plugin(USB usb){
        usb.setup();
        usb.work();
    }
}
//定义USB子类
class UDisk implements USB{
    @Override
    public void setup() {
        System.out.println("安装U盘驱动");
    }
    @Override
    public void work() {
        System.out.println("U盘开始工作");
    }
}
class PrintDisk implements USB{
    @Override
    public void setup() {
        System.out.println("安装打印机驱动");
    }
    @Override
    public void work() {
        System.out.println("打印机开始工作");
    }
}
public class Test{
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.plugin(new UDisk());
        computer.plugin(new PrintDisk());
    }
}

3 写工厂设计模式，吃水果的例子
//定义一个吃水果的操作
interface IFruit{
    public void eat();
}
//定义工厂类
class Factory{
    public static IFruit getInstance(String className){
        if (className.equals("apple")){
            return new Apple();
        }
        if (className.equals("lemon")){
            return new Lemon();
        }
        return null;
    }
}
//子类实现
class Apple implements IFruit{
    @Override
    public void eat() {
        System.out.println("可以吃苹果啦");
    }
}
class Lemon implements IFruit{
    @Override
    public void eat() {
        System.out.println("可以变成柠檬精啦");
    }
}
public class Test{
    public static void main(String[] args) {
        //如果没有传递参数，工厂也不要生产
        if (args.length==0){
            System.out.println("没有传递参数，程序退出");
            System.exit(1);     //退出程序
        }
        IFruit fruit = Factory.getInstance(args[0]);
        fruit.eat();
    }
}


4 写代理设计模式，找代理买口红的例子
interface ISubject{
    public void buyLipstick();  //核心功能是买口红
}
//有目标要做事情的类，也就是买家
class RealSubject implements ISubject{
    @Override
    public void buyLipstick() {
        System.out.println("买三支纪梵希小羊皮");
    }
}
//做真实操作业务的类，也就是微信代理
class ProxySubject implements ISubject{
    private ISubject subject;   //真实业务对象
    //构造方法，确认当前对象
    public ProxySubject(ISubject subject){
        this.subject = subject;
    }
    public void produceLipstick(){
        System.out.println("生产纪梵希小羊皮三支");
    }
    public void aftersale(){
        System.out.println("纪梵希售后团队");
    }
    @Override
    public void buyLipstick() {
        this.produceLipstick(); //真实业务前的准备，即先生产出口红
        this.subject.buyLipstick(); //真实业务，代购去买口红
        this.aftersale();   //操作后的首尾，口红的售后问题
    }
}
class Factory{
    public static ISubject getInstance(){
        return new ProxySubject(new RealSubject());
    }
}
public class Test{
    public static void main(String[] args) {
        ISubject subject = Factory.getInstance();
        subject.buyLipstick();
    }
}