• 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");
    }
});

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    模板方法设计模式

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

    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);
            }
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    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静态方法三");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

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

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

    接口之间可以多继承，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{

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    接口的使用可体现多态性

    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("结束");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69

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

    接口的应用：代理模式（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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    应用场景：

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

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

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

    简单工厂模式

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

    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;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    工厂方法模式

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

    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();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    抽象工厂模式

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

  • 相关阅读:
    mybatis if标签或者when标签判断字符串是否相等
    M代码管理篇
    SpringMVC学习笔记
    二、T100应收管理之订金立帐
    static关键字
    VSCode内用markdown写代码时出现很多段落标记的解决方案
    2023最新版JavaSE教程——第4天：流程控制语句之循环语句
    CPU中的核与进程，线程间的关系讲解（操作系统基础概念）
    CentOS7 yum安装报错：“Could not resolve host: mirrorlist.centos.org； Unknown error“
    塑化行业SRM供应商管理系统：缩短采购周期时间，改善供应商采购管理
  • 原文地址：https://blog.csdn.net/zf111212/article/details/125999343