1. Java基础知识图解
2.Java技术体系平台
1995年Sun公司推出的高级编程语言;2010年被Oracle公司收购。
Java SE(Java Standard Edition)标准版:面向桌面级应用的Java平台,提供完整的Java核心API,此版被称为J2SE;
Java EE(Java Enterprise Edition)企业版:为开发企业环境下的应用程序提供一套解决方案。技术体系包含:Servlet、Jsp等,主要针对Web应用程序开发,称J2EE;
Java ME(Java Micro Edition)小型版:支持Java程序运行在移动终端(手机、PDA)上的平台,对Java API有所精简,加入针对移动端的支持,此版本以前成为J2ME;
Java Card:支持一些Java小程序Applets运行在小内存设备如智能卡上的平台。
3.Java概述和特点
3.1.概述
Java从C和C++继承了许多成份,是类C发展和衍生的产物。Java变量声明、操作符、参数传递和流程控制等与C和C++语言完全相同。Java是一个纯粹的面向对象的程序设计语言,继承了C++面向对象技术的核心,舍弃C中易引起错误的指针(以引用取代)、运算符重载(operator overloading)、多重继承(以接口取代)等特性,增加垃圾回收器功能,用于回收不再被引用的对象所占据的内存空间。JDK1.5又引入了泛型编程(Generic Programming)、类型安全的枚举、不定长参数和自动装/拆箱。
3.2.特点
面向对象oop:基本概念(类和对象);三大特性(封装、继承和多态);支持单继承、接口多实现补充了单继承。
健壮性:吸收C/C++的优点,去掉影响程序健壮性的部分,如指针、内存的申请与释放等。提供一个相对安全的内存管理和访问机制;Java是强类型语言,增加异常处理机制和垃圾回收机制。
跨平台性:Java应用程序可在不同系统上运行。原理:只需安装一个Java虚拟机 (JVM Java Virtual Machine) 即可,因Java程序在操作系统中运行由JVM负责。
简单性:抛弃c++的指针和多继承,加入垃圾回收机制、多线程;高性能、安全的。
解释型语言,还有javaScript、PHP;像c、c++是编译性语言
Java虚拟机机制屏蔽底层运行平台的差别,实现了“一次编译,到处运行”,java文件被编译成class字节码文件,.class文件可在不同Java虚拟机(JVM)上执行。
4.Java环境和安装
4.1.JDK、JRE和JVM
JDK:提供给开发人员使用,包含java的开发工具和JRE。
JRE:由Java虚拟机(JVM)和Java核心类库等组成。运行Java程序,只需安装JRE即可。
JDK = JRE + 开发工具集(Javac编辑工具等)
JRE = JVM + Java SE标准类库
4.2.环境安装和配置
第一步:我的电脑——属性——高级系统设置——环境变量,新建JAVA_HOME变量 ,值为jdk的安装目录,例如:D:\software\Java8\jdk1.8.0_131。
第二步:系统变量——新建CLASSPATH 变量变量值填写.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar(注意最前面有一点)
CLASSPATH环境变量是用于设置Java编译器和运行时系统(JVM)在查找类文件时的搜索路径。当编译或运行时,编译器和JVM需要找到所需的类文件,以便正确加载和执行程序。
第二步:编辑path环境变量,新增%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;(如果Path的变量值末尾有没有分号,先输入英文分号再输入上面的代码)
5.转义符、注释和路径
5.1.转义符
在控制台,输入tab键,可以实现命令补全。转义字符:\t(制表符)、\n(换行符)、\\(\)、\"(")、\'(')、\r(回车)。
5.2.注释
类型 | 格式 | 说明 |
单行注释 | // 注释文字 | 单行和多行注释,被注释的文字,不会被JVM解释执行,不参与程序编译和运行;多行注释里不允许多行注释嵌套;文档注释的内容可被JDK提供的工具 javadoc 所解析,生成一套以网页文件形式体现的该程序的说明文档,操作方式:javadoc -d mydoc -author -verdion 源文件名称.java |
多行注释 | /* 注释文字 */ | |
文档注释 (java特有) | /** @author 指定java程序的作者 @version 指定源文件的版本 */ |
package com.shangguigu.test;
/**
* 文档注释(java特有)
* @author ccg
* @version v1.0
*/
// 文档注释生成,在一个方法上面或类上面:/**回⻋
public class Hello {//这个表示一个类,类的名称是Hello
// 程序执行的入口
public static void main(String[] args) {
// 执行体--要完成的功能
// println换行;print不换行
System.out.println("第一个\n程序");//syso ALT+/:提示
// \t空格符;\n换行符
System.out.print("非常好\t好好");
// java的单行注释 ctrl+/
/*
* 多行注释
* 选中要注释的多行代码ctrl+shift+/
* 删去某行 ctrl+d
* 复制一行: ctrl + alt + ↓
* 返回ctrl+z
*/
}
5.3.路径
6. 程序
6.1.helloWorld程序
编写:将编java源文件; 编译:使用javac命令编译java源文件,格式:javac 源文件名.java;运行:使用java命令解释运行.class字节码文件,格式:java 类名。
一个java源文件中可声明多个class类。但最多声明一个public类,且被public声明的类名必须与源文件名相同;编译后每个类都会生成一个.class的字节码文件,与类名相同。
package com.shangguigu.test;
public class HelloWorld {
// 程序的入口是main()方法,格式是固定的
public static void main(String[] args) {
// 每一行执行语句都以“;"结束
Hello a1 = new Hello();
// 输出语句
System.out.println("Hello World!");
System.out.println("----------------------");
System.out.println("你好");// 先输出数据,然后换行
System.out.print("大家好");// 不换行
}
}
class Hello{
public void show(){
System.out.println("hdi");
}
}
class Person{
}
6.2.程序小结
Java源文件以“.java”为扩展名。源文件的基本组成部分是类(class);Java应用程序的执行入口是main()方法,它格式是固定的;Java语言严格区分大小写;Java方法由一条条语句构成,每个语句以“;”结束;大括号都是成对出现的,缺一不可;一个源文件中最多只能有一个public类。其它类的个数不限,如果源文件包含一个public类,则文件名必须按该类名命名。
6.3.Java代码规范
类、方法的注释,要以javadoc的方式来写;非JavaDoc的注释,往往是给代码维护者看的,着重告诉读者为什么这么写,如何修改和注意什么问题等;使用tab操作,实现缩进,默认整体向右移动,用shift+tab整体左移;运算符和=两边习惯加一个空格;源文件使用utf-8编码。
7.关键字和标识符
7.1.关键字和保留字
被赋予特殊含义、专门用途的字符串(单词),并且字母要小写,在程序中不能另作它用。
用于定义数据类型的关键字 | ||||
class | inteface | enum | byte | short |
int | long | float | double | char |
boolean | void | |||
用于定义流程控制的关键字 | ||||
if | else | switch | case | return |
while | do | for | break | continue |
用于定义访问权限修饰符的关键字 | ||||
private | protected | public | default | |
用于定义类,函数,变量修饰符的关键字 | ||||
abstract | final | static | synchronized | |
用于定义类与类之间关系的关键字 | ||||
extends | implements | |||
用于定义建立实例及引用实例,判断实例的关键字 | ||||
new | this | super | instanceof | |
用于异常处理的关键字 | ||||
try | catch | finally | throw | throws |
用于包的关键字 | ||||
package | import | |||
其他修饰符关键字 | ||||
native | strictfp | transient | volatile | assert |
用于定义数据类型值的字面值 | ||||
true | false | null |
Java保留字:goto 、const,注意:区分大小写。
7.2.标识符的使用
对各种变量、方法、类、接口和包等命名的字符串为标识符,可理解为自己命名的字符序列都是标识符。
7.2.1.标识符的命名规则
由26个英文字母大小写、0-9、_或$组成。不能以数字开头;不能直接用关键字或保留字,但能包含关键字和保留字;严格区分大小写,长度无限制,不能包含空格等。
7.2.2.Java中的名称命名规范
包名:由多单词组成时所有字母要小写:xxxyyyzzz;类名、接口名:由多单词组成时,所有单词的首字母大写:XxxYyyZzz;变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始首字母大写:xxYyZzz;常量名:所有字母都大写,多单词时每个单词用下划线连接:XXX_YYY_ZZZ。
package com.learn.test;
// 类名:Identifier
public class Identifier {
public static void main(String[] args) {
// 变量名myNumber01
int myNumber01 = 1002;
System.out.println(myNumber);
}
}
// 类名Hello1_$
class Hello1_${
}
8.常量和变量
8.1.常量
常量:运行程序时,值不能改变的量。整数常量:88(十进制)、077(八进制)、11E(十六进制);浮点型常量:3.4f(float)、3.4(double型);布尔常量:true、false;字符常量:'A'、'\n'字符(转义)、'\\'特殊;字符串常量:“你好帅";null常量:null;符号常量:final double p = 3.14。
8.2.变量
内存中的一个存储区域,该区域的数据可在同一类型范围内不断变化。程序中最基本的存在单元,包含变量类型、变量名和变量值。java是强类型语言:所有的变量必须先声明后使用,指定类型的变量只接受该类型与之匹配的值。
Java中每个变量必须先声明和赋值才能使用,用变量名可访问这块区域的数据。作用域:在定义内的一对{ }中,只有在其作用域中才有效,同一个作用域,不能定义重名的变量。
类型 | 语法 | 举例 |
声明变量 | 数据类型 变量名称; | int var; |
变量赋值 | 变量名称 = 值; | var = 10; |
声明和赋值变量 | 数据类型 变量名 = 初始化值; | int var = 10; |
步骤:声明变量:根据数据类型在内存申请空间。赋值:将数据存储至对应的内存空间并赋值。作用域:规定变量所能使用的范围,只在其作用域内才能使用。
public class HelloWorld {
// 变量赋值两种方式
String name1 = "张三"; // 全局变量
// 方式二
String name;//先声明
name = "张三";//在赋值
// 可以多个同类型的变量同时初始化:
String username,address,tel;
public static void main(String[] args) {
// 变量的定义,声明并赋值
int myAge = 12;
// 变量的使用
System.out.println(myAge);
int a = 7;
if (5 > 3) {
int s = 3;// 局部变量,在if里面有用
System.out.println("s=" + s);
System.out.println("a=" + a);
}
System.out.println("s=" + s);//报错,不在其作用域内
System.out.println("a=" + a);
}
}
8.3.成员变量和局部变量
根据变量的声明位置分为成员变量和局部变量,并且都有各自的生命周期。
变量类型 | 分类 | 作用域 |
成员变量 | 以static修饰为类变量,否则为实例变量 | 声明再类里面,方法的外面,作用域是整个类 |
局部变量 | 形参(方法、构造器中定义的变量)、方法局部变量(在方法内定义)和代码块局部变量(在代码块内定义) | 声明再方法内部,作用域是离它最近的一对大括号里,使用时必须谨慎初始化。局部变量除形参外,需显式初始化 |
public class MemberVariable {
static int Life = 1;// 成员变量的类变量
// age和name是成员变量,也是实例变量
int age = 12;
String name = "张三";
public static void main(String[] args) {
new MemberVariable().show("男");
}
public void show(String sex) {// sex是形参,也是局部变量
// habby是局部变量
String habby = "打篮球";
System.out.println(name + "性别:"+ sex + "年龄:" + age + "爱好:" + habby);
}
}
9.Java数据
9.1 基本数据类型
Java对每一种数据都定义明确具体的类型(强类型语言),在内存中分配了不同大小的内存空间。按照数据类型划分为基本数据类型和引用类型。
9.1.1.基本数据类型
基本数据类型 | ||||
类型分类 | 类型 | 存储空间 | 范围和解释 | |
整数类型 | byte | 1字节=8bit位 | -128~127,bit: 计算机最小存储单位,byte:计算机基本存储单元 | |
short | 2字节 | -2^15~2^15-1 | ||
int | 4字节 | -2^31~2^31-1,整型常量默认类型;不足以表示较大的数时使用long | ||
long | 8字节 | -2^63~2^63-1,声明该类型时必须以"l"或"L"结尾,long id = 12452l | ||
浮点型型 | 单精度float | 4,-3.403E38 ~3.403E38 | 声明float类型结尾加‘f’或‘F’,如:float num = 12.3f;float尾数可以精确到7位有效数字,表示数值的范围比long还大。 浮点型表示带小数点的数值,Java的浮点型默认为double型,因为它的精度更高,是float的两倍。 | |
双精度double | 8,-1.798E38 ~1.798E38 | |||
字符类型 | char | 1字符=2字节 | Java中使用Unicode编码,一个字符可以存储一个字母、一个汉字或其他书面语的一个字符,所以可进行运算。 字符型变量的三种表现形式:字符常量用单引号(‘ ’)括起来的单个字符。char c1 = 'a'; char c2 = '中'; 转义字符‘\’来将其后的字符转变为特殊字符型常量。char c3 = ‘\n’, '\n'表示换行符;用Unicode值来表示字符型常量:‘\uXXXX’。其中,XXXX代表一个十六进制整数。\u000a 表示 \n | |
布尔类型 | boolean | 布尔型只能取两个值:true或false,不能用0或非 0 的整数替代false和true。常常在条件判断和循环结构中使用。 |
public static void main(String[] args) {
// 整形:byte(1字节 = 8bit) / short(2字节) / int(4字节) / long(8字节)
byte a = 12;
// 声明long类型变量,必须以“l”或“L"结尾
long h1 = 424l;
// 浮点型:float(4字节)/double(8字节)
double d1 = 123.3;
// 定义float类型变量,变量末尾要加上"f"或"F"
float f1 = 12.3f;
// 定义char类型变量,通常使用一对'',内部只能写一个字符
char c1 = 'q';
// 转义字符
char c2 = '\n';// 换行
// 布尔型:boolean
boolean isMarried = true;
if (isMarried) {
System.out.println("你不能参加\"单身\"party,\\n");
} else {
System.out.println("你可以谈女朋友");
}
}
9.1.2.String类型
String字符串属于引用数据类型,声明时,使用一对" ",可与8种基本数据类型做连接运算:+;运算结果为String类型。
public static void main(String[] args) {
String s1 = "Hello World";
String s2 = "";
//char = "";//编译不通过
//String str6 = 123;//编译不通过
String str8 = 123 + "";//"123"
int number = 1001;
String numberStr = "学号:";
boolean b1 = true;
String info = numberStr + number;// 学号:1001
String info1 = info + b1;// 学号:1001true
//练习
char c = 'a';//97 A:65
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
}
9.2.基本数据类型转换
9.2.1.自动类型转换
容量小的类型自动转换为容量大的数据类型。
容量大小排序:byte/char/short > int > long > float > double。
多种数据类型混合运算时,系统首先自动将所有数据转换成运算中数据类型容量最大的类型,然后再进行计算,容量小的数据类型与容量大的数据类型做运算时,结果自动提升为容量大的数据类型,容量大小指表示数的范围的大和小。比如:float容量要大于long的容量。
byte、short、char之间不会相互转换,它们计算时首先转换为int类型;boolean类型不能与其它基本数据类型运算。
任何基本数据类型和字符串(String)连接运算时(+),都会自动转化为字符串类型;一个字符串可串接另一个字符串,也可直接串接其他类型的数据。
原则:小类型可用大类型去接收;小类型遇到大类型会自动转化为大类型;一切类型遇到字符串都会转化为字符串。
public static void main(String[] args) {
//整形常量默认为int类型,浮点类型常量默认为double类型
byte b1 = 23;
int i1 = 124;
// 编译不通过
//byte = b1 + i1;
int i2 = b1 + i1;// 127
char c1 = 'a';// 对应的数字是97
char c2 = 97;//开发种非常少见
int i4 = 19;
int i3 = c1 + i4;// 116
// 特殊的,如下运算时不改变它的类型
byte = 5;
b += 3;// 类型没有改变,还是byte类型
//编码成功,默认把int类型赋值给long类型
long l1 = 123231;
//编译失败,过大的整数
//long l2 = 123435467889;
long l3 = 123435467889L;
}
9.2.2.强制类型转换
自动类型转换的逆过程,将容量大的数据类型转换为容量小的数据类型。转换时使用强制转换符:(),可能造成精度降低或溢出。
格外要注意:字符串不能直接转换为基本类型,但通过基本类型对应的包装类则可实现把字符串转换成基本类型。boolean类型不可以转换为其它的数据类型。
double d1 = 12.3;
int a1 = (int)d1;//12,截断操作,只要整数,损失精度
byte b = 3;
b = (byte)(b+4); // 把int强制转换成byte
int i = 5;
float d = 3.314F;
// i+d结果为double类型
double result = (float)(i+d); //把double强转为float类型
// 小类型可以用大类型去接收
// byte、short、int、long 从小到大
int a = (byte)123;//对
int b = (short)123;//对
int c = (long)123;//错
// 一瓶水装入一个盆子里,可以;一盆水装入一个瓶子,不可以。
// 小类型遇到大类型会自动转化为大类型
double ave = (98+97+99)/3.0;//98.0
// 一切类型遇到字符串都会转化为字符串,只有遇到字符串才会转化为字符串
System.out.println(10 + 1 + "");//11
System.out.println( 10 + " " + 1);//101
System.out.println("" + 10 + 1);//101
double num12 = 8.1 / 3; //2.7,接近2.7的一个小数,而不是 2.7
// 当我们对运算结果是小数的进行相等判断时,要小心
// 应该是以两个数的差值的绝对值,在某个精度范围类判断,不然可能达不到想要的效果
if(Math.abs(num11 - num12) < 0.000001 ) {
System.out.println("差值非常小,到我的规定精度,认为相等...");
}
将String类型转成基本数据类型时,如可把 "123" , 转成一个整数,但不能把 "hello" 转成一个整数;如果格式不正确,就会抛出异常,程序就会终止。
10.进制和编码
10.1.进制
数字在计算机底层以二进制形式存在,并以数字的补码方式存储数据。整数有四种表示方式
二进制(binary):0,1,满2进1,以0b或0B开头;
十进制(decimal):0-9,满10进1;
八进制(octal):0-7,满8进1,以数字0开头表示 ;
十六进制(hex):0-9及A-F,满16进1,以0x或0X开头表示,此处A-F不区分大小写:0x21AF + 1 = 0X21B0。
public static void main(String[] args) {
// 二进制
int num1 = 0b110;
// 十进制
int num2 = 110;
// 八进制
int num3 = 0127;
// 十六进制
int num4 = 0x110A;
// 输出:num1 = 6,num2 = 110,num3 = 87,num4 = 4362
System.out.println("num1 = "+num1+"\nnum2 = "+num2+"\nnum3 = "+num3+"\nnum4 = "+num4);
}
10.2.原码、反码和补码
有符号数的二进制最高位:0表示正数,1表示负数;正数的原码、反码和补码都一样;负数的反码=原码符号位不变,其它位取反;负数的补码=反码+1,负数的反码=负数的补码-1;0的反码和补码都是0;java没有无符号数,换言之Java中的数都是有符号的;在计算机运算时,都是以补码方式来运算;看运算结果时,要看它的原码。
11.运算符
运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。
名称 | 符号 | 其他 |
算术运算符 | +、-、*、/、%、++、-- | 取模运算的结果的符号与被模数符号相同,结果不一定总是整数。除法时整数相除舍弃小数部分。加号能把非字符串转换成字符串 |
赋值运算符 | =、+=、-=、*=、/=、%= | 当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。 |
比较运算符(关系运算符) | ==、!=、<、>、<=、>=、instanceof | 运算结果为boolean类型;instanceof是检查是否是类的对象。 |
逻辑运算符 | &、^、|、!、&&、|| | ^异或、逻辑运算符用于连接布尔型表达式,如Java把3<x<6写成x>3 & x<6 。 |
位运算符 | <<、>>、>>>、&、|、^、~ | <<是左移,再一定范围内,每向左1位,相当于*2,>>>无符号右移,位运算是直接对整数的二进制进行的运算 |
三元运算符 | 结构(条件表达式)?表达式1 : 表达式2 | 条件为true执行表达式1,否则执行表达式2。 |
11.1.算术运算符和赋值运算符
public static void main(String[] args) {
// 除号 /
int num1 = 12;
int num2 = 5;
int result = num1 / num2;// 2
double result3 = num1 / num2;// 2.0
double result4 = num1 / (num2 + 0.0);// 2.4
double result5 = (double) num1 / num2;// 2.4
double result6 = (double) (num1 / num2);// 2.0
// 赋值运算符:=
int wangScore = 80;
int zhangScore;
zhangScore = wangScore;//80 将右边的赋值给左边的
// 变量名 = 表达式:表达式就是符号(如加、减)与操作数(如wangScore,10等)的组合
zhangScore = (wangScore + 10) + (wangScore - 5);// 165
// %:取余运算
// 结果的符号和被模数的符号相同
// 开发中,用来判断是否能除尽
int m1 = 12 % 5;// 2
int m2 = -12 % 5;// -2
int m3 = 12 % -5;// 2
int m4 = -12 % -5;// -2
// 复合运算符:+=、-=、*=、/=、...
int num3 = 5;
num3 += 3;// 8等价于num3 = num3 + 3;
// (前)++:先自增1,在运算
// (后)++:先运算,在自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1);// a1 = 11,b1 = 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2);// a2 = 11,b2 = 10
// 注意点
short s1 = 10;
// s1 = s1 + 1;//编译失败,结果为int,但是s1是short类型
s1 = (short) (s1 + 1);// 正确的
s1++;// 自增1不会改变本身变量的数据类型
// 赋值
int g1 = 10, j1 = 10;
int g2, j2;
g2 = j2 = 10;
int j3 = 10;
int g3 = 10;
g1 += j1;// g1 = g1 +j1;
short h1 = 10;
// h1 = h1 +2;//编译不通过
h1 += 2;// 不会改变变量本身的数据类型,还是short类型
// 开发中希望变量+2有几种方式?
// 方式一:num = num + 2;
// 方式二:num += 2;(推荐)
// +1的几种方法
// num = num + 1;
// num += 1;
// num++;(推荐)
// 练习1
int i = 1;
i *= 0.1;// 通过
System.out.println(i);// 0
i++;
System.out.println(i);// 1
// 练习2
int m = 2, n = 3;
n *= m++;
System.out.println(m);// 3
System.out.println(n);// 6
int n5 = 10;
n5 += (n5++) + (++n5);// n5 = n5 + (n++) + (++n); n5 = 10 + 10 + 12;
System.out.println("n5 = " + n5);// n5 = 32
}
11.2.比较运算符(关系运算符)、逻辑运算符和位运算符
public static void main(String[] args) {
// =为赋值运算符,==为等于运算符
// 关系表达式的结构为布尔值;>、<、>=、<=运算符的优先级别高于==、!=
// >、<、>=、<=运算符只支持数值类型的数据比较
int num4 = 5, num5 = 6;
if (num4 == num5) {// false
System.out.print("num4 == num5");
}
if (num4 != num5) {// true
System.out.print("num4 == num5");
}
// 优先级:! -> && -> ||
// 逻辑与,两个操作数都为true,结果才为true
// 逻辑或,两个操作数一个为true,结果为true
// ! true变为false,false变成true
boolean isTrue = false;
if (!isTrue) {
System.out.println("!运算结果为真");
}
// 区分& 和&&,两者的运算结果相同,当左边为true二者右边都执行
// &&左边为false,右边不再执行;&不管左边成不成立,右边都执行
boolean b1 = true;
b1 = false;
int num1 = 10;
if (b1 & (num1++ > 0)) {
System.out.println("我现在北京");
} else {
System.out.println("我现在南京");// 我现在南京
}
System.out.println(num1);// 11
boolean b2 = true;
b2 = false;
int num2 = 10;
if (b2 && (num2++ > 0)) {
System.out.println("我现在北京");
} else {
System.out.println("我现在南京");// 我现在南京
}
System.out.println(num2);// 10
// 区分:| 与 ||,二者运算结果相同,二者左边为false,右边都会执行
// 二者左边为ture,|还会运算右边,||不会运算右边
// 逻辑运算符:&、|、^
// 操作数类型只能是布尔类型,操作结果也是布尔类型
// 优先级:! -> & -> ^ -> | -> && -> ||
// 逻辑与,都为true,结果才为true
if (num4 < num5 & num5 > 3) {// true
System.out.println("&运算结果为真");
}
// 逻辑或,有一个为true,结果为true
if (num4 > num5 | num5 > 3) {// true
System.out.println("|运算结果为真");
}
// 逻辑异或,相同时false,不同时true
if (num4 > num5 ^ num5 > 3) {// true
System.out.println("^运算结果为真");
}
// &,按位与,两个操作数都是1,结果为1
// |,按位或,两个操作数一个是1,结果为1
// ^,按位异或,两个操作数不同,结果为1
// ~,按位非/取反,操作数为1,结果为0;操作数为0,结果为1
// <<,左移,右边空位补0
// >>,右移,左侧空位补最高位,及符号位
// >>>,无符号右移,左侧空位补0
// 位运算的结果也是整型数;位运算符对操作数以二进制位为单位进行运算
// 如果操作数是char、byte、short,位运算前其值会自动晋升为int,运算结果也为int
// 位运算的操作数是整型数
// 5的二进制:00000101;2的二进制时00000010
// 00000101左移两位变成00010100
int num6 = 5 << 2;// 左移相当于5*2^2次幂
int num7 = 20 >> 2;// 右移相当于20/2^2
// num6=20,num7=5
System.out.println("num6 = " + num6 + "\t" + "num7 = " + num7);
int num3 = 10;
int num4 = 20;
// 交换两个的值
// 方式一:定义临时变量的方式
// 推荐方式
int temp = num4;
num4 = num3;
num3 = temp;
// 方式二:好处,不用定义临时变量
// 弊端①相加操作可能存在超出存储范围②局限性:只是用数值类型
// num3 += num4;
// num4 = num3 -num4;
// num3 = num3 - num4;
// 方式三:使用位运算,好处,不用定义临时变量,局限性:只是用数值类型
// num3 = num3 ^ num4;
// num4 = num3 ^ num4;
// num3 = num3 ^ num4;
System.out.println("num3 = " + num3 + ",num4 =" + num4);// num3 = 20,num4 =10
}
算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和条件运算符:优先级别最低的是赋值运算符,可通过()小括号控制表达式的运算顺序。()优先级最高,从右向左结合性的只有赋值运算符、三目运算符和单目运算符;算术运算符 > 关系运算符 > 逻辑运算符。
=和==的区别:== 是比较运算符,结果为boolea值;= 是赋值运算符,把右边的值通过等号传递到左边。大于、小于、大于等于、小于等于只支持左右两边都是数值;== 和 !=两边的操作数可以是数值类型和引用类型;字符串的比较用equals。
int i = 10;
int j = 20;
System.out.println(i == j);// false
System.out.println(i = j);// 20
11.3.三元运算符
三元运算符可用if-else替换,反之不成立。如果程序即可用三元运算符,也可用if-esle结构,优先选择三元运算符,效率高。
三目运算符/三元运算符:条件?表达式1:表达式2。条件为true执行表达式1否则执行表达式2。表达式1和表达式2类型相同;条件表达式是boolean类型;三元运算符可嵌套使用。
//三目运算符的使用
boolean sex = true;
System.out.println(sex == true ? '男' : '女');
int sex1 = 0;
System.out.println(sex1 == 1 ? '男' : '女');
12.面试
12.1.左移右移
最高效方式的计算2 * 8 ? 2 << 3 或 8 <<1:2乘以8,最高效的方式2左移3位或8左移1位。