最全java语言基础详细讲解推荐小白自学必看 (一)

java语言基础

一、详讲第一个程序HelloWorld

1.详解代码

代码中的关键字:

关键字 含义 public 公共的 Hello 类名 void 无返回值 String 字符串类型 class 类(Java的文件是以类为组织单位) static 静态的 main 方法名 String[] 字符数组

代码细节:

1.public修饰的类名必须和文件一致

2.Java是一门大小写敏感是语言

3.括号、双引号、大括号都是成双成对的存在

4.方法里面的代码都是从上往下执行-顺序执行

5.方法中的代码又叫做执行语句,执行语句用分号结束

二、代码规范

1.书写格式

使用tab键让代码更有层次感,可读性增高

2.代码注释

注释 描述 //注释内容 单行注释 /* 注释内容 */ 多行注释 /** 注释内容 */ 文档注释

三、Path的作用

%JAVA_HOME%/bin --> javac.exe 和 java.exe 在path中配置了某个文件夹,代表在其他任何文件夹里都可以打开配置的文件夹中的文件

四、Java的跨平台特性

Java比较特殊,大致归类为解释型语言,该语言不属于传统的解释型语言也不属于传统的编译型语言,该语言将源代码通过编译器成编译成字节码文件(中间文件/class文件),字节码文件不能被系统直接执行,但是可以被安装在该平台上的Java虚拟机(VM)进行解释执行。换言之,Java源码被编译成字节码文件,该字节码文件被各大平台上的Java虚拟机解释执行,实现了跨平台特性,但是跨平台的前提是平台上必须安装相匹配的Java虚拟机,实现了伪跨平台性。

五、Java体系的划分

JavaSE - J2SE - 标准版本(引申出了企业版本和微型版本) JavaEE - J2EE - 企业版本(针对后端开发的技术) JavaME - J2ME - 微型版本(针对前端开发的技术-已过时,现在都用Android、鸿蒙)

六、Java的发展历史

雇主:sun(Stanford University Network)—2009年74亿美金卖给oracle公司 Java之父:詹姆斯·高斯林 (James Gosling) 版本变更 1995年5月23日,Java语言诞生; 1996年1月,第一个JDK-JDK1.0诞生; 1996年4月,10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术; 1996年9月,约8.3万个网页应用了JAVA技术来制作; 1997年2月18日,JDK1.1发布; 1997年4月2日,JavaOne会议召开,参与者逾一万人,创当时全球同类会议规模之纪录; 1997年9月,JavaDeveloperConnection社区成员超过十万; 1998年2月,JDK1.1被下载超过2,000,000次; 1998年12月8日,JAVA2企业平台J2EE发布; 1999年6月,SUN公司发布Java的三个版本:标准版、企业版和微型版; 2000年5月8日,JDK1.3发布; 2000年5月29日,JDK1.4发布; 2001年6月5日,NOKIA宣布,到2003年将出售1亿部支持Java的手机; 2001年9月24日,J2EE1.3发布; 2002年2月26日,J2SE1.4发布,自此Java的计算能力有了大幅提升; 2004年9月30日18:00PM,J2SE1.5发布,成为Java语言发展史上的又一里程碑。为了表示该版本 的重要性,J2SE1.5更名为Java SE 5.0; 2005年6月,JavaOne大会召开,SUN公司公开Java SE 6。此时,Java的各种版本已经更名,以取 消其中的数字“2”:J2EE更名为Java EE,J2SE更名为Java SE,J2ME更名为Java ME; 2006年12月,SUN公司发布JRE6.0; 2009年4月7日Google App Engine开始支持Java; 2010年11月,由于甲骨文对于Java社区的不友善,因此Apache扬言将退出JCP; 2011年7月28日,甲骨文发布Java 7.0的正式版; 2014年3月19日,甲骨文公司发布Java 8.0的正式版

七、标识符

**含义:**给类、方法、变量、接口取名字时使用到的字符序列
**组成部分:**英文大小写字母 or 数字 or $ or _ or 中文
命名规范:
  1. 不能以数字开头 区分大小写字母 不能使用除了$和_以外的特殊符号 不要使用中文(企业级的命名规范不允许使用中文) 不能使用Java的关键字
public class 标识符{
          
   
    public static void 标识符(String[] args){
          
   
        int 标识符 = 100;
    }
}

**例如:**创建一个类的名称

_aaa 合法

aaa_aaa 合法

4aaa 不合法

_4aaa 合法

八、Java关键字

含义:Java提供的具有特殊意义的单词

九、变量

**含义:**在程序执行过程中,可改变的量 注意: 中括号里的内容可写可不写,不违反变量的语法规则 2. =为赋值号,将赋值号右边的值赋值给左边的变量 3. 变量类似容器,但是变量只能存单个值(要想存多个值,可以考虑使用数组和集合) 4. 在同一作用域中,变量不能重复 5. 变量必须初始化后才能使用

语法

数据类型 变量名 = 值;
效果:创建一个指定名称的变量  并将指定的值放到这个变量里面去

十、基本数据类型

含义:一个程序中不同数据有不同的类型,我们在创建一个变量时,Java规定我们必须指定该变量只能存放哪种类型的数据。

数据类型 备注 byte 字节型。 -27~27-1 short 短整型。 -215~215-1 int 整型。 -231~231-1 long 长整型。 -263~263-1 float 单精度浮点型。 double 双精度浮点型。精度越高表示的小数位就越多 char 字符型。 单个的符号(文字、字母、标点符号、特殊符号、空格) boolean 布尔型。 值只能是true/false. true:表示成立 false:表示不成立 String 字符串型。可以存放单个或者多个字符 引用类型 存放对象的地址值

问题:既然都是整数为什么要分4中不同的类型?

答案:因为不同的数据类型占用的内存大小是不一样的,我们在实际开发中要选择适合大小的数据类型来创建变量,达到节省内存空间的效果。例如:我们要存放一个人的年龄,应该选择byte,最节省内存空间

示例:

public static void main(String[] args){
          
   
      /*
        创建变量    整型变量
        数据类型只能写java定义好的类型
        变量名要满足标识符的要求
         */
        byte b = 127;
        //byte b2 = 128;  会报错:因为128超出了byte的取值范围
        short s = 129;
        int i = 666;
        /*
        在给变量存值的时候,java会先处理这个值  如果是整数,则会将该值处理为int型
        而这个值超过了int的取值范围,所以被报错
        解决:告诉java不要把我处理为默认的int型,我是long类型
        方式:在值的后面跟上一个大写或者小写的L,建议大写
         */
        long l = 234324326677L;

        //浮点型
        /*
        float类型的值要跟上一个f或者F,否则java会将所有的小数都默认处理为double型
         */
        float f = 3.14f;
        double d = 3.14159;

        //字符型
        /*
        字符型的值,必须使用单引号修饰
         */
        char c = 5;

        //布尔型
        boolean b1 = true;
        boolean b2 = false;

        //字符串型
        /*
        字符串类型的值必须使用双引号修饰
         */
        String str = "5";

        /*
        如果我们使用一个变量名,则java会自动的将该变量中存的值取出来使用
         */
        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);

        System.out.println(f);
        System.out.println(d);

        System.out.println(c);

        System.out.println(b1);
        System.out.println(b2);

        System.out.println(str);
}

十一、计算处理整数机制

整数的运算问题

计算 3 + 2:5

计算 3 - 2:计算机不会做减法,只会做加法

所以其实就是 3 + (-2) = -5(肯定是错的)

计算机存放一个数字,都是存的该数字的补码形式

原码 反码 补码

**正数:**正数的原码、反码、补码都是一样的,三码合一。

负数:负数的原码、反码、补码都不一致,所以我们只需要重点讨论负数的反码与补码

**负数的原码:**二进制数本身

举例说明:

2 的原码: 00000010

-2的原码:10000010

负数的反码:将整个二进制数的符号位不变,其他为的属性0变1,1变0

2的反码:00000010

-2的反码:11111101

负数的补码:将反码+1

2的补码:00000010

-2的补码:11111110

那么计算机在计算3+(-2)时,是使用

00000011 与 11111110在进行计算

整数的进制

平时生活中大多是使用的十进制1-10,Java使用的整数肯定是默认为十进制,但可以在声明整数型变量时指定进制。

    二进制:使用0b开头,后面使用0和1,满2进1。 八进制:使用0开头,后面使用0-7,满8进1。 十进制:跟平时使用一样正常使用,满10进1。 十六进制:使用0x开始,使用1-9,10用a表示、11用b表示、12用c表示、13用d表示、14用e表示、15用f表示,满16进1。

示例:

public class IntDemo {
          
   
    public static void main(String[] args) {
          
   
        int i = 0b101;//声明二进制
        System.out.println(i);

        int i2 = 0123;//声明八进制
        System.out.println(i2);

        int i3 = 12321321;//声明十进制
        System.out.println(i3);

        int i4 = 0xabc;  //声明十六进制  12+11*16+10*16^2
        System.out.println(i4);
    }
}

十二、进制转化

十进制转二进制

十进制数除2取余法,即十进制数除2,余数为权位上的数,得到的商值继续除2,依此步骤继续向下运算直到商为0为止。

二进制转十进制

把二进制数按权展开、相加即得十进制数。

二进制转八进制

3位二进制数按权展开相加得到1位八进制数。(注意事项,3位二进制转成八进制是从右到左开始转换,不足时补0)。

二进制转十六进制

方法为:与二进制转八进制方法近似,八进制是取三合一,十六进制是取四合一。(注意事项,4位二进制转成十六进制是从右到左开始转换,不足时补0)

十三、类型转换

**类型转换:**将a类型的数据赋值给b类型的变量

口公式:

    小转大,自动转(隐式转) 大转小,强制转(显示转)

大小的标准:

浮点型大于整型

都是整型时,占用内存空间越大的类型越大

都是浮点型时,占用内存空间越大的类型越大

数值类型的取值范围:byte<short<int<long<float<double

注意:

1.如果字面量是某一个具体的整数,一定得记住它是int类型的字面量,从这个int类型的字面量开始去想结果。

2.大转小的过程中可能会出现数据丢失的问题

扩展

数字字面量:代码中的数字 数字为整数默认类型为:int 数字为小数默认类型为:double

强制转换示例:

public class ConvertDemo {
          
   
    public static void main(String[] args) {
          
   
        //将byte类型转换为int类型:典型的小转大
        byte b2 = 5;
        int a2 = b2;

        //将int类型转换为byte类型:典型的大转小
        int a = 5;
        //byte b = a;//会出错  因为需要强制转换
        byte b = (byte)a;//这就是强制转换

        System.out.println(a2);//5
        System.out.println(b);//5

        //整型转浮点型
        int a3 = 5;
        float f = a3;
        //整型转换为浮点型,自动添加一个.0
        System.out.println(f);

        //浮点型转整型
        double d = 3.14;
        int a4 = (int)d;
        //浮点型转换为整型,会将小数位直接砍掉
        System.out.println(a4);
    }
}

整型与字符类型的转换

public class ConvertDemo2 {
          
   
    public static void main(String[] args) {
          
   
        //将char转换为int  可以自动转换
        char c1 = a;
        int i1 = c1;

        //将int转换为char  使用强制转换
        int i2 = 98;
        char c2 = (char)i2;

        /*
        char与int明明不是同一个类型为什么可以类型转换
        因为char类型底层就是一个short
        也就是说字符型其实就是一个整型
        当我们要存放一个字符时,其实计算机存的是一个数字

        那么每一个字符到底应该存哪一个数字,应该有对应关系
        这个对应关系是由字符集来指定的
        这个字符集是由认为设计的,不同的字符集中对应关系也有可能不一样
         */
    }
}

数学运算中的类型转换

public class ConvertDemo3 {
          
   
    public static void main(String[] args) {
          
   
        /*
        以下两行代码是典型的将int类型的值赋值给byte/short类型
        不需要强制转,是因为java帮我们进行了优化
        不是强制转的语法失效了

        优化的条件:直接将值赋值给变量
         */
        byte b = 5;
        short s = 6;

        /*
        byte b1 = 5;
        byte b2 = 6;
        byte b3 = b1 + b2;
         */
        byte b1 = 5;
        byte b2 = 6;
        /*
        右边的结果是11,java会默认的处理为int类型  不会帮我们优化
        所以会报错,因为需要强制转换
         */
        byte b3 = (byte)(b1 + b2);
        System.out.println(b3);

    }
}

十四、运算符

    常见的数学运算符
+ - * / % ......

+加号

    **+作用:**加法运算、拼接字符串 **规律:**将多个字符串的值 拼接成一个字符串,+的左边或者右边,只要有一边是字符串,则一定做拼接字符串处理
public class Demo1 {
          
   
    public static void main(String[] args) {
          
   
        System.out.println(1+1);

        /*
        拼接字符串
        1.将多个字符串的值 拼接成一个字符串
        2.字符串与其他类型的值也可以拼接成一个字符串
        规律:+的左边或者右边,只要有一边是字符串,则一定做拼接字符串处理
         */
        String s1 = "Hello ";
        String s2 = "Wrold ";
        System.out.println(s1 + s2);

        System.out.println("hello" + 3.14);

        System.out.println(5 + 6 + "," + 6 + 5);//11,65
    }
}

%取余

public class Demo2 {
          
   
    public static void main(String[] args) {
          
   
        System.out.println(10%3);//1
        System.out.println(3%10);//3
        System.out.println(-4%10);//-4
        System.out.println(-10%4);//-2
    }
}

**取余练习:**声明整型变量,并赋值为5位数,取出该数的每一位的值

public class Demo3 {
          
   
    public static void main(String[] args) {
          
   
        int i = 56757;

        int ge = i % 10;//取出个位数
        int shi = i / 10 % 10;// 取出十位数
        int bai = i / 100 % 10;// 取出百位数
        int qian = i / 1000 % 10;// 取出千位数
        int wan = i / 10000;// 取出万位数
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
        System.out.println(qian);
        System.out.println(wan);

    }
}

数学运算中的结果值的类型

public class Demo {
          
   
    public static void main(String[] args) {
          
   
        //在数学运算中,结果值的数据类型与运算中的最大类型一致
        
        /*
        结果值应该是int类型  真实结果是2.5  但是结果要处理为int
        相当于将2.5转换为int类型   就是将小数位直接砍掉
         */
        System.out.println(5/2);//2
        //结果值应该是double类型   
        System.out.println(5/2.0);//2.5
        /*
        结果值是double类型  真实结果为15  会被转换为double类型
        转换的方式就是添加.0
         */
        
        System.out.println(3.0 * 5);//15.0
    }
}

++与–

++:自增符号

–:自减符号

注意:在使用自增或自减符号时,变量一定要有值

++符号的基本效果:

整型变量++;   或者    ++整型变量;
效果:将该变量的本身的值+1

–符号的基本效果:

整型变量--;   或者    --整型变量;
效果:将该变量的本身的值-1
/*
a++:先赋值,再自增
++a:先自增,再赋值
赋值:将变量的值赋值给表达式
自增:将变量本身的值+1
 */
public class Demo5 {
          
   
    public static void main(String[] args) {
          
   
        int i = 5;
        int j = 5;

        /*
        为什么i++的值为5
        因为i++的效果是
        1.将i的值赋值给 i++,所以i++的值就是i的值5
        2.将i的值+1     i的值变为6
         */
        System.out.println(i++);//5
        System.out.println(i);//6

        /*
        为什么++j的值为6
        因为++j的效果是
        1.将j的值+1   变为6
        2.将j的值赋值给++j   所以++j的值为6
         */
        System.out.println(++j);//6
        System.out.println(j);//6

        int a = 5;
        System.out.println(a++ + ++a);//12

        int k = 6;//7  6
        int v = 7;//6 7
        System.out.println(k++ - --v + k-- - ++v);//0
        //                 6     6      7     7

    }
}

深入算数运算符

public class Test02{
          
   
	
	public static void main(String[] args){
          
   
		/**
			知识点:深入算数运算符
			
			+、-、*、/、%、++、--
			
			案例一:byte类型做运算,会向上转型成int
			byte b1 = 10;
			byte b2 = 20;
			//10 - byte - 8位:0000,1010
			//10 - int  -32位:0000,0000,0000,0000,0000,0000,0000,1010
			//20 - byte - 8位:0001,0100
			//20 - int  -32位:0000,0000,0000,0000,0000,0000,0001,0100
			//30 - int  -32位:0000,0000,0000,0000,0000,0000,0001,1110
			//30 - byte - 8位:0001,1110
			byte result = (byte)(b1+b2);
			System.out.println(result);
			
			案例二:short类型做运算,会向上转型成int
			short s1 = 10;
			short s2 = 20;
			short result = (short)(s1+s2);
			System.out.println(result);
			
			案例三:描述下列计算结果的类型
			byte b = 10;
			short s = 10;
			int i = 10;
			long l = 10;
			float f = 1.1F;
			double d = 2.2;
			System.out.println(b+s);//int类型
			System.out.println(i+s);//int类型
			System.out.println(l+s);//long类型
			System.out.println(i+l);//long类型
			System.out.println(i+f);//float类型
			System.out.println(i+d);//double类型
			
			案例四:浮点类型不能直接做运算,要做运算会使用BigDecimal
			double d1 = 0.5;
			double d2 = 0.4;
			System.out.println(d1-d2);//0.09999999999999998
			
			案例5:a的ASCII是97
			char c = a;
			System.out.println(c+1);//98
		
			经典面试题一:输出结果为?
			int a = 8;
			int b = (a++)+(++a)+(a*10);
			System.out.println(b);//118
			//a = 10
			//b = 8 + 10 + 10
			
			经典面试题二:输出结果为?
			int i =  0;   
			i = ++i; 
			//底层原理:
			//i = (int)(i+1);
			//i = i;
			System.out.println(i);//1
			
			int i = 0;   
			i = i++;  
			//底层原理:
			//int temp = i;--temp用于记录i最初的值
			//i = (int)(i+1);
			//i = temp
			System.out.println(i);//0 
			
			扩展1:
			byte b = 10;
			++b;//底层:b = (byte)(b+1);
			short s = 10;
			++s;//底层:s = (short)(s+1);
			int i = 10;
			++i;//底层:i = (int)(i+1);
			long l = 10;
			l++;//底层:l = (long)(l+1);
			
			扩展2:
			int i = 10;
			//++i; 和 i++; 没有区别,因为分号是一条执行语句的结束,不管先加还是后加都给我加
			//++i;
			//i++;
			System.out.println(i);
		*/	
	}
}

复合运算符

a += 值;     效果:  a = a + 值
a -= 值;     效果:  a = a - 值
a *= 值;     效果:  a = a * 值
....

基本使用

public class Demo6 {
          
   
    public static void main(String[] args) {
          
   
        int i = 5;
        i += 5;//效果是  i = i + 5
        System.out.println(i);//10
        i -= 6;//效果是  i = i - 6
        System.out.println(i);//4
    }
}

深入符合运算

public class Test03{
          
   
	
	public static void main(String[] args){
          
   
		/**
			知识点:赋值运算符
			
			=、+=、-=、*=、/=、%=
			
			int i = 10;
		
			i += 10;//i = (int)(i+10);
			i -= 10;//i = (int)(i-10);
			i *= 5 ;//i = (int)(i*5);
			i /= 5 ;//i = (int)(i/5);
			i %= 3 ;//i = (int)(i%3);
			System.out.println(i);//1
			
			经典面试题一:输出结果为?
				//一次性声明多个变量
				int a,b; 
				a = b = 100;//把100赋值给b,b再赋值给a
				System.out.println(a);//100
				System.out.println(b);//100
				
			经典面试题二:下面的两种写法结果分别是?
				short s=1; 
				s = s+1;//报错:short类型的变量s 与 int类型的数字字面量1 做运算的结果是int类型 

				short s=1; 
				s += 1;//s = (short)(s+1);
				
		
		*/		
	}
}

自动进行类型转换

复合运算符的好处:

    代码更简洁 如果需要类型转换,则复合运算符会自动的进行转换
public class Demo7 {
          
   
    public static void main(String[] args) {
          
   
        byte b = 5;
        // b = b + 3;//会出错  因为右边的结果值是int类型所以需要强转
        b = (byte)(b + 3);
        System.out.println(b);


        byte b2 = 5;
        //b2 += 3 效果: b2 = b2 + 3.  但是我们并没有进行强转,因为复合运算符会自动的帮我们转换
        b2 += 3;
        System.out.println(b2);
    }
}

深入符合运算

public static void main(String[] args){
          
   
	/**
		知识点:赋值运算符
		
		=、+=、-=、*=、/=、%=
		
		int i = 10;
	
		i += 10;//i = (int)(i+10);
		i -= 10;//i = (int)(i-10);
		i *= 5 ;//i = (int)(i*5);
		i /= 5 ;//i = (int)(i/5);
		i %= 3 ;//i = (int)(i%3);
		System.out.println(i);//1
		
		经典面试题一:输出结果为?
			//一次性声明多个变量
			int a,b; 
			a = b = 100;//把100赋值给b,b再赋值给a
			System.out.println(a);//100
			System.out.println(b);//100
			
		经典面试题二:下面的两种写法结果分别是?
			short s=1; 
			s = s+1;//报错:short类型的变量s 与 int类型的数字字面量1 做运算的结果是int类型 

			short s=1; 
			s += 1;//s = (short)(s+1);
			*/
}

赋值符号=

变量 = 值;

效果:java一定是先获取都右边的值,再将值赋值给左边的变量
    
int a = 5;
a = a++;
System.out.println(a);//5
    练习:声明两个同类型的变量,交换这两个变量的值
public class Practise2 {
          
   
    public static void main(String[] args) {
          
   
        /*
        声明两个同类型的变量,交换这两个变量的值
         */
        int a = 5;
        int b = 6;
        /*
        这个写法不能达到交换的效果
        因为a = b 执行时,a变量的值因为被覆盖所以丢失
         */
//        a = b;
//        b = a;
//        System.out.println(a);
//        System.out.println(b);

        /*
        如果要替换两个变量的值
        一定要避免某个变量的值丢失
        解决:在某个变量的值被覆盖之前   全复制一份作为备份
         */
        int c = a;
        a = b;
        b = c;
        System.out.println(a);
        System.out.println(b);

        /*
        要求不创建第三个变量达到替换的效果
        实际开发中,不建议使用这个写法
        因为可读性太差了
        但是考试可能会遇到,所以要会写
         */
        int i = 5;
        int j = 6;

        i = i + j;
        j = i - j;
        i = i - j;
        System.out.println(i);
        System.out.println(j);
    }
}

比较运算符

== :比较左边与右边的值是否相等,如果相等结果true. 否则返回false
!= :比较左边与右边的值是否不相等,如果不相等返回true.否则返回false
> >= < <=.....
public class Demo8 {
          
   
    public static void main(String[] args) {
          
   
        int a = 5;
        int b = 6;
        System.out.println(a==b);//false
        System.out.println(a!=b);//true

        System.out.println(a >= 5);
        /*
        =与==的区别:
        =是赋值符号,效果是将右边的值赋值给左边的变量
        ==是比较符号,效果是判断两边的值是否相等
         */
    }
}

注意: =与==的区别: =是赋值符号,效果是将右边的值赋值给左边的变量 ==是比较符号,效果是判断两边的值是否相等

逻辑运算符

& :并且    
	效果:连接两个条件,如果两个条件都成立,则整体成立
| : 或者
	效果:连接两个条件,如果两个条件都不成立,则整体不成立
! : 取反  
	效果:本身的值是true,使用了取反符号就变成false

&& : 双与  也表示并且,但是带短路效果
|| : 双或  也表示或者,但是带短路效果

&与&&

public class Demo10 {
          
   
    public static void main(String[] args) {
          
   
        int i = 5;
        /*
        & 不带短路效果  所以任何情况下都会将两个条件都判断一次
        这样是不合理的,因为如果第一个条件不成立了,则第二个条件就不需要判断了
        在不影响整体结果值的情况下,不判断第二个条件,我们将这种情况称之为短路效果
         */
        System.out.println(i > 5 & i++ < 6);//false
        System.out.println(i);//6

        int j = 5;
        /*
        使用&&符号  带短路效果
        意思就是:在判断了第一个条件,如果就能决定整体的结果,则不会判断第二个条件
        当前这个代码,第一个条件为false,就已经决定了整体的结果肯定为false
        所以就触发了短路效果,不会判断第二个条件也就不会执行j++
        所以j的值还是5
         */
        System.out.println(j > 5 && j++ < 6);//false
        System.out.println(j);//5
    }
}

|与||

public class Demo11 {
          
   
    public static void main(String[] args) {
          
   
        int i = 5;
        /*
        | 不带短路效果  所以会将两个表达式都判断一次
         */
        System.out.println(i >= 5 | i++ <= 9);//true
        System.out.println(i);//6

        int j = 5;
        /*
        || 带短路效果
        第一个条件已经能决定整体的结果了,就不会判断第二个条件了
         */
        System.out.println(j >= 5 || j++ <= 9);//true
        System.out.println(j);//5

位运算符(了解)

&   :如果连接的是boolean表达式,则充当逻辑运算符
     如果连接的是整数,则充当位运算符
     将两个数字的二进制形式,每一位都进行运算,如果两个数字都是1,则结果为1
     否则结果为0
|   :如果连接的是boolean表达式,则充当逻辑运算符
     如果连接的是整数,则充当位运算符
     将两个数字的二进制形式,每一位都进行运算,如果两个数字有一个是1,则结果为1
     否则结果为0

^   : 将两个数字的二进制形式,每一位都进行运算,如果两个数字不相等,则结果为1
	  否则结果为0
     
>>  :右移
	 将指定整型的二进制数向右边移动指定的位数。
	 右边移动的数字就丢失,左边会空出位置出来,如果符号位是1则左边填1,如果符号位是0,则左边填0
<<  :
	 左移
	 将指定整型的二进制数向做边移动指定的位数。
	 左边移动的数字就丢失,右边会空出位置出来,空出的位置填0
>>> :无符号右移
	将指定整型的二进制数向右边移动指定的位数。
	 右边移动的数字就丢失,左边会空出位置出来,空出的位置填0
public class Demo12 {
          
   
    public static void main(String[] args) {
          
   
        int i = 15;
        int j = 2;
        /*
        00000000 00000000 00000000 00001111
        00000000 00000000 00000000 00000010
        -------------------------------------
        00000000 00000000 00000000 00000010
         */
        System.out.println(i & j);//2

        /*
        00000000 00000000 00000000 00001111
        00000000 00000000 00000000 00000010
        -------------------------------------
        00000000 00000000 00000000 00001111
         */
        System.out.println(i | j);//15

         /*
        00000000 00000000 00000000 00001111
        00000000 00000000 00000000 00000010
        -------------------------------------
        00000000 00000000 00000000 00001101
         */
        System.out.println(i ^ j);//13

    }
}
/*计算结果:
-12 >> 3
-12 >>> 3
*/
public class Practise3 {
          
   
    public static void main(String[] args) {
          
   
        byte b = -12;
        /*
        -12的原码:10001100
        -12的反码:11110011
        -12的补码: 11110100
        右移3位:11111110
        结果的反码:11111101
        结果的原码:10000010    十进制:-2
         */
        System.out.println(b >> 3);

         /*
        -12的原码:10000000 00000000 00000000 00001100
        -12的反码:11111111 11111111 11111111 11110011
        -12的补码: 11111111 11111111 11111111 11110100
        无符号右移3位:00011111 11111111 11111111 11111110
         */
        System.out.println(b >>> 3);
        System.out.println(0b00011111111111111111111111111110);
    }
}

三目运算符

boolean表达式?java代码1:java代码2

特点:如果boolean表达式的值为true,则执行java代码1,否则执行java代码2
public class Practise5 {
          
   
    public static void main(String[] args) {
          
   
        /*
        定义三个整型变量并赋值
        使用三目运算符,打印更大的那一个值
         */
        int a = 25;
        int b = 12;
        int c = 9;
        System.out.println(a>b?(a>c?a:c):(b>c?b:c));
    }
}
/*
>> 3
-12 >>> 3
*/
public class Practise3 {
          
   
    public static void main(String[] args) {
          
   
        byte b = -12;
        /*
        -12的原码:10001100
        -12的反码:11110011
        -12的补码: 11110100
        右移3位:11111110
        结果的反码:11111101
        结果的原码:10000010    十进制:-2
         */
        System.out.println(b >> 3);

         /*
        -12的原码:10000000 00000000 00000000 00001100
        -12的反码:11111111 11111111 11111111 11110011
        -12的补码: 11111111 11111111 11111111 11110100
        无符号右移3位:00011111 11111111 11111111 11111110
         */
        System.out.println(b >>> 3);
        System.out.println(0b00011111111111111111111111111110);
    }
}
经验分享 程序员 微信小程序 职场和发展