做一个抽象类也是封装？

Question

据说封装封装了数据和方法，并隐藏了该对象外部不需要的功能（方法和实例变量）

我的问题是仅使变量私有，而使封装公开吗？ 还是使抽象类成为封装？

例如：我让Switch（Electic Switch）类打开或关闭，以使Switch类成为我使用的抽象类，并且通过使用抽象封装了Switch类，以便可以映射电动机或灯泡或任何电子仪器

public class Switch {
    private boolean isOff = true;
    private ISwitchListener listener;
    public Switch(ISwitchListener listener) {
        this.listener = listener;
    }
    public void trigger() {
        isOff = !isOff;    
        if(isOff) {
            listener.off();
        } else {
            listener.on();
        }
    }
}

public class Bulb implements ISwitchListener {

    @Override
    public void on() {
        // TODO Auto-generated method stub
        System.out.println("bulb is glittering");
    }

    @Override
    public void off() {
        // TODO Auto-generated method stub
        System.out.println("bulb is not glittering");
    }

}

public interface ISwitchListener {
    public void on();
    public void off();
}

public class Executor {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Switch swt = new Switch(new Bulb()); 
        swt.trigger();          
    }
}

如果我不在这里使用抽象，我将有下面的类

public class Switch {
    private boolean isOff = true;
    public void trigger() {

        isOff = !isOff;
        Bulb b =new Bulb();
        if(isOff) {
            b.off();
        } else {
            b.on();
        }
    }
}

当我想将Motor映射到Switch时，我需要将类更改为bleow

public class Switch {
    private boolean isOff = true;
    public void trigger() {

        isOff = !isOff;
        Bulb b =new Bulb();
        if(isOff) {
            b.off();
        } else {
            b.on();
        }
    }
}


public class Motor {
    public void on() {
        // TODO Auto-generated method stub
        System.out.println("Motor is rotating");
    }

    public void off() {
        // TODO Auto-generated method stub
        System.out.println("Motor is getting off to rotate");
    }
}

Answer 1

通常，不，抽象和封装是两件事。 具体来说，抽象意味着删除对于代码或模型的预期目的不必要的细节。 例如，如果编写一个程序来计算房屋所需的油漆量，则房屋模型需要包括表面积，但不需要包括地址或院子的大小。 封装意味着隐藏对象或模块的内部工作原理，以便可以控制和轻松更改对象之间的耦合。 如果没有封装，则对象的客户端可能会直接引用其内部元素，这意味着如果修改了对象，则必须更改所有客户端。

关于代码示例，我认为一个更好的解决方案是创建一个“可切换”接口，并由Motor and Bulb实现。 像这样：

public interface Switchable {
   void on();
   void off();
}

public class Motor implements Switchable {
    public void on() {
        System.out.println("Motor is rotating");
    }

    public void off() {
        System.out.println("Motor is getting off to rotate");
    }
}

public class Switch {
    private boolean isOff = true;
    private Switchable switchable;

    public Switch(Switchable switchable) {
        this.switchable = switchable;
    }

    public void trigger() {
        isOff = !isOff;
        if(isOff) {
            switchable.off();
        } else {
            switchable.on();
        }
    }
}

希望能有所帮助。

Answer 2

第一个示例是依赖项注入的示例=>，让调用者确定类“ Switch”完成其工作所需的具体类。

实际上，这是数据隐藏的“对立面”，因为外界必须了解“ Switch”类的一些实现细节。 =>它需要ISwitchListener的实现

Answer 3

正如@TI所说，它可以是一种方法，例如对于Java 8而言，您可以在接口中创建默认实现，因此可以将其隐藏在实现接口的类中。

但是封装是关于字段（实例变量）的隐藏。 创建一个私有成员（实例变量）并创建setter和getter。 您只能通过专用方法来实现价值。

如果要封装方法，则需要处理可访问性（请参阅默认修饰符和保护修饰符）。

因此，您的问题的答案是：否。使用抽象来制作类不是封装。

Answer 4

抽象和封装是相互关联的。 您可以说需要抽象来封装系统。 抽象是指客户端系统不需要了解更多信息时。 封装是指模块的客户端不了解接口中的内容时。

请访问此页面以获取有关此主题的精美文章。