示例如下：
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.方法的写法： * 方法的类型（+、-） 方法名（参数名：参数类型）：返回值类型