封装概述 

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点 

1.隐藏实现细节，提供公共的访问方式 

2.提高了代码的复用性 

3.提高安全性。

Java封装实例

class Student{
    String name;
    private int age; //将age属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
    public void show(){
        System.out.println("名字: " + name);
        System.out.println("年龄: " + age);
    }
    public void getAge(int a){
    age = a;
    }
}

class StudentDemo{
    public static void main(String[] args){
        Student s = new Student();
        s.show();
        System.out.println("-------------------");
        //给成员变量赋值
        s.name = "李冰冰";
    //通过方法赋值
        s.getAge(27);
        s.show();

    }
}

private关键字 

是一个权限修饰符，可以修饰成员变量和成员方法，被其修饰的成员只能在本类中被访问。

例1：不能访问私有的成员变量

class demo{
    int num = 10;
}

class PrivateDemo{
    public static void main(String[] args){
        demo d = new demo();
        System.out.println(d.num);
    }
}

输出结果： 

C:\Users\Dell\Desktop\study>java PrivateDemo 

10



class demo{
    private int num = 10;  //用private修饰
}

class PrivateDemo{
    public static void main(String[] args){
        demo d = new demo();
        //不能访问私有的成员方法
        System.out.println(d.num);
    }
}

输出结果： 

C:\Users\Dell\Desktop\study>javac PrivateDemo.java 

PrivateDemo.java:8: 错误: num可以在demo中访问private 

        System.out.println(d.num); 

                            ^ 

1 个错误 

程序报错了，因为用了private关键字修饰，只能通过公共方式访问。

修改程序：

class demo{
    private int num = 10;  //用private修饰
    public void show(){
    System.out.println(num);
    }
}

class PrivateDemo{
    public static void main(String[] args){
        demo d = new demo();  //通过公共方式进行访问
        d.show();
    }
}

例2：不能访问私有的成员方法



class demo{
    private void method(){  //定义method成员方法
        System.out.println("method");
    }  

}

class PrivateDemo{
    public static void main(String[] args){
        demo d = new demo();  
        d.method();  //不能访问私有的成员方法
    }
}

程序会报错： 

C:\Users\Dell\Desktop\study>javac PrivateDemo.java 

PrivateDemo.java:11: 错误: method()可以在demo中访问private 

        d.method(); 

         ^ 

1 个错误

修改程序：



class demo{
    private void method(){  //定义method成员方法
        System.out.println("method");
    }
    public void function(){
        method();
    }

}

class PrivateDemo{
    public static void main(String[] args){
        demo d = new demo();
        d.function();
    }
}

封装


java中的封装是将代码和数据一起封装到单个单元中的过程，例如胶囊，即几种药物的混合。

我们可以通过将类的所有数据成员设为private，以在java中创建一个完全封装的类。现在我们可以使用setter和getter方法来设置和获取其中的数据。Java Bean类是完全封装类的示例。

封装的应用

//save as Student.java  
package com.lch;

public class Student {
    private String name;

    public String getName() {
        return name;
    }

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

该封装后只能通过set和get方法进行访问
//save as Test.java  
package com.lch;

class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("vijay");                                                            //设置set
        System.out.println(s.getName());                                       //使用get进行访问
    }
}

输出结果
vijay

1、方法的重载：

  方法名一样。  2.参数列表不一样（参数个数不同或参数类型不用）。
  注意：重载只跟参数有关，与返回类型无关。方法名和参数相同而返回类型不相同，不能说是重载。


2、JRE 和 JDK 分别是什么意思？

  JRE:Java Runtime Environmengt ：java运行时环境，包括java虚拟机和java基础库。

  JDK：java Development Kit ： java开发工具包。


3、怎样理解JAVA的平台可移植性？

   java被编译成字节码，字节码与平台无关只面向JVM编写，因为java有一个JVM（Java Virtual Machine）java虚拟机，不同操作平台有自己的JVM，所以java可以跨平台运行。


4、构造方法：主要创建对象时初始化对象（给他赋值）。

   构造方法与类名相同，可重载多个方法         不能加返回值void




构造方法例题1：

public class Ex_animal {  

public static void main(String[] args) {  
    // TODO Auto-generated method stub  

    Animal an1 = new Animal("兔子","草",5);  
    Animal an2 = new Animal();  
    Animal an3 = new Animal(an1,an2);  
    an2.all(an3);  
}  


} 

class Animal{ 

    String name; 

    String eat; 

    int weight; 

    public Animal() { 

        this.name = name; 

        this.eat = “猪蹄”; 

        this.weight = 12; 

    } 

    public Animal(Animal a,Animal b) { 

        this.name = b.name; 

        this.eat = a.eat; 

        this.weight = b.weight;  

}  
public Animal(String name,String eat,int weight) {  
    this.name = name;  
    this.eat = eat;  
    this.weight = weight;  
}  
public Animal(String name,int weight) {  
    this.name = name;  
    this.weight = weight;  
}  
public void eat1() {  
    System.out.println("这个动物喜欢吃" + this.eat);  
}  
public void run() {  
    System.out.println("这个动物会跑");  
}  
public void all(Animal an) {  
    System.out.println("这是一只 " + this.name + "，它喜欢吃 " + an.eat + ",它重 " + an.weight +" 斤");  
}  


}  



构造方法例题2

/**  

 * 测试类  

 *  

 * @author lenovo64  

 *这只小狗是小白，白色正在和那只小猫叫做小黑，黑色在打架  

 *获胜的动物是黑色  

 */ 

public class Test { 

    public static void main(String[] args) {  

    Animal dog = new Animal("小黑", "小猫", "黑色");  
    Animal cat = new Animal("小白", "小狗", "白色");  
    String s = dog.play(cat, dog);  
    System.out.println("获胜的动物是" + s);  
}  


}  

class Animal { 

    String name; 

    String kind; 

    int age; 

    String color; 

    long animalID; 

    String date;  

public Animal(String name, String kind) {  
    this.name = name;  
    this.kind = kind;  
}  

public Animal(String name, String color, String kind) {  
    this.name = name;  
    this.color = color;  
    this.kind = kind;  
}  

public Animal(String name, int age, long animalID) {  
    this.age = age;  
    this.animalID = animalID;  
}  

public String play(Animal dog, Animal cat) {  
    System.out.println("这只" + dog.color + "是" + dog.name + "，" + dog.kind + "，正在和那只" + cat.color + "叫做" + cat.name  
            + "，" + cat.kind + "，在打架");  
    return cat.kind;  
}  


} 

                                                                                //5月10日



1、什么是封装？

将对象信息，内部逻辑结构隐藏起来。封装就是将属性私有化，提供公有的方法访问私有属性。 

        做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（getter）方法和赋值（setter）方法，用于对这些属性的访问。 

            例如：private String name; 

            public String getName(){ 

                            return; 

                  } 

            public void setName(String name){ 

                         this.name=name; 

                  }

2、为什么需要封装？

通过封装，可以实现对属性的数据访问限制，同时增加了程序的安全性。



3、如何实现封装，实现封装的具体方法？

   （1）、修改属性的可见性来限制对属性的访问。
   （2）、为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。
   （3）、在赋值和取值方法中，加入对属性的存取的限制。




4、权限修饰符4个级别：



5、static类成员：

公用的东西，实现某个方法或属性与关联在一起。



对象成员：

每个对象独立拥有的东西

6、修饰数据成员的final：

这是final的主要用途是将该成员修饰为常量，意味着不可修改。

1.封装简介

概念 

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

    直接通过操控类对象来达到目的，不需要对具体实现十分了解，使类属性和方法的具体实现对外不可见。不但方便还起到了保护作用。



封装的实现



先了解java的访问修饰符



演示代码： 


Java 中的内部类

问：什么是内部类呢？

答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！

答：内部类的主要作用如下：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据（方便）
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
问：内部类有几种呢？

答：内部类可分为以下几种： 

◦成员内部类 

◦静态内部类 

◦方法内部类 

◦匿名内部类

Java 中的成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：



从上面的代码中我们可以看到，成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

4、 编译上面的程序后，会发现产生了两个 .class 文件



其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，友情提示哦：

1、 外部类是不能直接使用内部类的成员和方法滴



可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：



Java 中的静态内部类

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

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();（这里和成员内部类比起方便的多了）