Java之封装（Encapsulation）与接口（Interface）

缺乏、安全感 2022-05-20 04:42 218阅读 0赞

### 封装（Encapsulation） ###

将抽象性函数接口的实现细节进行部分包装，隐藏，防止该类的代码和数据被外部类定义的代码随机访问的一种操作。

**封装的特性：**

1）是类的保护屏障，保障类代码的安全性。

2）想要访问该类的代码，必须经过严格的接口控制。

3）方便修改代码，不用修改调用代码的程序片段。

4）易于理解和代码维护，代码条理清晰易读。

下面演示封装的一个实例：

EncapsulationDemo.java

public class EncapsulationDemo {
        private String name;
        private String address;
        private int age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

以上实例中public方法是外部类访问该类成员变量的入口，通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

下面演示一个访问该方法的实例：

在同一文件夹目录下创建java文件

EncapsulationDemoTest.java

public class EncapsulationDemoTest {
        public static void main(String[] args) {
            EncapsulationDemo encapsulationDemo = new EncapsulationDemo();
            encapsulationDemo.setName("小明");
            encapsulationDemo.setAddress("北京");
            encapsulationDemo.setAge(18);
            System.out.println("姓名是：" + encapsulationDemo.getName());
            System.out.println("地址是：" + encapsulationDemo.getAddress());
            System.out.println("年龄是：" + encapsulationDemo.getAge());
        }
    }

运行结果：

姓名是：小明  
地址是：北京  
年龄是：18  
  
Process finished with exit code 0

测试类在调用的时候不能直接访问被调用类中的私有属性和方法，只能通过public来使之公有化。

### 接口（Interface） ###

接口是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

**接口的特性**

1）接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。  
        2）除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。  
        3）接口无法被实例化，但是可以被实现。  
        4）一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。  
        5）接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

**接口与类相似点：**

1）一个接口可以有多个方法。  
        2）接口文件保存在.java结尾的文件中，文件名使用接口名。  
        3）接口的字节码文件保存在.class结尾的文件中。  
        4）接口相应的字节码文件必须在与包名称相匹配的目录结构中。

**接口与类的区别**

1）接口不能用于实例化对象。  
        2）接口没有构造方法。  
        3）接口中所有的方法必须是抽象方法。  
        4）接口不能包含成员变量，除了static和final变量。  
        5）接口不是被类继承了，而是要被类实现。  
        6）接口支持多重继承。

** 接口的特性**

1）接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。  
        2）接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键子。  
        3）接口中的方法都是公有的。

下面我们演示接口的一个实例：

InterfaceDemo.java

interface Animal {
        void eat();
    
        void trval();
    }

在接口中声明方法时，public是多余的，可以省略。

接口的实现

1）当类实现接口的时候，类要实现接口中所有的方法，否则，类必须声明为抽象的类。

2）类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

下面我们演示接口实现的实例：

InterfaceDemoTest.java

public class InterfaceDemoTest implements Animal {
    
        @Override
        public void eat() {
            System.out.println("动物吃东西");
        }
    
        @Override
        public void trval() {
            System.out.println("动物会旅行");
        }
    
        public void testMethod() {
            System.out.println("实现接口类中的方法");
        }
    
        public static void main(String[] args) {
            InterfaceDemoTest interfaceDemoTest = new InterfaceDemoTest();
            interfaceDemoTest.eat();
            interfaceDemoTest.trval();
            interfaceDemoTest.testMethod();
        }
    }

运行结果：

动物吃东西  
动物会旅行  
实现接口类中的方法  
  
Process finished with exit code 0

重写接口中声明的方法时，应该注意以下原则：

1）类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。  
        2）类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。  
        3）如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

实现接口的时候也应该注意以下原则：

1）一个类可以同时实现多个接口。  
        2）一个类只能继承一个类，但是能实现多个接口。  
        3）一个接口能继承另一个接口，这和类之间的继承比较相似。

**        接口的继承：**

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

下面演示接口的继承：

Sports.java

public interface Sports {
        void setHomeTeam(String name);
    
        void setVisitingTeam(String name);
    }

Football.java

public interface Football extends Sports {
        void homeTeamScored(int points);
    
        void vistingTeamScored(int points);
    
        void endTeamScored(int points);
    }

Hockey.java

public interface Hockey extends Sports{
        void homeGoalScored(int points);
    
        void vistingGoalScored(int points);
    
        void endGoalScored(int points);
    
        void overtimePeriod(int ot);
    }

以后程序都属于接口，Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。  
        相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。

**接口的多重继承**

在Java中，类的多重继承是不合法，但接口允许多重继承。  
        在接口的多重继承中extends关键字只需要使用一次，在其后跟着继承接口。

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口，与类不同的是，接口允许多重继承，而 Sports及 Event 可能定义或是继承相同的方法。

**标记方法**

最常用的继承接口是没有包含任何方法的接口。  
        标识接口是没有任何方法和属性的接口。它仅仅表明它的类属于一个特定的类型，供其他代码来测试允许做一些事情。  
        标识接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。  
        例如：java.awt.event包中的MouseListener接口继承的java.util.EventListener接口定义如下：

package java.util;
    public interface EventListener
    {}

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

建立一个公共的父接口

正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

向一个类添加数据类型：

这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

### 相关习题 ###

1. 编写一个封装学生信息的对象，在页面中调用该对象，并将学生信息输出在页面中。

1）信息包括：姓名，性别，学号和班级。

Student.java

public class Student {
        private String name;
        private String gender;
        private int stuNum;
        private String classInfo;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getGender() {
            return gender;
        }
    
        public void setGender(String gender) {
            this.gender = gender;
        }
    
        public int getStuNum() {
            return stuNum;
        }
    
        public void setStuNum(int stuNum) {
            this.stuNum = stuNum;
        }
    
        public String getClassInfo() {
            return classInfo;
        }
    
        public void setClassInfo(String classInfo) {
            this.classInfo = classInfo;
        }
    }
    
    class StudentTest {
        public static void main(String[] args) {
            Student student = new Student();
            student.setName("小明");
            student.setGender("男");
            student.setStuNum(130062);
            student.setClassInfo("软件工程");
            System.out.println("姓名是：" + student.getName());
            System.out.println("性别是：" + student.getGender());
            System.out.println("学号是：" + student.getStuNum());
            System.out.println("班级是：" + student.getClassInfo());
        }
    }

运行结果：

姓名是：小明  
性别是：男  
学号是：130062  
班级是：软件工程

Process finished with exit code 0

2. 按如下要求编写Java程序：   
        1）定义接口A，里面包含值为3.14的常量PI和抽象方法double area()。   
        2）定义接口B，里面包含抽象方法void setColor(String c)。   
        3）定义接口C，该接口继承了接口A和B，里面包含抽象方法void volume()。   
        4）定义圆柱体类Cylinder实现接口C，该类中包含三个成员变量：底圆半径radius、 圆柱体的高height、颜色color。

5）创建主类来测试类Cylinder。

CylinderTest.java

interface A {
        double PI = 3.14;
    
        double area();
    }
    
    interface B {
        void setColor(String c);
    }
    
    interface C extends A, B {
        void volume();
    }
    
    class Cylinder implements C {
        private double radius;
        private double height;
        private String color;
    
        public Cylinder(double radius, double height, String color) {
            this.radius = radius;
            this.height = height;
            this.color = color;
        }
    
        @Override
        public double area() {
            return PI * radius * radius;
        }
    
        @Override
        public void setColor(String c) {
            this.color = c;
        }
    
        public String getColor() {
            return this.color;
        }
    
        @Override
        public void volume() {
            System.out.println("圆柱的体积为：" + this.area() * this.height);
        }
    }
    
    public class CylinderTest {
        public static void main(String[] args) {
            System.out.println("Test c1");
            A c1 = new Cylinder(2, 5, "red");
            System.out.println("面积为：" + c1.area());
            System.out.println(((Cylinder) c1).getColor());
            System.out.println("------------分割线---------");
            System.out.println("Test c2");
            B c2 = new Cylinder(5, 2, "blue");
            System.out.println("面积为：" + ((Cylinder) c2).area());
            System.out.println(((Cylinder) c1).getColor());
            c2.setColor("green");
            System.out.println(((Cylinder) c2).getColor());
            System.out.println("------------分割线---------");
            System.out.println("test c3:");
            C c3 = new Cylinder(1, 2, "blank");
            System.out.println("面积为：" + c3.area());
            c3.volume();
            System.out.println(((Cylinder) c3).getColor());
        }
    }

运行结果：

Test c1  
面积为：12.56  
red  
\------------分割线---------  
Test c2  
面积为：78.5  
red  
green  
\------------分割线---------  
test c3:  
面积为：3.14  
圆柱的体积为：6.28  
blank  
  
Process finished with exit code 0