面向对象三大特性之一封装

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

我们程序设计追求“高内聚，低耦合”，高内聚就是类的内部数据操作 细节自己完成，不允许外部干涉；低耦合即为仅暴露少量的方法给外部使用。

主要记住这句话：属性私有，get/set

例如可以通过定义一个Student类和Application类，以如下代码深入了解封装及私有属性的利用。

Student类

//类   private:私有属性
public class Student {
    //名字
    //学号
    //性别
   private String name;
   private int id;
   private char  sex;
   private int age;
    //学习()
    public void study(){}
    //睡觉()
    public void sleep(){}
​
    //提供一些可以操作的方法  get set 方法
    /*
    get 获得这个数据
    set 给这个数据设置一些值
     */
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        if (age>120 || age<0){
            this.age=3;
        }else {
            this.age = age;
        }
    }

Application类

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小三");
        System.out.println(student.getName());
        student.setAge(520);
        System.out.println(student.getAge());
    }
    }

那么接口又是什么？如何实现？

接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范！

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是~则必须能~”的思想。

接口的本质是契约，就像我们法律一样，制定好后大家都要遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。

那么这里提到了抽象类，我们可以利用abstract对抽象类一个大概了解。

Abstract

父类Action

//abstract   抽象类   extends 单继承   接口可以多继承
public abstract class Action {
    //约束，有人帮我们实现
    public abstract void doSomething();
    /*
    1、不能new这个抽象类，只能靠子类去实现它：约束！
    2、抽象类可以写普通方法
    3、抽象方法必须在抽象类中
    抽象的抽象为约束
     */
}

子类A

//抽象类的所有方法必须要有子类实现
//继承了它的子类都必需要重写方法  除非都是抽象类
public class A extends Action {
    @Override
    public void doSomething() {
​
    }
}

我们知道extends只能单继承，而接口可以多继承。

UserService类

//定义的关键字   interface    接口都有实现类
public interface UserService {
    //接口中的所有定义的属性都是常量  public static final
    int AGE=99;
    //接口中的所有定义的方法都是 抽象的 public abstract
   void add(String name);
   void delete(String name);
   void query(String name);
   void update(String name);
}

TimeService类

public interface TimeService {
    void timer();
}

UserServiceImpl类

//抽象类：extends~
//类可以实现接口 通过implements 接口
//实现了接口的类就必须重写接口中的方法
//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
​
    }
​
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void query(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
​
    @Override
    public void timer() {
​
    }
}