java中使用二进制进行权限控制

 

基本概念

[java] view plaincopyprint?
  1. package test; 
  2.  
  3. publicclass Rights { 
  4.  
  5.     publicstaticvoid main(String[] args) { 
  6.         int a=1; // 001 状态a 
  7.         int b=2; // 010 状态b 
  8.         int c=4; // 100 状态c 
  9.          
  10.         int ab = a | b; // 001 | 010 = 011 初始状态 
  11.          
  12.         System.out.println(ab | c); // 011 | 100 = 111 添加c的状态 
  13.         System.out.println(ab & (~b)); // 011 & (~010) = 011 & 101 = 001 去除b的状态 
  14.          
  15.         System.out.println((ab & b) == b); // 011 & 010 = 010 判断是否有b的权限：(ab & b)==b 
  16.         System.out.println((ab & c) == c); // 011 & 100 = 000  
  17.     } 
  18. }  
package test;

public class Rights {

	public static void main(String[] args) {
		int a=1; // 001 状态a
		int b=2; // 010 状态b
		int c=4; // 100 状态c
		
		int ab = a | b; // 001 | 010 = 011 初始状态
		
		System.out.println(ab | c); // 011 | 100 = 111 添加c的状态
		System.out.println(ab & (~b)); // 011 & (~010) = 011 & 101 = 001 去除b的状态
		
		System.out.println((ab & b) == b); // 011 & 010 = 010 判断是否有b的权限：(ab & b)==b
		System.out.println((ab & c) == c); // 011 & 100 = 000 
	}
}

 

使用二进制进行权限或状态控制

 

[java] view plaincopyprint?
  1. package test; 
  2.  
  3. publicclass Test { 
  4.  
  5.     /**
  6.      * @param args
  7.      */ 
  8.     publicstaticvoid main(String[] args) { 
  9.  
  10.         /**
  11.          * 四种权限 ，当前定义为int，以下二进制表示只取后四位作说明
  12.          */ 
  13.  
  14.         // 添加 
  15.         int c = 1;// ...0001=2^0 
  16.         // 查询 
  17.         int r = 2;// ...0010=2^1 
  18.         // 修改 
  19.         int u = 4;// ...0100=2^3 
  20.         // 删除 
  21.         int d = 8;// ...1000=2^4 
  22.  
  23.         /**
  24.          *
  25.          * 大家可以观察四种权限的二进制表示的规律 ，都是2的N次方，
  26.          * 就表示本身，添加权限有最后一位为其它为0,查询倒数第二位为1其它都为0，修改倒数第三个为1其它都为0，删除倒数第四个为1其它都为0
  27.          *
  28.          */ 
  29.  
  30.         /**
  31.          * 这样表示有哪种权限时可以用 |(按位或) 操作
  32.          *
  33.          */ 
  34.  
  35.         // 用户A有添加和修改权限 
  36.         int usera = c | r | u; 
  37.  
  38.         // 用户B有添加和删除权限 
  39.         int userb = c | d; 
  40.  
  41.         /**
  42.          * 判断用户是否有某种权限用用户权限和要判断的权限进行 &(按位与) 操作，结果为要判断的权限值时表示用户有此权限，否则没有此权限
  43.          */ 
  44.         System.out.println(); 
  45.         if ((usera & u) == u) { 
  46.             System.out.println("用户a有更新权限"); 
  47.         } else { 
  48.             System.out.println("用户a没有有更新权限"); 
  49.         } 
  50.  
  51.         /**
  52.          * 给用户添加权限用用户权限和要添加的权限|(按位或) 操作再覆盖之前权限值
  53.          */ 
  54.         System.out.println(); 
  55.         if ((userb & u) == u) { 
  56.             System.out.println("用户b有更新权限"); 
  57.         } else { 
  58.             System.out.println("用户b没有更新权限"); 
  59.         } 
  60.  
  61.         System.out.println("==>给用户b添加更新权限"); 
  62.         userb = userb | u; 
  63.  
  64.         if ((userb & u) == u) { 
  65.             System.out.println("用户b有更新权限"); 
  66.         } else { 
  67.             System.out.println("用户b没有更新权限"); 
  68.         } 
  69.  
  70.         /**
  71.          * 取消用户某种权限,用用户权限和要取消的权限按位取反后进行按位 操作，再覆盖之前权限值
  72.          */ 
  73.         System.out.println(); 
  74.         if ((usera & r) == r) { 
  75.             System.out.println("用户a有查询权限"); 
  76.         } else { 
  77.             System.out.println("用户a没有查询权限"); 
  78.         } 
  79.  
  80.         System.out.println("==>取消用户a的查询权限"); 
  81.         usera = usera & (~r); 
  82.  
  83.         if ((usera & r) == r) { 
  84.             System.out.println("用户a有查询权限"); 
  85.         } else { 
  86.             System.out.println("用户a没有查询权限"); 
  87.         } 
  88.     } 
  89.  
  90. }  
package test;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		/**
		 * 四种权限 ，当前定义为int，以下二进制表示只取后四位作说明
		 */

		// 添加
		int c = 1;// ...0001=2^0
		// 查询
		int r = 2;// ...0010=2^1
		// 修改
		int u = 4;// ...0100=2^3
		// 删除
		int d = 8;// ...1000=2^4

		/**
		 * 
		 * 大家可以观察四种权限的二进制表示的规律 ，都是2的N次方，
		 * 就表示本身，添加权限有最后一位为其它为0,查询倒数第二位为1其它都为0，修改倒数第三个为1其它都为0，删除倒数第四个为1其它都为0
		 * 
		 */

		/**
		 * 这样表示有哪种权限时可以用 |(按位或) 操作
		 * 
		 */

		// 用户A有添加和修改权限
		int usera = c | r | u;

		// 用户B有添加和删除权限
		int userb = c | d;

		/**
		 * 判断用户是否有某种权限用用户权限和要判断的权限进行 &(按位与) 操作，结果为要判断的权限值时表示用户有此权限，否则没有此权限
		 */
		System.out.println();
		if ((usera & u) == u) {
			System.out.println("用户a有更新权限");
		} else {
			System.out.println("用户a没有有更新权限");
		}

		/**
		 * 给用户添加权限用用户权限和要添加的权限|(按位或) 操作再覆盖之前权限值
		 */
		System.out.println();
		if ((userb & u) == u) {
			System.out.println("用户b有更新权限");
		} else {
			System.out.println("用户b没有更新权限");
		}

		System.out.println("==>给用户b添加更新权限");
		userb = userb | u;

		if ((userb & u) == u) {
			System.out.println("用户b有更新权限");
		} else {
			System.out.println("用户b没有更新权限");
		}

		/**
		 * 取消用户某种权限,用用户权限和要取消的权限按位取反后进行按位 操作，再覆盖之前权限值
		 */
		System.out.println();
		if ((usera & r) == r) {
			System.out.println("用户a有查询权限");
		} else {
			System.out.println("用户a没有查询权限");
		}

		System.out.println("==>取消用户a的查询权限");
		usera = usera & (~r);

		if ((usera & r) == r) {
			System.out.println("用户a有查询权限");
		} else {
			System.out.println("用户a没有查询权限");
		}
	}

}

二进制和十进制之间的转换

 

 

[java] view plaincopyprint?
  1. package test; 
  2.  
  3. publicclass Trans { 
  4.  
  5.     publicstaticvoid main(String[] args) { 
  6.         int bit = 7; 
  7.         System.out.println(Integer.toBinaryString(bit)); // 十进制转二进制 
  8.  
  9.         Integer it = Integer.valueOf("111", 2); 
  10.         System.out.println(it);// 转换为10进制结果 
  11.     } 
  12. } 

posted on 2014-03-14 09:05  锟斤拷锟斤拷  阅读(1436)  评论(0)  编辑  收藏  举报

导航