JAVA自学教程之（封装及其思想）



JAVA自学教程之（封装及其思想）。封装（Encaplusation）：
指：隐藏对象的属性和实现细节，只对外提供公共访问方式
优点： 1。将变化隔离 2.便于使用 3.提高重要性 4.提高安全性 封装原则： 1.将不需要对外提供的的内容隐藏起来

2.将属性隐藏，进对外提供其公共访问方式

 

事例代码：

  1. class man
  2. {
  3.     private int age;//年龄
  4.     private String sex;//性别
  5.     public void change(int a,String b)
  6.     {
  7.         if(a < 0 || a>130)
  8.         {
  9. System.out.println(“错误数据”);
  10.             return ;
  11.         }
  12.         age = a;
  13.         sex = b;
  14.         fun();
  15.     }
  17.     void fun()
  18.         {
  19.             System.out.println(“age = “+age+”，sex = “+sex);
  20.         }
  23. }
  25. public class Main
  26. {
  27.     public static void main (String[] args)
  28.     {
  29.         man jo = new man();
  30.         //jo.age = -20;这样就有不安全性，所以用private，将成员属性私有，外界就无法访问
  31.         jo.change(20,”man”);
  32.     }
  33. }
class man
{
	private int age;//年龄
	private String sex;//性别
	public void change(int a,String b)
	{
		if(a < 0 || a>130)
		{
			System.out.println("错误数据");
			return ;
		}
		age = a;
		sex = b;
		fun();
	}

	void fun()
		{
			System.out.println("age = "+age+"，sex = "+sex);
		}

}

public class Main
{
	public static void main (String[] args) 
	{
		man jo = new man();
		//jo.age = -20;这样就有不安全性，所以用private，将成员属性私有，外界就无法访问
		jo.change(20,"man");
	}
}

 

在实际开发过程中，已经形成了一种规范


书写规范：set（存放数据） 和 get（得到数据）

  1. class man
  2. {
  3.     private int age;//年龄
  4.     private String sex;//性别
  5.     public void setage(int a,String b)//存放
  6.     {
  7.         if(a < 0 || a>130)
  8.         {
  9.             System.out.println(“错误数据”);
  10.             return ;
  11.         }
  12.         age = a;
  13.         sex = b;
  14.     }
  15.     public int getage()  //获取
  16.     {
  17.         return age;
  18.     }
  19.     void fun()
  20.         {
  21.             System.out.println(“age = “+age+”，sex = “+sex);
  22.         }
  25. }
  27. public class Main
  28. {
  29.     public static void main (String[] args)
  30.     {
  31.         man jo = new man();
  32.         jo.setage(20, “fa”);
  33.         int ag = jo.getage();
  34.         System.out.println(ag);
  35.     }
  36. }
class man
{
	private int age;//年龄
	private String sex;//性别
	public void setage(int a,String b)//存放
	{
		if(a < 0 || a>130)
		{
			System.out.println("错误数据");
			return ;
		}
		age = a;
		sex = b;
	}
	public int getage()  //获取
	{
		return age;
	}
	void fun()
		{
			System.out.println("age = "+age+"，sex = "+sex);
		}

}

public class Main
{
	public static void main (String[] args) 
	{
		man jo = new man();
		jo.setage(20, "fa");
		int ag = jo.getage();
		System.out.println(ag);
	}
}

上述代码就是简单的封装性的体现，最明显的体现就是安全性，注意一点就是属性一般都是隐藏的。
封装的思想：
例子：各种电器就是一个很好的封装体，电器的开关，就是对外提供的访问方式，至于内部怎么访问，就不需要了解了，对用户是隐藏的。
当然，对象也是如此。
private 私有，是一个权限修饰符，权限最小，只能修饰成员，不能修饰局部         私有内容只在本类中有效 public 共有，权限最大
注意：private私有仅仅是封装的一种体现，私有是封装，封装并不代表私有
类、框架本身就是一个封装体
小练习：

 

封装完成，10个数的插入排序功能。

代码:

  1. import java.util.Scanner;
  3. import javax.naming.ldap.SortControl;
  6. class jo
  7. {
  8.     public void set(int a[])//公共访问方式
  9.     {
  10.         intsrtsort(a);
  11.     }
  12.     private static void intsrtsort(int a[])//插入排序
  13.     {
  14.         int len = a.length;
  16.         for(int i = 1;i<len;i++)
  17.         {
  18.             if(a[i] <a[i-1])
  19.             {
  20.                 int t = a[i],j;
  21.                 a[i] = a[i-1];
  22.                 for(j = i-2;j>=0 && a[j] > t;j–)
  23.                 {
  24.                     a[j+1] = a[j];
  25.                     swap(a, j+1, j);
  26.                 }
  27.                 a[j+1] = t;
  28.             }
  30.         }
  33.     }
  34.     private static void swap(int a[],int x,int y)//改变数值
  35.     {
  36.         a[x] = a[y];
  37.     }
  38. }
  39. public class Main
  40. {
  41.     public static void main (String[] args)
  42.     {
  43.         int a[] = new int[10];
  44.         Scanner cin = new Scanner(System.in);
  45.         System.out.println(“输入10个数，实现插入排序:”);
  46.         for(int i = 0;i<10;i++)
  47.         {
  48.             a[i] = cin.nextInt();
  49.         }
  50.         jo haha = new jo();//定义对象
  51.         haha.set(a);//存放数据
  52.         System.out.println(“排序结果如下：”);
  53.         show(a);//显示结果
  54.         cin.close();
  55.     }
  56.      static void show(int a[])
  57.     {
  58.         for(int i = 0;i < 10 ; i++)
  59.         {
  60.             System.out.print(a[i]+” “);
  61.         }
  62.     }
  64. }