面向对象语言特性之封装

面向对象语言有三大特性：封装，继承，多态。

封装 (encapsulation)，隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。

封装就是把类的一些信息隐藏起来，不允许外部程序直接访问，而是通过这个类提供的方法来实现对内部隐藏的信息的访问和操作。

一句话：什么是封装？封装就是隐藏内部实现，稳定外部接口，保护数据安全。

封装的好处显而易见：便于使用者正确使用，防止错误修改属性；松耦合，提高了系统独立性；提高了代码重用性。

封装的步骤

把属性用private修饰符修饰，成员变量只能在当前类中访问
设置public的setter和getter方法，供外部调用
使用public的方法访问

示例：

public class Person {
    //用private修饰属性
    private String name; 
    private int age;
    //设置setter和getter方法
    public String getName() {  
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

class Test{
    public static void main(String[] args) {
        Person p = new Person();
        //调用etter和getter方法访问属性
        p.setName("张三");　　　　　　
        p.setAge(18);
        System.out.println(p.getName());
    }
}

包

包是封装思想的一种体现。包的实质是一种访问控制机制。
包，使用package关键字，用来管理类文件，包的声明必须是在JAVA源文件的第一句非注释语句，一个源文件只能有一个包的声明语句。
使用包的好处：1，类似文件夹的概念，方便查找相应的类文件；2，防止命名冲突，在不同包中的类可以重名；3，在更广的范围内保护类、数据和方法。

 package 包名;
 //例如
 package cn.beida.javagroup.mypackage;

在当前包中访问其他包中的类，要先导入那个类所在的包，使用关键字import，
package只能有一句，但是import 可以有多句。

 package cn.beida.javagroup.mypackage;
 
 import java.util.Scanner;
 import cn.beida.online.*;
 import cn.beida.animal.Dog;

同名不同包的类出现在同一个类中时，要用完整的包限定名来声明类

com.oop.Dog     dog1 = new com.oop.Dog();
com.oop.pet.Dog dog2 = new com.oop.pet.Dog();

访问权限控制

类的访问修饰符有两个，public 和默认修饰符；public 修饰的类在不在同一个包中都可以访问；默认修饰符修饰的类只能在同包中访问。（默认修饰符就是类名前什么也不写）

public class Person{  //public 修饰的类
}

class Student{  //默认修饰符修饰的类
}

	同一个类中	同一个包中	子类中	其他地方
private	可以访问	不可以访问	不可以访问	不可以访问
默认修饰符	可以访问	可以访问	不可以访问	不可以访问
protected	可以访问	可以访问	可以访问	不可以访问
public	可以访问	可以访问	可以访问	可以访问

类的成员访问修饰符有四个，用来修饰成员变量和成员方法：

	同一个类中	同一个包中	子类中	其他地方
private	可以访问	不可以访问	不可以访问	不可以访问
默认修饰符	可以访问	可以访问	不可以访问	不可以访问
protected	可以访问	可以访问	可以访问	不可以访问
public	可以访问	可以访问	可以访问	可以访问

static修饰符

static 用来修饰成员变量和成员方法，使用static修饰的属性和方法属于类，可以通过类名加“.”直接调用，（也可以通过实例访问，但不建议）。
使用static修饰的变量叫做静态变量；
使用static修饰的方法叫做静态方法；
使用static修饰的代码块叫做静态代码块；

静态变量或静态方法，静态代码块位于JVM的方法区，当JVM加载类时，会把静态区一起加载到内存中去。当main方法里的语句还没执行时，静态区的代码已经执行完了。

静态变量

也叫做类变量，在内存中只有一个拷贝；在类的内部可以直接访问，在其他类中通过类名访问；
而实例变量是通过实例访问，每创建一个实例，就会为实例变量分配一次内存。

静态变量会在编译期间系统自动初始化并赋默认值为0；静态变量的好处是能被所有实例共享，如果类的所有实例包含一个相同的常量属性，可以把这个属性定义为静态常量类型，从而节省内存，如：static final PI = 3.14;。

注意：静态变量只能定义在类里，不能定义在方法里。

静态方法

静态方法由类名直接调用；不能直接访问实例变量和实例方法，只能访问静态变量和静态方法；静态方法必须被实现；静态方法中不能有this或super;

实例方法由实例调用，可以访问静态变量，静态方法，实例变量，实例方法。

静态代码块

JVM加载类时加载静态代码块，如果有多个静态块，就按顺序加载，每个静态块只会被执行一次。

示例：

public class Vote {
    //static修饰属性
    private static int count;   //投票数， 所有人都会改变同一个数
    private static final int MAX_COUNT = 100;//最大投票数，
    private String name;//投票人的姓名
    //构造方法
    public Vote(String name){
        this.name = name;
    }
    //投票方法
    public void voteFor(){
        if(count == MAX_COUNT){
            System.out.println("投票结束");
        }else{
            System.out.println("谢谢  "+this.name+"  的投票");
            count++;
        }
    }
    //static 修饰方法
    public static void printResult(){
        System.out.println("投票总数是"+count);
    }
}

public class VoteTest {
    public static void main(String[] args) {
        Vote v1 = new Vote("jim");
        Vote v2 = new Vote("jane");
        v1.voteFor();
        v2.voteFor();
        for(int i = 1; i < 99; i++){
            Vote v = new Vote("v"+i);
            v.voteFor();
        }
        Vote v3 = new Vote("tom");
        v3.voteFor();

        //静态方法用类名来调用
        Vote.printResult();
    }
}