什么是封装？

封装，就是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，只能通过该类提供的方法来实现对隐藏信息的操作和访问。

封装隐藏的是属性，留出可以访问的接口就是访问方法。

封装的特点

  1. 只能通过规定的方法访问数据
  2. 隐藏类的实例细节，方便修改和实现

封装的实现

为了实现良好的封装，需要从两个方面考虑

  1. 把字段（成员变量）和实现细节隐藏起来，不允许外部直接访问
  2. 把方法暴露出来，让方法控制这些成员变量进行安全的访问和操作

步骤：

  1. 修改属性的可见性

    1. public class Person {
    2. //将属性的访问控制修饰符修改为private-限定只能在当前类内被访问
    3.  private String name;
    4. }

  2. 创建公有的get/set方法

    1. public class Person {
    2. //获取属性方法
    3. public String getName() {
    4.      return name;
    5.  }
    6. //修改属性方法
    7. public void setName(String name) {//传入相同的参数名与属性形成对照
    8.      this.name = name;
    9.  }
    10. }

    get + 首字母大写的属性名() ：get 方法一般都是具有和属性数据类型一致的返回值，并且是没有形参的。
    set + 首字母大写的属性名(参数)：set 方法一般都是具有和属性数据类型一致的方法参数，返回值一般是 void。

  3. 在get/set方法中加入属性控制

加入属性控制，是为了对数据进行合理的修改和判断，对成员变量（对象属性）进行更精确的控制。

  1. /**
  2.  * 针对年龄范围作出合理限制
  3.  * @param month
  4.  */
  5. public void setAge(int age) {
  6.     if(age < 0 || age >= 240) {
  7.         System.out.println("年龄不合理，暂定为1");
  8.         this.age = 1;
  9.     } else {
  10.         this.age = age;
  11.     }
  12. }

在另一个类中的访问和操作

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Cat one = new Cat();
  4.         one.setName("张三");
  5.         System.out.println("名字：" + one.getName());
  6.     }
  7. }

带参构造器中的属性控制

使用带参构造器可以实现对象实例化时候的属性设定。
如：

  1. public class Person {
  2.         private int age;
  3.         public Person() {
  4.         }
  5.         public Person(int age) {
  6.         this.age = age;
  7.         }
  8.     public void setAge(int age) {
  9.                 if(age < 0 || age >= 240) {
  10.                 System.out.println("年龄不合理，暂定为1");
  11.                         this.age = 1;
  12.                     } else {
  13.                         this.age = age;
  14.                     }
  15.             }
  16. }
  18. public class Test {
  19.         public static void main(String[] args) {
  20.         Person person = new Person(-3);
  21.         System.out.println(person.getAge());
  22.         }
  23. }

我们发现上述代码执行之后，并没有完成对属性值的限制，这是因为在构造器中，我们直接对属性值进行了操作。所以，我们可以利用set方法中的属性限制，完成代码逻辑。

  1. public Person(int month) {
  2.     //this.age = age;
  3.     this.setAge(age);
  4. }

static关键字

  1. static代表着静态信息，被static修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static声明的成员变量属于静态成员变量，静态变量存放在 Java 内存区域的方法区。

  2. static表示静态的，static修饰的属性称之为【类变量，静态变量】，方法称之为【类方法，静态方法】。

  3. 在Java程序中，static修饰的成员具有这样一个特征，无论该类最终实例化出来多少对象，静态成员都会共用一块静态空间。也就是说，如果调用一个静态属性，无论是哪个对象去调用修改，两者都在针对同一块内存空间进行操作。

普通成员和静态成员的区别：

  1. 对普通成员而言：当这个类的对象产生的时候，它的相关成员会产生，而当这个对象销毁的时候，这些成员就会进行资源释放；
  2. 对静态成员而言：从类第一次加载的时候，静态成员就会产生，一直到这个类不在有任何对象被使用。也就是它彻底销毁的时候，静态资源才会进行资源的释放。所以静态成员的生命周期比较长。

静态资源有着如下的特性：

  1. 类对象共享
  2. 类加载时产生，销毁时释放，生命周期长

静态资源的访问方式：

  1. 对象.静态成员
  2. 类.静态成员

static能用来修饰方法和属性。

静态内容与非静态内容的访问限制

  1. 在普通成员方法中，可以直接访问类中静态成员（对象.静态资源）
  2. 静态方法中不能直接访问同一个类的非静态成员，只能直接调用同一个类中的静态成员，如果想要访问非静态成员，只能通过对象实例化后，对象.成员方法/属性的方式访问
  3. static修饰的方法中不能出现this

关于代码块的执行顺序

在Java中，如果在语句当中出现{}，这样的大括号对这就叫代码块。

  1. 普通代码块——顺序执行
  2. 构造代码块——创建对象时调用，优先于构造方法执行；多个构造代码块顺序执行；
  3. 静态代码块——static修饰的代码块，优于构造代码块执行，多个静态代码块顺序执行；无论产生多少个实例，只调用一次。

总结：

  1. 仅希望执行一次的代码就可以放到静态代码块中，这样可以提高代码的执行效率。
  2. 在普通代码块中可以操作类成员，但是在静态代码块中只能操作静态成员，如果想用需要先实例化对象，通过对象.成员调用。