java Byte类型 常量 java中byte变量的取值范围

一、java变量类型

1、byte

1)byte 数据类型是8位、有符号的，以二进制补码表示的整数；

2)最大值2^7-1 = 127  最小值-2^7 = 128  默认值是0

3)byte占用空间只有int的四分之一，所以能用byte尽量用byte

例子：byte a = 10，byte b = -5。

2、short

1)short数据类型是16位、有符号的，以二进制补码表示的整数；

2)最大值2^15-1 = 32767最小值-2^15 = -32768 默认值是0

3)short占用空间只有int的二分之一

例子：short a = 1000，short b = -20000。

3、int

1)int 数据类型是32位、有符号的以二进制补码表示的整数；

2)最大值2^31-1 = 2,147,483,647最小值-2^31 = -2,147,483,648默认值是0

3)一般地整型变量默认为 int 类型 默认值0

例子：int a = 200000，int b = -200000。

4、long

1)long数据类型是64位、有符号的以二进制补码表示的整数；

2)最大值2^63-1 = 9,223,372,036,854,775,807最小值-2^63 = -9,223,372,036,854,775,808默认值是0

3)这种类型主要使用在需要比较大整数的系统上 默认值0L

例子：long a = 200000L，long b = -200000L。

5、float

1)float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；

2)float 在储存大型浮点数组的时候可节省内存空间

3) 默认值0.0f

例子：float a = 2.3f。

6、double

1)float 数据类型是双精度、64位、符合IEEE 754标准的浮点数；

2)浮点数的默认类型为 double 类型

3) 默认值0.0d

例子：double a = 2.3432453332d。

7、boolean

1)boolean数据类型表示一位的信息

2)只有两个取值：true 和 false

3) 默认值false

例子：boolean a = true。

8、char

1)char 类型是一个单一的 16 位 Unicode 字符

2)最小值是 \u0000（十进制等效值为 0），最大值是 \uffff（即为 65535）；

3) char 数据类型可以储存任何字符；

例子：chara = 'A'。

9、实例

package com.zhouzy.base.t3;

public class VariableTest {
	public static void main(String[] args) {  
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  
  
        // short  
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  
  
        // int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
  
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
  
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
  
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
  
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE="  
                + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE="  
                + (int) Character.MAX_VALUE);  
    }  
}

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127

基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767

基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38

基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308

基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
 

10、转义符

 

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x0)
\s	空格 (0x20)
\t	制表符
\"	双引号
\'	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

12、自动和强制类型转换

 

 

package com.zhouzy.base.t3;

public class TypeTest {
	public static void main(String[] args) {
		byte a = 1;
		int b = a;
		byte c = (byte)b;
		System.out.println("a:"+a+",b:"+b+",c:"+c);
	}
}

 

 二、访问修饰符

访问控制

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	Y/N（说明）	N
default	Y	Y	Y	N	N
private	Y	N	N	N	N

三、非访问修饰符 

1、static 修饰符

静态变量，static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法，static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

package com.zhouzy.base.t3;

public class TypeTest {
	public static int a = 1;
	
	public static void main(String[] args) {
		getValue();
	}
	
	public static int getValue(){
		return a;
	}
}

2、final 修饰符

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值

public final int b = 2;

3、abstract 修饰符

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

package com.zhouzy.base.t3;

public abstract class AbstractTest {
	public abstract  void methodA();
	
	public void methodB(){
		System.out.println("我不是抽象方法");
	}
}

4、synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

public synchronized void test(){
		//同步方法，多个请求时只能被一个线程访问
	}

5、transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

6、volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

private volatile int a = 10;

四、运算符

1、算术运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
--	自减: 操作数的值减少1	B-- 或 --B 等于 19（区别详见下文）

实例

package com.zhouzy.base.t3;

public class OperatorTest {
	 public static void main(String[] args) {
		 //简单的加减乘除运算
	     int a = 10;
	     int b = 20;
	     int c = 25;
	     int d = 25;
	     System.out.println("a + b = " + (a + b) );
	     System.out.println("a - b = " + (a - b) );
	     System.out.println("a * b = " + (a * b) );
	     System.out.println("b / a = " + (b / a) );
	     System.out.println("b % a = " + (b % a) );
	     System.out.println("c % a = " + (c % a) );
	     System.out.println("a++   = " +  (a++) );
	     System.out.println("a--   = " +  (a--) );
	     // 查看  d++ 与 ++d 的不同
	     System.out.println("d++   = " +  (d++) );
	     System.out.println("++d   = " +  (++d) );
	  }
}

2、自增自减运算符

package com.zhouzy.base.t3;

public class OperatorTest {
	public static void main(String[] args){
        int a = 4;//定义一个变量；
        int b = ++a;//自增运算
        int c = 4;
        int d = --c;//自减运算
        System.out.println("进行自增运算后的值等于"+b);
        System.out.println("进行自减运算后的值等于"+d);
    }
}

 

解析:

int b = ++a; 拆分运算过程为: a=a+1=5; b=a=5, 最后结果为b=5 a=5 

int d = --c; 拆分运算过程为: c=c-1=3; d=c=3, 最后结果为d=3,c=3

后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 实例：

package com.zhouzy.base.t3;

public class OperatorTest {
	 public static void main(String[] args){
	        int a = 5;//定义一个变量；
	        int b = 5;
	        int x = 2*++a;
	        int y = 2*b++;
	        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
	        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
	    }
}

 

3、关系运算符 

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

实例

package com.zhouzy.base.t3;

public class OperatorTest {
	public static void main(String[] args) {
	     int a = 100;
	     int b = 200;
	     System.out.println("a == b = " + (a == b) );
	     System.out.println("a != b = " + (a != b) );
	     System.out.println("a > b = " + (a > b) );
	     System.out.println("a < b = " + (a < b) );
	     System.out.println("b >= a = " + (b >= a) );
	     System.out.println("b <= a = " + (b <= a) );
	  }
}

 

4、位运算符 

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

package com.zhouzy.base.t3;

public class OperatorTest {
	public static void main(String[] args) {
	     int a = 60; /* 60 = 0011 1100 */ 
	     int b = 13; /* 13 = 0000 1101 */
	     int c = 0;
	     c = a & b;       /* 12 = 0000 1100 */
	     System.out.println("a & b = " + c );
	 
	     c = a | b;       /* 61 = 0011 1101 */
	     System.out.println("a | b = " + c );
	 
	     c = a ^ b;       /* 49 = 0011 0001 */
	     System.out.println("a ^ b = " + c );
	 
	     c = ~a;          /*-61 = 1100 0011 */
	     System.out.println("~a = " + c );
	 
	     c = a << 2;     /* 240 = 1111 0000 */
	     System.out.println("a << 2 = " + c );
	 
	     c = a >> 2;     /* 15 = 1111 */
	     System.out.println("a >> 2  = " + c );
	  
	     c = a >>> 2;     /* 15 = 0000 1111 */
	     System.out.println("a >>> 2 = " + c );
	  }
}

 

5、逻辑运算符 

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
| |	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真

实例

public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }

 

6、短路逻辑运算符 

实例

package com.zhouzy.base.t3;

public class OperatorTest {
	public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}

 

7、赋值运算符 

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
| =	按位或赋值操作符	C | = 2等价于C = C | 2

实例

package com.zhouzy.base.t3;

public class OperatorTest {
	public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}

8、条件运算符（?:） 

实例

package com.zhouzy.base.t3;

public class OperatorTest {
	public static void main(String[] args) {
		 String a = null;
		 String b = "bbb";
		 
		 System.out.println(a == null ? "空字符串":a);
		 System.out.println(b == null ? "空字符串":b);
    }
}

9、Java运算符优先级 

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr--	从左到右
一元	++expr --expr + - ～ ！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>>  <<	左到右
关系	> >= < <=	左到右
相等	==  !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	|	左到右
逻辑与	&&	左到右
逻辑或	| |	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = | =	从右到左
逗号	，	左到右

10、instanceof 运算符 

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

实例

package com.zhouzy.base.t3;

import com.zhouzy.base.t2.Animal;
import com.zhouzy.base.t2.Cat;

public class OperatorTest {
	public static void main(String[] args) {
		Cat cat = new Cat();
		System.out.println(cat instanceof Animal);
    }
}

true