Java基础

JAVA语言基础

Windows操作系统常用的DOS命令

• dir：列出当前目录下的文件以及文件夹

• md：创建目录

• rd：删除目录

• cd：进入指定目录

• cd…：退回到上一级目录

• cd\：退回到根目录

• del：删除文件

• exit：退出 dos 命令行

1 JVM、JRE、JDK介绍

1. JVM(JVM Java Virtual Machine)：核心机制，Java虚拟机

JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器。

对于不同的平台，有不同的虚拟机。

Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”。

因为有了JVM，同一个Java 程序在三个不同的操作系统中都可以执行。这样就实现了Java
程序的跨平台性。

（2）JRE(Java Runtime Environment Java运行环境)

包括Java虚拟机(JVM Java Virtual
Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

（3）JDK(Java Development Kit Java开发工具包)

JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。其中的开发工具：编译工具(javac.exe)
打包工具(jar.exe)等

简单而言，使用JDK的开发工具完成的java程序，交给JRE去运行。

2环境变量的配置

• 配置环境变量

  • path：windows系统执行命令时要搜寻的路径。

  • classpath：JDK1.5之前必须配置，JDK1.5 之后可选配置

（1）在dos命令行中敲入javac，出现错误提示：

错误原因：当前执行的程序在当前目录下如果不存在，windows系统会在系统中已有的一个名为path的环境变量指定的目录中查找。如果仍未找到，会出现以上的错误提示。

（2）进入到 jdk安装路径\bin目录下，执行javac，会看到javac参数提示信息。

（3）每次执行 java
的工具都要进入到bin目录下，是非常麻烦的。可不可以在任何目录下都可以执行java的工具呢？

根据windows系统在查找可执行程序的原理，可以将java工具所在路径定义到 path
环境变量中，让系统帮我们去找运行执行的程序。

方式一：直接配置path

我的电脑/计算机右键属性，选择高级系统设置

点击【环境变量】

在path中新加环境变量时，建议把原来的值复制到记事本中再编辑，在原来的值前面增加

D:\ProgramFiles\Java\jdk1.8.0_141\bin;

然后再复制回去，避免出错。

标点符号是英文半角输入方式。

方式二：配置JAVA_HOME+path

我的电脑/计算机右键属性，选择高级系统设置

点击【环境变量】

新建变量“JAVA_HOME”，值为JDK的安装路径，JDK安装的根目录：D:\ProgramFiles\Java\jdk1.8.0_141

这里注意：

• 如果是以后都在该用户下开发使用JDK，那么可以选择新建用户变量；

• 如果是以后希望在所有用户下该变量都可见，那么选择新建系统变量；

• JAVA_HOME是JDK安装的根目录，不是Java开发工具的bin目录
  

把JAVA_HOME变量值添加到path变量中：%JAVA_HOME%\bin;

注意：

• 在path中新加环境变量时，建议把原来的值复制到记事本中，再编辑，在原来的值前面增加%JAVA_HOME%\bin;然后再复制回去，避免出错

• 如果新建的是用户变量JAVA_HOME，那么只能把JAVA_HOME添加到用户变量的path中，否则可能出现找不到JAVA_HOME的情况，如果用户变量没有path，可以再新建一个path变量（path变量是windows系统执行命令时要搜寻的路径），如果已经存在path，那么编辑即可，

• 如果新建的是系统变量JAVA_HOME，那么只能把JAVA_HOME添加到系统变量的path中，否则可能出现找不到JAVA_HOME的情况

测试环境

检验javac命令

检验java命令

Java语言主要特征

• Java语言是易学的。Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。

• Java语言是强制面向对象的。Java语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。

• Java语言是分布式的。Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（javanet），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。

• Java语言是健壮的。Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。

• Java语言是安全的。Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。如：安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查。

• Java语言是体系结构中立的。Java程序（后缀为java的文件）在Java平台上被编译为体系结构中立的字节码格式（后缀为class的文件），然后可以在实现这个Java平台的任何系统中运行。

• Java语言是解释型的。如前所述，Java程序在Java平台上被编译为字节码格式，然后可以在实现这个Java平台的任何系统的解释器中运行。

• Java是性能略高的。与那些解释型的高级脚本语言相比，Java的性能还是较优的。

• Java语言是原生支持多线程的。在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。

第一个Java应用程序

注释

用于说明解释程序的文字就是注释。

提高了代码的阅读性；调试程序的重要方法。

Java中的注释类型：

• 单行注释

• 多行注释

• 文档注释（java特有）

注释是一个程序员必须要具有的良好编程习惯。

将自己的思想通过注释先整理出来，再用代码去体现

单行注释和多行注释

单行注释： //注释文字

多行注释： /* 注释文字 */

注：

对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。

多行注释里面不允许有多行注释嵌套。

文档注释

文档注释：/** 注释内容 */

注释内容可以被JDK提供的工具 javadoc
所解析，生成一套以网页文件形式体现的该程序的说明文档。

例如：javadoc -d mydoc -version -author HelloWorld.java

标识符

Java
对各种变量、方法和类等要素命名时使用的字符序列称为标识符。凡是自己可以起名字的地方都叫标识符。

1、标识符命名规则

定义合法标识符：

• 由26个英文字母大小写，0-9 ，_或 $ 组成

• 数字不可以开头。

• 不可以使用关键字和保留字，但能包含关键字和保留字。

• Java中严格区分大小写，长度无限制。

• 标识符不能包含空格。

2、标识符命名规范

标识符的命名：

在起名字时，为了提高阅读性，要尽量有意义，“见名知意”

• 包名：多单词组成时所有字母都小写：xxxyyyzzz

• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

变量

变量的作用：保存数据

变量的本质：内存的一块存储区域

变量的三要素：数据类型、变量名、变量值

数据类型：决定内存大小，可以存什么值

变量名：如何访问这块存储区域

变量值：里面存储的数据

声明变量：数据类型 变量名;

变量赋值：变量名 = 变量值;

声明变量和变量的赋值可以同时进行，也可以分开进行。但是在变量被访问之前，必须有值。

例如：数据类型 变量名 = 变量初始值;

变量的使用：通过变量名来访问这块存储区域

要求：

• 变量必须先声明后使用

• 变量再使用之前必须有初始值

• 变量有作用域

变量：
某个值在程序中不同的地方都在使用，那么这个值就用一个变量保存。可以使用变量名来代表这个值。
变量本质对代表内存的一块存储区域。

变量的三要素：
1、数据类型（决定区域的大小，决定里面存的是什么类型的值）
比喻：面积，用途
2、变量名
比喻：房主，地址
3、变量值
比喻：里面的内容
如何使用变量？
1、变量必须先声明后使用
声明变量的格式：
数据类型 变量名;
例如：int age;
int num;
double score;
2、变量的使用之前，还必须初始化
变量赋值的格式：
变量名 = 变量值;

变量的声明和初始化可以在同一个语句完成。
例如：int age = 18;

3、变量有作用域
从声明处开始，到它所属的}结束

同一个作用域中不能重复声明
（1）同一个作用域中，一个变量声明一次
（2）同一个作用域变量不能重名

class BianLiang{
	public static void main(String[] args){
		//声明变量
		int age;
		
	//变量的赋值，第一次赋值叫做初始化
	age = 18;
	
		System.out.print("现在年龄：" + age);
		System.out.print("明年的年龄：" + (age+1));
	}
	
	/*
	//age超过作用域
	public static void test(){
		System.out.print("现在年龄：" + age);
	}
	}

数据类型

基本数据类型（8种）：

• 整型：byte（1个字节）short（2个字节）int（4个字节，整数的默认类型）long（8个字节）

字节byte：1个字节，-128~127

短整型short：2个字节，-32768~32767

• 浮点型：float（4个字节）double（8个字节，小数的默认类型）

• 字符型：char（2个字节）

• 布尔型：boolean（只有两个值true和false）

引用数据类型：

• 类

• 数组

• 接口

注意：

• Java的整型常量默认为 int
  型，如果想要表示某个整数值是long型时，需要在值后面加L或l。java程序中变量常声明为int型，除非不足以表示大数，才使用long

• Java
  的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。float可以保证十进制科学计数法小数点后6位有效精度和第7位的部分精度。double可以保证十进制科学计数法小数点后15位有效精度和第16位的部分精度。

• 字符型的值必须使用单引号，只能而且必须存储单个字符，不能是空单引号。例如：’a’、’\n’、’\u5c1a’。字符型使用Unicode编码（ASCII，特殊字符，中文、日文、韩文…）

• String是引用数据类型，String的常量值必须使用双引号。单独的双引号也是一个字符串值。

Java的数据类型：
（1）基本数据类型（8种）
（2）引用数据类型：类、数组、接口…
一、基本数据类型（8种）
bit：位，计算机中只有0和1，最小的存储单位
byte：字节，一个字节 = 8 位
1、数值型
（1）整型（整数）
byte：字节 1个字节 -128~127
short：短整型 2个字节 -32768~32767
int：整型（默认类型）4个字节
long：长整型 8个字节
特殊：long类型的数字后面需要加L或l

（2）浮点型（小数）
float：单精度浮点型（4个字节）
科学记数法：356.78 3.5678*10^2
大约是：小数点后6~7位
特殊：float类型的数字后面需要加F或f
double：双精度浮点型（8个字节）默认类型
大约是：小数点后15~16位

2、字符型
char：字符型 2个字节 因为Java中所有的字符都使用Unicode字符集
Java中每一个字符，都有一个唯一的Unicode编码值。
可以存储一个字母，一个汉字，一个其他的字符
字符类型的值要使用单引号引起来’’
字符串类型的值要使用双引号引起来""
char c = ‘a’;
char s = ‘女’;
char line = ‘\n’;//转义字符
char tab = ‘\t’;
char d = ‘\b’;
char b = ‘’’;
char b = ‘"’;
char c = ‘\u5c1a’;//Unicode编码值的十六进制形式
3、布尔型，逻辑型
boolean：只有两个值，true和false

class Test{
	public static void main(String[] args){
		byte b = 127;
		System.out.println("b = " + b);//""中的内容原样输出
		long num = 123456789012345678L;
		System.out.println("num=" + num);
		float f = 3.1F;
		System.out.println("f=" + f);
		float f = 3.1F;
		System.out.println("f=" + f);
		
		double d = 3.1415926531234;
		System.out.println("d=" + d);
		
		//char gender = '女';
		//String sex = "女";
		//System.out.print("a\tb\nc\b");
		
		char c = '尚';//char c = '\u5c1a';
		System.out.print(c);
		
		boolean beautiful = false;
		if(beautiful){
			System.out.println("世界你好");
		}else{
			System.out.println("世界你好");
		}
	}
}

变量的运算之数据类型之间的转换

自动类型转换（自动升级）：小容量转为大容量（系统自动完成）

byte,short,char --> int -->long -->float -->double

• byte，short，char三者之间不进行运算，若运算都将自动升级为int再做运算

• boolean不与其他任意数据类型转换

• 任何数据类型与String之间使用“+”运算符都将自动“连接”成String类型

强制类型转换：

大容量转小容量，需要使用强制符()，结果可能损失精度或溢出

基本类型的转换：
（1）自动类型转换
byte,short,char --> int -->long --> float --> double
1个字节，2个字节，2个字节 4个字节 8个字节 4个字节 8个字节
说明：
byte,short,char之间是互不转换的，包括byte+byte等运算也会变成int
boolean和谁都不转
String类型的数据与任意类型的数据“+”拼接后结果都是String字符串

ASCII码：
小写字母a：97
小写字母b：98

大写字母A：65
大写字母B：66

数字0：48
数字1：49

（2）强制类型转换
double --> float --> long -->int -->byte,short,char
需要强制类型转换符()
注意：强制类型转换可能损失精度或溢出

class TypeChange{
	public static void main(String[] args){
		byte b = 127; //把127赋值给b，存储到b变量中
		int num = b; //把变量b中的值复制一份给num，也是说把变量b中的值赋值给num
		System.out.println("b = " + b);
		System.out.println("num = " + num);
		
		char c = 'a';//Unicode编码值，兼容ASCII码
		int letter = c;
		System.out.println("c = " + c);//a
		System.out.println("letter = " + letter);//97
		
		byte b1 = 1;
		byte b2 = 2;
		byte b3 = (byte)(b1 + b2);
		System.out.println("b3 = " + b3);
		
		char c1 = 'a';
		char c2 = (char)(c1 + 1);
		System.out.println("c2 = " + c2);
		double d = 10.56;
		int a = (int)d;
		System.out.println("a = " + a);//损失精度
		int age = 130;
		byte bb = (byte)age;//溢出
		System.out.println("bb = " + bb);
			}
				}

进制

计算机中任何的计算和存储都是以二进制方式实现的

位（bit） — 是计算机中最小的存储单位

字节（byte） — 计算机中基本的存储单元

1byte = 8bits、1KB = 1024Byte、1MB = 1024KB、1GB = 1024MB、1T = 1024GB

对于整数，有四种表示方式：

• 二进制：0,1 ，满2进1.以0b或0B开头（字母B大小写均可）。

• 十进制：0-9 ，满10进1.

• 八进制：0-7 ，满8进1.八进制数被冠以0来表示。

• 十六进制：0-9及A-F，满16进1，十六进制数被冠以0X来表示（字母X大小写均可）

如： 0x3f20（十六进制） 0732 （八进制）

public class JinZhi{
	public static void main(String[] args){
		//最终打印的结果是十进制
		System.out.println("十进制：" + 10);
		System.out.println("二进制：" + 0B10);
		System.out.println("八进制：" + 010);
		System.out.println("十六进制：" + 0X10);
	}
}

十进制转化任意进制

任意进制转换为十进制

2、二进制 八进制 十六进制互转

二进制转八进制：三位一组，算出这三位对应的十进制值，然后挨个连接上即可

二进制转十六进制：四位一组，算出这四位对应的十进制值，然后挨个连接上即可

八进制转二进制：把每个位置上的数字当做10进制的数，转成三位的二进制，然后挨个拼接上

十六进制转二进制：把每个位置上的数字当做10进制的数，转成四位的二进制，然后挨个拼接上

原码、反码、补码

所有数字在计算机底层都以二进制形式存在。一个数在计算机中的二进制表示形式,
叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0,
负数为1。

Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位。

因为机器数是带符号的，因此机器数与一个数的“二进制值”还是有区别的。

计算机以补码的形式保存所有的整数。

正数的原码、反码、补码都相同

负数的补码是其反码加1。

运算符

运算符：

1、算术运算符

2、赋值运算符

3、比较运算符（关系运算符）

4、逻辑运算符

5、条件运算符

6、位运算符

表达式：操作数+运算符

1、算术运算符：

1. 加、减、乘、除：+、-、*、/

除：当两个整数相除时，只保留整数部分

1. 取模（求余数）：%

取模：被模数%模数，当模数有负号时，会被忽略

（3）+：作为单目运算时表示正数

与其他基本数据类型计算时当做加法用

当与字符串String类型进行运算时表示连接，计算结果是字符串String类型

1. -：作为单目运算符时表示负数

与其他基本数据类型计算时当做减法用

（5）++，-- 自增和自减

++在前，变量先自增，然后参与其他运算，在后，变量的值先参与其他运算，然后变量本身在自增

–类似

算术：arithmetic
一、算术运算符
（1）加：+
（2）减：-
（3）乘：*
（4）除：/
特殊：如果是两个整数相除，结果只保留整数部分
（5）取余，取模：% 被模数%模数
特殊：模数的负号被忽略

（6)在JAVA中：+ 还表示拼接
只要+两边有一个是字符串，那么就是拼接，结果仍然是字符串
a + “+”：a变量的值 拼接上 “+”符号 23+

（7）正号 +
（8）负号 -

（9）自增 ++
对于自增变量本身来说，++在前或在后都一样，自增变量都要加1
i++或++i，i就是自增变量

对于表达式来说，i++和++i不一样的，++在前，先自增，再进行其他运算，++在后，先进行其他运算，然后再自增

（10）自减 –
同自增

class SuanShu{
	public static void main(String[] args){
		int a = 23;
		int b = 12;
		System.out.println(a + "+" + b + "=" + (a+b));
		int sum = a + b;
		System.out.println(a + "+" + b + "=" + sum);
		
		int sub = a - b;
		//System.out.println(a + "-" + b + "=" + a-b);//错误，原因是a + "-" + b + "=" + a的结果是字符串，字符串不能进行减法
		System.out.println(a + "-" + b + "=" + (a-b));
		System.out.println(a + "-" + b + "=" + sub);
		
		int mul = a * b;
		System.out.println(a + "*" + b + "=" + a*b);
		System.out.println(a + "*" + b + "=" + mul);
		
		//整数相除，只保留整数部分
		int div = a / b;
		System.out.println(a + "/" + b + "=" + a/b);
		System.out.println(a + "/" + b + "=" + div);
		double d = (double)a/b;//先把a的类型进行转换，转换成double类型，然后再和b相除
		System.out.println(a + "/" + b + "=" + d);
		
		int yu = a % b;
		System.out.println(a + "%" + b + "=" + yu);
		
		System.out.println("------------------特殊的取模----------------------");
		System.out.println(5%2);//1
		System.out.println(-5%-2);//-1
		System.out.println(-5%2);//-1
		System.out.println(5%-2);//1
		
		System.out.println("------------------负号----------------------");
		int num1 = 12;
		int num2 = -num1;
		System.out.println("num2=" + num2);
		
		System.out.println("------------------自增----------------------");
		int i = 0;
		System.out.println("自增之前i=" + i);
		i++;
		System.out.println("自增第一次之后i=" + i);
		++i;
		System.out.println("自增第二次之后i=" + i);
		int j = ++i;//把i自增1，然后结果赋值给j，或者说，先算++i，然后再赋值
		System.out.println("自增第三次之后i=" + i);
		System.out.println("j="+j);
		int k = i++;//先算赋值，把i的值赋值给k，i原来是3，把3赋值给k，然后i在自增1，i变成4
		System.out.println("自增第四次之后i=" + i);
		System.out.println("k="+k);
		
		//面试题：陷阱题
		i = i++;//先赋值，把i原来的值重新赋值给i，不变，然后i自增，但是这个自增后的值没有在放回变量i的位置
		System.out.println("自增第五次之后i=" + i);
	}
}

2、赋值运算符：

基本的赋值运算符：=

扩展的赋值运算符：+= -= *= /= %= &= …

扩展的赋值运算符的说明：中间不能有空格，而且结果隐含数据类型转换

例如：short s1 = 1;
short s2 = 2;
s2 += s1;

赋值：assign
最基本的赋值运算符：=

Java中赋值，永远是把等号=右边的赋值给左边的变量。
右边如果是常量值，那么就把常量的值直接赋值给左边的变量；
右边如果是变量，那么就把变量的值直接赋值给左边的变量；
右边如果是表达式，那么就把表达式的运算结果直接赋值给左边的变量；

扩展的赋值运算符：
+=，-=，*=，/=，%=
注意：
（1）+=等，中间是不能有空格的，即不能写成 + =
（2）如果结果的类型与左边的变量不在一样时，隐含了强制类型转换

class FuZhi{
	public static void main(String[] args){
		int a = 10;//把10赋值给a
		int b = a; //把a的值赋值给b
		int c = a + b;//把a+b的运算结果赋值给c
		
		//20 = a;//错误的
		
		System.out.println("-------------------------------");
		byte b1 = 1;
		byte b2 = 127;
		//b2 = b1 + b2;//右边的结果是int类型，需要强制类型转换
		b2 += b1;//把左边的变量的值 + 右边的变量的值，结果再赋值给左边的变量，如果计算的结果是升级后的结果，会强制类型转换
		System.out.println("b1=" + b1);
		System.out.println("b2=" + b2);
		
		System.out.println("-------------------------------");
		int i = 2;
int j = 3;
		j *= i + 1;//等价于  j = j * (i+1);
		System.out.println("i=" + i);
		System.out.println("j=" + j);
		
		System.out.println("-------------------------------");
		int m = 2;
		int n = 3;
		n *= m++;// (1)n = n * m; (2)m++;
		System.out.println("m=" + m);//对于自增变量来说，++在前还是在后都要自增1
		System.out.println("n=" + n);
		
		System.out.println("-------------------------------");
		int x = 2;
		int y = 3;
		y *= ++x;// (1)++x; (2)y = y * x;
		System.out.println("x=" + x);//对于自增变量来说，++在前还是在后都要自增1
		System.out.println("y=" + y);
		
		System.out.println("-------------------------------");
		i = 1;
		i *= 0.1;//把double类型强制转换成int
		System.out.println(i);//0
		i++;
		System.out.println(i);//1
	}
}

3、关系运算符

关系运算符，比较运算符：运算的结果只有true或false的布尔值

（1）> < >= <= !=

（2）== 判断是否相等，一定要与=赋值运算符区分开

比较：compare
关系：relation

比较运算符又称为关系运算符：
1、大于：>
2、小于：<
3、大于等于：>=(中间不能有空格)
4、小于等于：<=
5、是否等于：==
6、是否不等于：!=

条件判断时，常常使用比较运算符

比较运算符的表达式的结果只有两种：true或false，即结果是一个boolean值

class BiJiao{
	public static void main(String[] args){
		int age = 19;
		
		System.out.println(age >= 18);
		System.out.println(age < 18);
		
		System.out.println("------------------------------");
		
		System.out.println(age == 18);//比较运算符的表达式，结果是true
		System.out.println(age = 18);//赋值表达式，结果是18
		
		boolean result = false;
		if(result = true){//变成了一个赋值表达式
			System.out.println("条件成立");
		}
		System.out.println("result="+result);
		
		/*
		编译错误(age=18)不是比较表达式，结果也不是true或false，条件只能是布尔值
		if(age = 18){
			System.out.println("刚刚成年");
		}
		*/
				
		/*
		if(age>=18){
			System.out.println("欢迎进入成人世界！");
		}else{
			System.out.println("未成年不允许进入！");
		}
		*/
	}
}

4、逻辑运算符

逻辑运算符：结果也是布尔型，而且操作数也必须是布尔型

与，并且 &
表示&符号两边的表达式/变量的值都必须是true，整个逻辑表达式的结果才为true

或 |
表示|符号两边的表达式/变量的值只要有一个true，整个逻辑表达式的结果就为true

非 ! 表示逻辑值取反

短路与 &&
表示&&符号两边的表达式/变量的值都必须是true，整个逻辑表达式的结果才为true

但是，如果左边的表达式已经是false时，右边的就不再计算，不看了

短路或 ||
表示||符号两边的表达式/变量的值只要有一个true，整个逻辑表达式的结果就为true

但是，如果左边的表达式已经为true时，右边的就不再计算

异或运算 ^ 求的就是个性，不同，两个操作数不同时，结果为真，如果相同就为假

逻辑：logic,logical
逻辑运算符：
(1)逻辑与：&
表示&左右两边的条件要同时成立
true & true 结果才为true
true & false 结果为false
false & true 结果为false
false & false 结果为false
(2)逻辑或： |
表示|左右两边的条件只要有一个成立就可以
false | false 结果为false

false | true 结果为true
true | false 结果为true
true | true 结果为true
(3)逻辑非：!
!false 结果为true
!true 结果为false
(4) 逻辑异或：^
^左右两边的条件的结果相反时为true
true ^ true 结果为false
true ^ false 结果为true
false ^ true 结果为true
false ^ false 结果为false
(5)短路与：&&
表示&&左右两边的条件要同时成立
true && true 结果才为true
true && false 结果为false
false && true 结果为false
false && false 结果为false
同逻辑与&有所不同：当&&左边的表达式为false时，右边的表达式不看了
(6)短路或：||
表示||左右两边的条件只要有一个成立就可以
false || false 结果为false
false || true 结果为true
true || false 结果为true
true || true 结果为true
和逻辑或|有所不同：当||左边的表达式为true时，右边的表达式不看了

二元运算符：运算符需要两个操作数
a + b， a * b， a = b， a > b，…
一元运算符： 运算符需要一个操作数
++，–，正号，负号
i++，+a

class Logic{
	public static void main(String[] args){
		//成绩
		int score = -75;
		
		//如果成绩在80~90之间，我们显示成绩良好
		//80<=score<=90
		/*错误
		if(80 <= score <= 90){
			System.out.println("良好");
		}
	if(score>=80 & score<=90){
			System.out.println("良好");
		}
		
		//如果成绩小于0或大于100，我们显示超过合理的成绩范围
		if(score<0 | score>100){
			System.out.println("超出成绩范围");
		}
		System.out.println("------------------------------------");
		System.out.println(true & true);//true
		System.out.println(true & false);//false
		System.out.println(false & true);//false
		System.out.println(false & false);//false
		
		System.out.println("------------------------------------");
		System.out.println(true | true);//true
		System.out.println(true | false);//true
		System.out.println(false | true);//true
		System.out.println(false | false);//false
		
		System.out.println("------------------------------------");
		int num = 100;
		boolean flag = num<100 | num>100;
		System.out.println("flag = " + flag);
		if(!flag){
			System.out.println("num等于100");
		}
		System.out.println("------------------------------------");
		System.out.println(true ^ true);//false
		System.out.println(true ^ false);//true
		System.out.println(false ^ true);//true
		System.out.println(false ^ false);//false
				
		System.out.println("------------------------------------");
		int i = 0;
		int j = 1;
		if(i>0 && ++j > 1){
			i = 20;
		}
		System.out.println("i=" + i);
		System.out.println("j=" + j);
	}
		}

5、三元(目)运算符

三元运算符：格式 条件表达式?表达式1:表达式2

注意条件表达式结果必须是布尔类型

当条件表达式的结果为true,那么整个三元运算符的结果就取表达式1的结果，否则就取表达式2的结果

案例：求两个数最大值

求三个数最大值

public class FindMax{
	public static void main(String[] args){
		int x = 3;
		int y = 2;
		int z = 5;
		
		int max = x>=y ? x : y;
		//运行到这里，max中存的是x,y中较大者
		
		max = max >= z ? max : z;
		
		System.out.println("max = " + max);
	}
}

6、位运算符

位运算符：操作数是整数

左移 << ：右边补0

右移 >> ：左边补0或1，原数最高位是1，就补1，原数最高位是0，就补0

无符号右移 >>>：左边补0

按位与 & ：二进制对应位置取与 ，同时为1才为1，否则为0

按位或 | ：二进制对应位置取或 ，有一个为1就为1

按位异或运算 ^ ：二进制对应位置取异或 ，两者不同才为1

按位取反 ~ ：二进制对应位置取反 ，原来是1，变为0，原来是0变为1

说明：位运算符都是机器数直接运算的

代码示例：

public class BitOperator{
	public static void main(String[] args){
		int a = 8;
		
		//a的二进制：24个零 0000 1000
		//a<<2
		//24个零 0010 0000
		System.out.println(a << 2);
		
		//a的二进制：24个零 0000 1000
		//a>>2
		//24个零 000000 10
		System.out.println(a >> 2);
		
		int b = -8;
		//b的二进制：
		//原码 1 23个0 0000 1000
		//反码：1 23个1 1111 0111
		//补码：1 23个1 1111 1000
		//左移b<<2，右边补0
		//1 23个1 1110 0000 补码
		//反码：1 23个1 1101 1111
		//原码：1 23个0 0010 0000  -32
		System.out.println(b << 2);
		
		//b的二进制：
		//原码 1 23个0 0000 1000
		//反码：1 23个1 1111 0111
		//补码：1 23个1 1111 1000
		//右移：b>>2，左边补什么，看最高位，
		//补码：1 23个1 111111 10
		//反码：1 23个1 111111 01
		//原码：1 23个0 0000 0010  -2
		System.out.println(b >> 2);
			//无符号右移
		//b的二进制：
		//原码 1 23个0 0000 1000
		//反码：1 23个1 1111 0111
		//补码：1 23个1 1111 1000
		//无符号右移：b >>> 2,不看最高位，左边直接补0
		//00 1 23个1 1111 10
		System.out.println(b >>> 2);
		
		System.out.println("-----------------------------");
		//a的二进制：24个零 0000 1000
		//b的二进制：
		//原码 1 23个0 0000 1000
		//反码：1 23个1 1111 0111
		//补码：1 23个1 1111 1000
		//24个零 0000 1000 & 1 23个1 1111 1000 
		//24个零 0000 1000 -》 8
		System.out.println(a & b);
		
		//24个零 0000 1000 | 1 23个1 1111 1000 
		//1 23个1 1111 1000 ->-8
		System.out.println(a | b);
		
		//24个零 0000 1000 | 1 23个1 1111 1000 
		//24个1 1111 0000补码
		//反码：24个1 1110 1111 
		//原码：1 23个0 0001 0000 -》 -16
		System.out.println(a ^ b);
		
		//a的二进制：24个零 0000 1000
		//~a
		//24个1 1111 0111补码
		//反码：24个1 1111 0110
		//原码：1 23个0 0000 1001
		System.out.println(~a);
	}
}

流程控制语句结构

流程控制语句结构：

顺序结构：从上到下，顺序执行

分支结构：根据选择不同，执行不同的代码。if…else和switch…case

循环结构：根据条件循环重复执行某段代码。for（普通for和增强for）、while和do…while三种

一、顺序结构

（在同一个方法中）从上往下执行

流程控制语句结构：
1、顺序：（在同一个方法中）从上往下执行
从键盘输入一个值，并打印输出
2、分支
3、循环

用核心类库中的类：String,System,Math,Scanner等
如果这个类型定义在java.lang包下，那么直接使用，无需导包，直接使用简名称
但是如果这个类型定义在其他包下，那么需要写全名称或导包
全名称：java.util.Scanner

导包语句：
格式：import 包.类名;
位置：必须在源文件的上面，在class的上面
import java.util.Scanner;

class TestStatement{
	public static void main(String[] args){
		System.out.println("欢迎使用尚硅谷登记系统：");
		System.out.println("请输入个人信息：");
		
		//System.out.println(Math.pow(2,3));
		
		//Scanner键盘输入的工具类
		//input是一个变量名，自己命名
		//方式一：全名称
		//java.util.Scanner input = new java.util.Scanner(System.in);
		
		//方式二：导包，简名称
		Scanner input = new Scanner(System.in);
		
		System.out.print("请输入年龄：");		
		int age = input.nextInt();		
		System.out.println("您的年龄是：" + age);
		
		System.out.print("请输入入学成绩：");		
		double score = input.nextDouble();	
	System.out.println("您的分数是：" + score);
		
		System.out.print("请告知我是否帅/美：");		
		boolean	flag = input.nextBoolean();		
		System.out.println("帅/美否：" + flag);
		
		System.out.print("请输入您的姓名：");
		String name =  input.next();
		System.out.println("您的名字是："+name);
	}
}

二、复合语句：

与C语言及其他语言相同，Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“{”开始，闭括号“}”结束。

复合语句中的每一语句都是从上到下执行。复合语句以整个块为单位，并且在复合语句中可以嵌套复合语句。

Java代码结构：

class 类{

{

//代码块

}

方法签名{

//方法体

}

内部类{

内部类体

}

}

复合语句为变量创建了一个作用域。在该作用域中某个变量被创建并能够使用，如果在某个变量的作用域外使用该变量，则会发生错误。

三、分支结构

1、条件语句

1、if单分支语句

语法格式：

if(条件表达式){

//当条件表达式结果为true时，需要执行的语句块

}

说明：

1. 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量。

2. 语句块只有一个语句时，{}可以省略，但是建议保留

执行过程：

条件成立就执行，条件不成立就不执行。

2、if…else双分支条件语句

语法格式：

if(条件表达式){

//当条件表达式结果为true时，需要执行的语句块1

}else{

//当条件表达式结果为false时，需要执行的语句块2

}

执行过程：

当条件成立执行语句块1，不成立执行语句块2

说明：

（1）条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量。

（2）if或else的语句块只有一个语句时，{}可以省略，但是建议保留

3、if…else if多分支条件语句

语法结构：

if(条件表达式1){

//当条件表达式1结果为true时，需要执行的复合语句1

}else if(条件表达式2){

//当条件表达式2结果为true时，需要执行的复合语句2

}

…

【else{

//当上述条件表达式结果都为false时，需要执行的语句

}】

执行过程：

从上至下判断条件，如果一旦某个条件成立了，就执行对应的语句块，后面的条件就不看了，如果所有条件都不满足，如果存在else，那么执行else，如果不存在else，就什么也不执行。

注意：

（1）每个if或者else后面的{}不是必须的，但是如果没有{}，默认只能带一条语句。即if或else后面的语句块只有一条语句时，可以省略{}，但是可读性不够好。

（2）最后的else不是必须的，可以缺省

（3）当多个条件是互斥关系时，顺序无所谓

当多个条件是包含关系时，“小上大下/子上父下”

public static void main(String[] args) {
		int score = 89;
		if(score>90){
			System.out.println("优秀");
		}else if(score>80){
			System.out.println("良好");
		}else if(score>60){
			System.out.println("及格");
		}else{
			System.out.println("不合格");
		}
	}

public static void main(String[] args) {
		int score = 89;
		if(score>90 && score<=100){
			System.out.println("优秀");
		}else if(score>80 && score<=90){
			System.out.println("良好");
		}else if(score>60 && score<=80){
			System.out.println("及格");
		}else{
			System.out.println("不合格");
		}
	}

4、嵌套

if…else系列语句可以嵌套，在任意一个语句块中都可以再嵌套其他的条件语句。

执行特点：

当外层条件满足时，内层条件才判断

2、选择结构

语法结构：

switch(表达式){

case 常量值1：

//执行语句块1

[break;]

case 常量值2：

//执行语句块2

[break;]

…

case 常量值n：

//执行语句块n

[break;]

【default：

//执行缺省语句

[break;]

】

}

注意：

1. 表达式返回的结果类型只能是byte，short，char，int，枚举（JDK1.5之后），String（JDK1.7之后）

2. 表达式返回的结果的类型需要与case后的值的类型保持一致

3. case后面只能跟常量值，不能是变量值或不确定的表达式值

4. 同一个switch语句，case的常量值必须互不相同

5. break是可选的，当表达式返回结果与某个case后的值进行匹配成功后，执行相应分支的语句，一旦进入某个分支后，只有直到遇到break才会退出switch，否则将会继续执行下一个case的语句。

6. default是可选的。位置也不一定是最后，也可以在任意case的位置。但是不管再哪里，都是要所有case的常量值不匹配后才会进入default分支，一旦进入default分支，也是需要遇到break或switch的闭括号“}”才会停止。

总结：switch的入口，表达式值与某个case匹配，或都不匹配，从default进入。

switch的出口，遇到break或者switch的闭括号“}”结束

3、条件判断与选择结构的选择

当条件判断是等值判断，并且表达式的结果是byte,short,char,int,枚举,String类型的时候，用switch会更合适，

其他都使用条件判断

可以使用switch…case的，肯定可以使用if…else，返回来不一定。

循环语句for

for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。for循环语句的语法格式如下：

for（初始化表达式; 循环条件; 操作表达式）{

执行语句

………

}

在上面的语法结构中，for关键字后面()中包括了三部分内容：初始化表达式、循环条件和操作表达式，它们之间用“;”分隔，{}中的执行语句为循环体。

接下来分别用①表示初始化表达式、②表示循环条件、③表示操作表达式、④表示循环体，通过序号来具体分析for循环的执行流程。具体如下：

for（① ; ② ; ③）{

④

}

第一步，执行①

第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步

第三步，执行④

第四步，执行③，然后重复执行第二步

第五步，退出循环

接下来通过一个案例对自然数1~4进行求和，如下所示。

public class ForDemo01 {
	public static void main(String[] args) {
		int sum = 0; // 定义变量sum，用于记住累加的和
		for (int i = 1; i <= 4; i++) { // i的值会在1~4之间变化
			sum += i; // 实现sum与i的累加
		}
		System.out.println("sum = " + sum); // 打印累加的和
	}
}

运行结果如下图所示。

上述代码中，变量i的初始值为1，在判断条件i<=4为true的情况下，会执行循环体sum+=i，执行完毕后，会执行操作表达式i++，i的值变为2，然后继续进行条件判断，开始下一次循环，直到i=5时，条件i<=4为false，结束循环，执行for循环后面的代码，打印“sum=10”。

为了让初学者能熟悉整个for循环的执行过程，现将上述代码运行期间每次循环中变量sum和i的值通过表2-11罗列出来。

1. sum和i循环中的值

循环次数	sum	i
第一次	1	1
第二次	3	2
第三次	6	3
第四次	10	4