示例如下：

package com.hy;
/*
面向对象的特征一：封装与隐藏
一：问题的引入：
当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值，
这里，赋值操作要受到属性的数据类型和存储范围制约，除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值。
加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加（比如：setLegs)
同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为私有的（private)
二：封装性的体现：
我们将类的属性私有化（private),同时，提供公共的方法来获取（getxxx)和设置(setxxx)此属性的值。
拓展：封装性的体现，（1）如上（2）不对外暴露的私有方法*/
public class F_ {public static void main(String[] args) {Animal animal = new Animal();animal.setAge(99);animal.name="gog";animal.setLegs(6);animal.eat();animal.show();System.out.println(animal.getLegs());System.out.println(animal.getAge());}
}class Animal{private String name;private   int age;private int legs; //腿的个数public void  eat(){System.out.println("动物进食");}public  void show(){System.out.println("name="+name+",age="+age+",legs="+legs);}public  void  setLegs(int l){if(l>=0&l%2==0){legs=l;}else {legs=0;}}public  int getLegs( ){return legs;}public void setAge(int m){if(m>=0){age=m;}else {age=0;}}public int getAge(){return age;}public void setName(int n){if(name)}
}

运行之后如下所示：

 我们程序设计追求“高内聚，低耦合”

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅对外暴露少量的方法用于使用

权限的问题：

隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性、可维护性，通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想。

	类内部	同一个包	不同包的子类	同一个工程
private	yes
缺省	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

//同一个包中的同一个类，可以调用私有（private)的属性、方法
//同一个包中的其他类，不可以调用Order类中私有（private)的属性、方法
//同一个包中的其他类，可以调用Order类中缺省、protected、public的属性、方法
///在不同包的子类中，不可以调用Order类中私有（private)和缺省权限的属性、方法
//在不同包的子类中，可以调用Order类中protected和public的属性、方法
//不同包下的普通类（非子类）要使用order类，不可以调用声明为private、缺省、protected的权限的属性、方法

package com.hy;
/*
面向对象的特征一：封装与隐藏
一：问题的引入：
当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值，
这里，赋值操作要受到属性的数据类型和存储范围制约，除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值。
加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加（比如：setLegs)
同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为私有的（private)
二：封装性的体现：
我们将类的属性私有化（private),同时，提供公共的方法来获取（getxxx)和设置(setxxx)此属性的值。
拓展：封装性的体现，（1）如上（2）不对外暴露的私有方法（3）单例模式三、封装性的体现，需要权限修饰符来配合
1.Java规定的4种权限，（从小到大排列），private、缺省(default,什么也不写)、protected、public
2.4种权限可以用来修饰类及类的内部结构、属性、方法、构造器、内部类
3.具体的，4种权限都可以用来修饰类的内部结构、属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public*/
public class F_ {public static void main(String[] args) {Animal animal = new Animal();animal.setAge(99);animal.setLegs(6);animal.eat();animal.show();System.out.println(animal.getLegs());System.out.println(animal.getAge());}
}class Animal{private String name;private   int age;private int legs; //腿的个数public void  eat(){System.out.println("动物进食");}public  void show(){System.out.println("name="+name+",age="+age+",legs="+legs);}public  void  setLegs(int l){if(l>=0&l%2==0){legs=l;}else {legs=0;}}public  int getLegs( ){return legs;}public void setAge(int m){if(m>=0){age=m;}else {age=0;}}public int getAge(){return age;}}

 权限：

package com.hy;
/*
面向对象的特征一：封装与隐藏
一：问题的引入：
当我们创建一个类的对象以后，我们可以通过“对象.属性”的方式，对对象的属性进行赋值，
这里，赋值操作要受到属性的数据类型和存储范围制约，除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值。
加入额外的限制条件，这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加（比如：setLegs)
同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为私有的（private)
二：封装性的体现：
我们将类的属性私有化（private),同时，提供公共的方法来获取（getxxx)和设置(setxxx)此属性的值。
拓展：封装性的体现，（1）如上（2）不对外暴露的私有方法（3）单例模式三、封装性的体现，需要权限修饰符来配合
1.Java规定的4种权限，（从小到大排列），private、缺省(default,什么也不写)、protected、public
2.4种权限可以用来修饰类及类的内部结构、属性、方法、构造器、内部类
3.具体的，4种权限都可以用来修饰类的内部结构、属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public
总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，
体现类及类的内部结构在被调用时的可见性的大小*/
public class F_ {public static void main(String[] args) {Animal animal = new Animal();animal.setAge(99);animal.setLegs(6);animal.eat();animal.show();System.out.println(animal.getLegs());System.out.println(animal.getAge());}
}class Animal{private String name;private   int age;private int legs; //腿的个数public void  eat(){System.out.println("动物进食");}public  void show(){System.out.println("name="+name+",age="+age+",legs="+legs);}public  void  setLegs(int l){if(l>=0&l%2==0){legs=l;}else {legs=0;}}public  int getLegs( ){return legs;}public void setAge(int m){if(m>=0){age=m;}else {age=0;}}public int getAge(){return age;}}

构造器：

package com.hy;
/*
类的结构之三：构造器（或构造方法、constructor)的使用一、构造器的作用：
创建对象
二、说明：
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式，权限修饰符  类名（形参列表 ）*/public class Person {String name;int age;//构造器public Person(){System.out.println("Person( )...");}public void  eat(){System.out.println("人吃饭");}public  void  study(){System.out.println("人可以学习");}
}
class PersonTest{public static void main(String[] args) {//创建类的对象 ：new +构造器Person person = new Person();person.eat();}}

运行之后如下所示：

我们新建如下所示：

package com.hy;
/*
类的结构之三：构造器（或构造方法、constructor)的使用一、构造器的作用：
1.创建对象
2.初始化对象的信息
二、说明：
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式，权限修饰符  类名（形参列表 ）
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器。*/public class Person {String name;int age;//构造器public Person(){age=18;}public void setName(String n){name=n;}public String getName(){return name;}public Person(String n,int a){name=n;age=a;}public void  eat(){System.out.println("人吃饭");}public int getAge(){return age;}public  void  study(){System.out.println("人可以学习");}
}
class PersonTest{public static void main(String[] args) {//创建类的对象 ：new +构造器Person person = new Person();System.out.println("年龄为："+person.getAge());Person s = new Person("S", 5);Person person1 = new Person();}}

运行之后如下所示：

 总结：属性赋值的先后顺序

（1）默认初始化

   (2)显式初始化

（3）构造器中初始化

（4）通过“对象.方法”或“对象.属性”的方式，赋值

以上操作的先后顺序：（1）---（2）---（3）----（4）

JavaBean:

package com.hy;/*** javaBean是一种java语言写成的可重用组件。* 所谓javaBean，是指符合如下标准的Java类：* （1）类是公共的* （2）有一个无参的公共的构造器* （3）有属性，且有对应的get、set方法** 用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且* 其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。* 用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。*/
public class TriAngle {int age;public TriAngle() {}public void setAge(int a){age=a;}public int getAge() {return  age;}}

UML类图：

 最外层为包名，内部为类名

 1.+表示public类型，-表示private类型，#表示protected类型

 2.方法的写法： * 方法的类型（+、-） 方法名（参数名：参数类型）：返回值类型