在面向对象程式设计方法中，封装（Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装可以被认为是一个保护屏障、防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装的主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也将强了程式码的安全性。

封装的优点

良好的封装能够减少耦合
类内部的结构可以自由修改
可以对成员变量进行更精确的控制
隐藏信息，实现细节

实现Java的封装

修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
        private String name;
        private int age;
}

这段代码中，将name和age属性设置为私有的，只能本类才能访问，其它类都访问不了，如此就对信息进行了隐藏。

对每个值属性提供对外的公共方法访问，也就是创建一对赋值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

    public void setName(String name){
      this.name = name;
    }
}

采用this关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

让我们来看一个Java封装类的例子：

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

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

/* F文件名 : RunEncap.java */
public class RunEncap{
   public static void main(String args[]){
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ 
                             " Age : "+ encap.getAge());
    }
}

以上代码编译运行结果如下：

Name : James Age : 20

包

有时候在封装的时候会遇到这样的问题，就是我们的类名可能是重复的。为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

包的作用

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包采用了树形目录的存储方式。同一个包中的类名字是不同，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

定义包语法

package 包名
//注意：必须放在源程序的第一行，包名可用"."号隔开

例如：

//我们在定义文件夹的时候利用"/"来区分层次
//包中我们用"."来分层
package com.shiyanlou.Java

不仅是我们这样利用包名来区分类，系统也是这样做的。

系统中的包
java.(功能).(类)
java.lang.(类) 包含java语言基础的类
java.util.(类) 包含java语言中各种工具类
java.io.(类) 包含输入、输出相关功能的类

那我们怎么在不同包中使用另一个文件中的类呢？这时候就需要用到import关键字。比如我们要导入实验楼下People这个类。import com.shiyanlou.People，同时如果import com.shiyanlou.*这是将包下的所有文件都导入进来，*是通配符。
这里要注意一点，包的命名规则是全小写字母拼写。

访问修饰符

我们在前面的代码中经常用到private和public修饰符，这些修饰符的作用和意义是什么呢？接下来我们就来学习Java中的访问修饰符。
访问修饰符可以用来修饰属性和方法的访问范围。

访问修饰符	本类	同包	子类	其它
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

如图所示，代表了不同的访问能修饰符的访问范围，比如 private 修饰符的属性或者方法，只能在当前类中中访问或者使用。默认是什么修饰符都不加，默认在当前类中和同一包下都可以访问和使用。protected修饰的属性或者方法，对同一包内的类和所有子类可见。public修饰的属性或者方法，对所有类可见。
我们可以举一个例子，比如 money，如果我们用private修饰代表着这是私有的，只能我自己可以使用。如果是protected代表着我可以使用，和我有关系的人，比如儿子也可以用。如果是public就代表了所有人都可以使用。

内部类

可以将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。
内部类的主要作用如下：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其它类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类允许继承多个非接口类型

注意：内部类是编译时的概念，一旦编译成功，就会称为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

我们通过代码来详细学习以下内部类把！

成员内部类

ackage com.shiyanlou;

//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + name);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象，对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
        // 或者为 People.Student b = a.new Student();
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}

由此，我们可以直到，成员内部类的使用方法：

Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符。
Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）
定义成员内部类后，必须使用外部类对象来创建内部类对象，即内部类对象名 = 外部类对象.new 内部类();
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字加上述代码中：a.this

注：成员内部类不能含有static的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

静态内部类

静态内部类通常被称为嵌套类。

package com.shiyanlou;

//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX"; 

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + (new People().name));
            System.out.println("访问外部类中的ID：" + People.ID);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象，对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

以上代码编译运行结果如下：

访问内外部类中的name：LiLei
访问外部类中的ID：510xxx199X0724XXXX
访问内部类中的ID：20151234

静态内部类是static修饰的内部类，这种内部类的特点是：

静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问
如果外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过成员名直接调用外部类的静态成员
创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名=new 内部类();

局部内部类

局部内部类，是指内部类定义在方法和作用域内。
例如：

package com.shiyanlou;

//外部类People
public class People {    
    //定义在外部类中的方法内：
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex：" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex：" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内：===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内：===========");
        b.peopleInfo2(true);
    }
}

以上编译运行结果如下：

定义在方法内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID：20151234
定义在作用域内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID：20151234

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

匿名内部类

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所有匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
例如：

public class Outer { 

    public Inner getInner(final String name, String city) { 
        return new Inner() { 
            private String nameStr = name; 
            public String getName() { 
                return nameStr; 
            } 
        };
    } 

    public static void main(String[] args) { 
        Outer outer = new Outer(); 
        Inner inner = outer.getInner("Inner", "NewYork"); 
        System.out.println(inner.getName()); 
    } 
} 
interface Inner { 
    String getName(); 
}

以上代码编译运行结果如下：

Inner

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的，如果不限定义，编译时会报错该类找不到。
同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。
然而，因为匿名内部类没名字，是用默认的构造函数的，无参数的，如果需要该类有带参数的构造函数，示例如下：

public Inner getInner(final String name, String city) { 
        return new Inner(name, city) { 
            private String nameStr = name; 

            public String getName() { 
                return nameStr; 
            } 
        }; 
    }

注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造函数所使用，所以不必定义为 final。

Java封装

封装的优点

实现Java的封装

包

包的作用

访问修饰符

内部类

成员内部类

静态内部类

局部内部类

匿名内部类

你可能感兴趣的:(Java封装)