Java复习五：抽象类+模板设计方法+接口+三种工厂模式

抽象类

类的设计应该保证父类和子类能够共享特征。有时将一个父类设计的非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

abstract可以修饰类。抽象类

​ 抽象类不可以实例化

​ 抽象类中一定有构造器，便于子类实例化时调用

abstract class name{}

public abstract void name（）；

包含抽象方法的类一定是抽象类，抽象类可以没有抽象方法

abstract使用注意点

​ 1 abstract不能用来修饰属性和构造器

​ 2 abstract不能和static,final,私有方法一起使用

//非匿名类的匿名对象
method(new Student());

//匿名子类的非匿名对象
Person st=new Person(){

    @Override
    public void eat() {
        System.out.println("吃");
    }

    @Override
    public void walk() {
        System.out.println("喝");
    }
};
method(st);

//匿名子类的匿名对象
method(new Person(){
    @Override
    public void eat() {
        System.out.println("chichichi");
    }

    @Override
    public void walk() {
        System.out.println("hehehe");
    }
});

模板方法设计模式

当功能内部一部分实现时确定的，一部分实现是不确定的。可以把不确定的部分暴露出去。让子类实现

package t7;


public class TemplateTest {
    public static void main(String[] args) {
        Template t=new SubTemplate();
        t.spendTime();
    }
}
abstract class Template{
    public void spendTime(){
        long start=System.currentTimeMillis();
        code();
        long end=System.currentTimeMillis();
        System.out.println("花费的时间:"+(end-start));
    }
    public abstract void code();
}

class SubTemplate extends Template{

    @Override
    public void code() {
        for(int i=2;i<1000;i++){
            boolean flag=false;
            for(int j=2;j<=Math.sqrt(i);j++)
            {
                if(i%j==0){
                    flag=true;
                    break;
                }
            }
            if(!flag){
                System.out.println(i);
            }
        }
    }
}

interface接口

接口的本质是契约，标准，规范。继承是“是不是”的关系，而接口是能不能的关系

JDK7以前：只能定义全局常量和 抽象方法，默认都是这样的

​ 全局常量：public static final 直接用接口名.属性获取

​ 抽象方法：public abstract

JDK8:除了全局常量和抽象方法之外，还可以定义静态方法static，默认方法default

接口和抽象类的区别：

相同：不能实例化，都可以被继承

不同：抽象类有构造器，接口不能声明构造器

抽象类单继承，接口多继承

静态方法只能通过接口调用，默认方法只能通过实现类来调用，实现类可以重写默认方法

如果子类继承了父类和实现的接口中声明的同名同参的方法，那么在子类没有重写此方法的情况下，默认调用的是父类中的方法。类优先原则

如果实现类实现了多个接口，而多个接口中有同名同参的默认方法，如果没有重写此方法，则会报错。接口冲突。调用指定接口中的方法可以通过interfaceName.super.method

package t4_jdk8_interface;

/**
 * TODO
 * jdk8的接口新特性
 * 可以定义静态方法和默认方法
 */
public interface CompareA {
    public static void method1(){
        System.out.println("静态方法1");
    }

    public default void method2(){
        System.out.println("静态方法2");
    }

    default void method3(){
        System.out.println("静态方法三");
    }
    default void method4(){
        System.out.println("静态方法4");
    }
}

class CompareATest {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        //接口中定义的default方法可以通过实例类来调用
        subClass.method2();
        //接口中定义的静态方法，只能通过接口调用，不能通过实体类调用
        CompareA.method1();
        //接口父类同名默认调用父类
        subClass.method3();

        subClass.method();

    }
}

interface CompareB{
    default void  method4(){
        System.out.println("Comapre静态方法四");
    }
}
class SubClass extends superClass implements CompareA,CompareB {
    void method(){
        //调用父类的
        super.method3();
        //调用指定接口中的方法
        CompareA.super.method4();
        CompareB.super.method4();
    }

    //如果两个接口中存在同名方法，那么必须要重写该方法
    @Override
    public void method4() {
        System.out.println("重写");
    }
}

class superClass{
    public void  method3(){
        System.out.println("superclass静态方法三");
    }
}

接口中不能定义构造器，意味着接口不可以实例化

如果实现类没有覆盖结构中所有的抽象方法，则此实现类为一个抽象类

接口之间可以多继承，extends。

package t1_interface;

/**
 * 接口类可以定义的数据类型只能为 public static final全局常量
 * 方法只能为全局抽象方法
 *
 * 接口之间可以多继承
 */
public class InterfaceTest {
    public static void main(String[] args) {
        Plane plane = new Plane();
        plane.fly();
    }
}
interface Flayalbe{
    int MAX_SPEED=7000;
    void fly();
}

class Plane implements Flayalbe,C{

    @Override
    public void fly() {
        System.out.println("芜湖~起飞");
    }

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

interface A{
    void method1();
}

interface B{
    void method2();
}

interface C extends A,B{

}

接口的使用可体现多态性

package t1_interface;

/**
 * TODO
 * 接口的使用
 * 匿名实现类和匿名对象
 * 接口实际上是定义了一种实现的规范
 */
public class InterfaceTest2 {
    public static void main(String[] args) {

        Computer computer=new Computer();
        //非匿名实现类的非匿名对象
        Flash flash=new Flash();
        //创建了接口的非匿名实现类的匿名对象
        computer.useUsB(new Flash());
        //匿名实现类的非匿名对象
        USB phone=new USB() {
            @Override
            public void start() {
                System.out.println("eeee");
            }

            @Override
            public void end() {
                System.out.println("efff");
            }
        };

        computer.useUsB(phone);
        //创建了接口的匿名实现类的匿名对象
        computer.useUsB(new USB(){

            @Override
            public void start() {
                System.out.println("ooo");
            }

            @Override
            public void end() {
                System.out.println("kkkk");
            }
        });
    }
}
interface USB{
    void start();
    void end();
}

class Computer{
    void useUsB(USB usb){
        usb.start();
        System.out.println("数据开始传输");
        usb.end();
    }
}
class Flash implements USB{

    @Override
    public void start() {
        System.out.println("开始");
    }

    @Override
    public void end() {
        System.out.println("结束");
    }
}

接口的主要用途是被实现类实现。称之为面向接口编程

接口的应用：代理模式（Proxy）

代理设计是为其他对象提供一种代理以控制这个对象的访问

package t1_interface;

/**
 * TODO
 * 代理模式
 *
 * 代理类和实际类共同实现接口
 * 将实际服务对象传入代理类中，代理类在接口方法中调用实际类的实现方法
 */
public class NetWorkTest {
    public static void main(String[] args) {
        Server server=new Server();
        ProxyServer proxyServer=new ProxyServer(server);
        proxyServer.browse();
    }
}
interface NetWork{
    void browse();
}

//被代理类
class Server implements NetWork{
    @Override
    public void browse() {
        System.out.println("爷实现了");
    }
}

//代理类
class ProxyServer implements NetWork{

    private NetWork netWork;

    public ProxyServer(NetWork work){
        netWork=work;
    }
    public void check(){
        System.out.println("联网之前的检测工作");
    }

    @Override
    public void browse() {
        check();
        netWork.browse();
    }
}

应用场景：

安全代理：屏蔽对真实角色的直接访问

远程代理：通过代理类处理远程方法调用

延迟加载：先加载轻量级代理对象，真正需要的时候再加载真实对象

简单工厂模式

用来生产统一等级结构中的任意产品，增加新产品需要修改原代码

package t1_interface;

/**
 * TODO
 * 简单工厂代理模式
 * 创建一个类专门用来生产对象，根据逻辑语句判断或者创建不同的生成对象的方法
 *
 * 优点：创建者与调用者分离
 * 缺点：扩展性差，违背了开闭原则，对扩展开放，对修改封闭

 */
public class FactoryTest {
    public static void main(String[] args) {
        Car car=CarFactory.getCar("比亚迪");
        car.run();
    }
}

interface Car{
    void run();
}

class Ao implements Car{
    @Override
    public void run() {
        System.out.println("奥迪跑");
    }
}

class Biy implements Car{

    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }
}

class CarFactory{
    public static Car getCar(String str){
        if ("比亚迪".equals(str)){
            return new Biy();
        }else if("奥迪".equals(str)){
            return new Ao();
        }
        return null;
    }
}

工厂方法模式

用来生产同一等级结构中的固定产品

package t2_factory;

/**
 * TODO
 * 工厂方法模式
 *
 * 步骤：
 * 创建工厂接口
 * 实现不同的工厂接口创建类
 *
 * 优点：创建者与调用者分离
 * 缺点：扩展性差，违背了开闭原则，对扩展开放，对修改封闭

 */
public class FactoryTest2 {
    public static void main(String[] args) {
       Car a=new AoFactory().getCar();
       Car b=new BiyFactory().getCar();
       a.run();
       b.run();
    }
}


interface Factory2{
    Car getCar();
}

class AoFactory implements Factory2{

    //重写方法返回类型可以是原方法的子类
    @Override
    public Ao getCar() {
        return new Ao();
    }
}

class BiyFactory implements Factory2{

    @Override
    public Biy getCar() {
        return new Biy();
    }
}

抽象工厂模式

用来生产不同产品族的全部产品，对于增加新的产品无能为力，支持增加产品族