重拾Java基础 2021-12-03 第一天打卡
毕业到工作这么多年以来，断断续续的也有9年的时间了，之间做过Java开发，也做过测试工作，从事测试工作后，很少去关注开发的知识与技术，最近思考了下，觉得自己把最有优势的生存技能丢了，准备打卡重拾自己的优势，如果你也与我一样，请你认真思考下自己目前的状态，放下手机，放弃游戏，做一些我们应该做的事情，如果你是刚刚接触这一行，那么我们一起努力！
言归正传！
Java
Java是什么？
Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的高级程序设计语言。
后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。
Java 可以运行于多个平台上，比如 Windows, Mac OS 及其他多种 UNIX 版本的系统。
这是官方解释，言简意赅的说：Java 是编程语言，可以开发Web程序，安卓程序，可以跨平台运行。
什么是跨平台？
跨平台可以说是跨操作系统，如Windows, Mac OS 及其他多种 UNIX 版本的系统。
Java 体系
Java分为三个体系：
- JavaSE(J2SE) (Java2 Platform Standard Edition，java平台标准版）
- JavaEE(J2EE) (Java 2 Platform,Enterprise Edition，java平台企业版)
- JavaME(J2ME) (Java 2 Platform Micro Edition，java平台微型版)。
主要特性
因为是一些解释，就直接复制了，最初的时候以为都是一些废话，现在觉得还是有必要仔细地读下的，因为确实如此。
Java 语言是简单的：
Java 语言的语法与 C 语言和 C++ 语言很接近，使得大多数程序员很容易学习和使用。另一方面，Java 丢弃了 C++ 中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java 语言不是使用指针，而是引用。并提供了自动分配和回收的内存空间，使得程序员不必为内存管理而担忧。
Java 语言是面向对象的：
Java 语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements）。Java 语言全面支持动态绑定，而且 C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
Java语言是分布式的：
Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。
Java 语言是健壮的：
Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证。对指针的丢弃是 Java 的明智选择。Java 的安全检查机制使得 Java 更具健壮性。
Java语言是安全的：
Java通常被用在网络环境中，为此，Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外，Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵。
Java 语言是体系结构中立的：
Java 程序（后缀为 java 的文件）在 Java 平台上被编译为体系结构中立的字节码格式（后缀为 class 的文件），然后可以在实现这个 Java 平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
Java 语言是可移植的：
这种可移植性来源于体系结构中立性，另外，Java 还严格规定了各个基本数据类型的长度。Java 系统本身也具有很强的可移植性，Java 编译器使用 Java 实现的，Java 的运行环境使用 ANSI C 实现的。
Java 语言是解释型的：
如前所述，Java 程序在 Java 平台上被编译为字节码格式，然后可以在实现这个 Java 平台的任何系统中运行。在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
Java 是高性能的：
与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++。
Java 语言是多线程的：
在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有**两种方法来创建线程：其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。
注：线程这块很重要，特别是多线程
Java 语言是动态的：
Java 语言的设计目标之一是适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
发展史就不介绍了，1995 年 5 月 23 日，Java 语言诞生，1996 年 1 月，第一个 JDK-JDK1.0 诞生，现在已经JDK 17 了，但是大部分用的都是jdk1.8的，国内应该没有高于这个版本的吧！孤陋寡闻没有听说！
既然说到JDK了，那接下来也确实该介绍JDK了，哈哈哈！
Java 开发工具
JDK这是Java Development Kit 缩写。
中国被称为Java开发套件。
由SUN该公司提供。这是Java应用程序开发提供了编译和执行环境，所有的Java写程序都依赖于它。
JDK将Java程序编写为字节码文件，就是将.Java文件编译为 .class文件。
JDK 其实就开发工具包，我们要写程序就必须要有安装的。
JRE 就是程序运行的环境。
JVM 虚拟机
三者的关系：JDK 包含 JRE，JRE 包含 JVM。
Java的核心优势是跨平台，由JVM虚拟机实现的，不同的系统安装对应版本的JDK就可以了，因为JDK包含了JRE和JVM。
Java的执行过程：
JDK安装
首先去官网下载对应系统版本的JDK。
下载地址：
https://www.oracle.com/java/technologies/downloads/#java8
下载之后安装尽量别选择C盘，如果你只有一个盘而且是固态硬盘的话没有问题。
安装完成之后需要进行环境变量的配置：
windows的环境配置：
右击“此电脑”--》属性--》高级系统设置==》环境变量==》系统变量下点创建
我是这么配置的，别人不知道。
win+r 输入cmd
正常显示java version "版本"，就可以正常使用了。
那就编写一个第一个Java程序吧！HelloWord 哈哈哈！强大的HelloWord!
桌面新建HelloWord.java文件代码如下：
public class HelloWord{
public static void main(String[] args){
// 这是输出语句，输出HelloWord！
System.out.println("HelloWord!");
}
}win+r ==》cmd进入 javac HelloWord.java
这时候你会发现桌面多出一个HelloWord.class文件
之后再执行java HelloWord 命令行就会输出 HelloWord！，就是System.out.println("HelloWord!");括号里的。
这样验证我们的jdk安装就没问题了，而且还写了强大的HelloWord。
编写代码可以用文件这么编写，但是有错误不容易发现，但是锻炼代码基础，之前有人跟我这么说的，但是有方便的可视化工具为什么不用呢？用IDE写多了也是一样的，而且代码敲错了还有提示，效率才是最重要的！
IDE：eclipse、IDEA，推荐用IDEA
IDEA是付费的，当然有破解版本，需要去找，找不到那就eclipse吧！
怎么下载安装，怎么用就去网上查去吧！就不多介绍了！
好了，也安装好了那么久，开始基础语法学习了！
Java基础语法
类：类是一个模板，它描述一类对象的行为和状态
代码：public class 类名(文件名) {} 要写的程序在花括号中
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
代码：public static void main(String[] args){} 这是main方法，也是所有程序的入口，括号中的是参数，后面详细介绍。
System.out.println("Hello World"); // 输出 Hello World，System.out.println();输出语句，先这么记就行。
public：访问修饰符
static：关键字
void：返回类型（void就是没有返回值）
main：方法名
String：类名（很重要的一个类，String是字符串类）
[]:代表数组，String[] 字符数组
args：数组名称，这里也是参数名称。
基础语法：
编写 Java 程序时，应注意以下几点：
- 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
- 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
- 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。也叫驼峰命名法。
- 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
- 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
Java 标识符
- Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关于 Java 标识符，有以下几点需要注意：
- 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（ $）、或者下划线（_）开始
- 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
- 关键字不能用作标识符
- 标识符是大小写敏感的
- 合法标识符举例：age、$salary、_value、__1_value
- 非法标识符举例：123abc、-salary
注意：其实就是不能以字母和下划线开头，但是以$、_、开头的也基本没有人这么定义，都是写的英文字母。
Java修饰符
像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized
在后面的章节中我们会深入讨论 Java 修饰符。
Java 变量
Java 中主要有如下几种类型的变量
局部变量
类变量（静态变量）
成员变量（非静态变量）
Java 关键字
访问控制：
private 私有的
protected 受保护的
public 公共的
default 默认
类、方法和变量修饰符：
abstract声明抽象
class类
extends扩充,继承
final最终值,不可改变的
implements实现（接口）
interface接口
native本地，原生方法（非 Java 实现）
new新,创建
static静态
strictfp严格,精准
synchronized线程,同步
transient短暂
volatile易失
程序控制语句：
break跳出循环
case定义一个值以供 switch 选择
continue继续
default默认
do运行
else否则
for循环
if如果
instanceof实例
return返回
switch根据值选择执行
while循环
错误处理：
assert断言表达式是否为真
catch捕捉异常
finally有没有异常都执行
throw抛出一个异常对象
throws声明一个异常可能被抛出
try捕获异常
包相关：
import 引入
package 包
基本类型：
boolean布尔型
byte字节型
char字符型
double双精度浮点
float单精度浮点
int整型
long长整型
short短整型
变量引用：
super父类,超类
this本类
void无返回值
保留关键字：
goto是关键字，但不能使用
const是关键字，但不能使用
注：上面的关键字先大致了解下就行了，编码时间长了就记住了。
Java 基本数据类型
变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
1、boolean：布尔型：默认值是 false；
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
例子：boolean one = true。
2、char：字符类型
char 类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（十进制等效值为 0）；
最大值是 \uffff（即为 65535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';。
3、byte：位
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。
4、short：短整型
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。
5、int：整数
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。
6、long：长整型
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
7、float：单精度
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
8、double(双精度)：
double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
浮点数的默认类型为 double 类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
Java变量
在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：
type identifier [ = value][, identifier [= value] ...] ;
例如： byte b = -128;
格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。
int a,b,c; // 声明三个整数没有初始化值
int a = 1,b = 2 ,c=3; // 声明三个整数并赋予初值
byte b = -128; // 声明一个byte类型并赋予初值
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。public class PrintStudy {
public static void main(String[] args) {
// byte
byte b = -128;
System.out.println(b);
// short
short s = 5555;
System.out.println(s);
// int
int i = 100000;
System.out.println(i);
// long
long l = 99999999;
System.out.println(l);
// float
float f = 3.4028f;
System.out.println(f);
// double
double d = 3.1415926;
System.out.println(d);
// char 注意char类型赋值只能用单引号，双引号是字符串
char c = 'C';
System.out.println(c);
// boolean 只有两个值ture和false 真和假
boolean boo = true;
System.out.println(boo);
}
}-128
5555
100000
99999999
3.4028
3.1415926
C
true
Process finished with exit code 0记住变量怎么定义，怎么赋值，赋值的范围就行了，没必要过多介绍！
Java 运算符
- 算术运算符
+加法 - 相加运算符两侧的值A + B 等于 30
-减法 - 左操作数减去右操作数A – B 等于 -10
*乘法 - 相乘操作符两侧的值A * B等于200
/除法 - 左操作数除以右操作数B / A等于2
％取余 - 左操作数除以右操作数的余数B%A等于0
++自增: 操作数的值增加1B++ 或 ++B 等于 21（区别详见下文）
--自减: 操作数的值减少1B-- 或 --B 等于 19（区别详见下文）
public class PrintStudy {
public static void main(String[] args) {
int a = 3,b = 2;
// 加法运算
System.out.println(a+b);
// 减法运算
System.out.println(a-b);
// 乘法运算
System.out.println(a*b);
// 除法运算
System.out.println(a/b);
// 取余
System.out.println(a%b);
// ++ 自增
System.out.println("后++" + a++); // 打印后加+1， 3+1=4 a就变成 a = 4；
System.out.println("先++" + ++a);// 先加1后打印，1+4 = 5 a就变成了5了
// -- 自减
System.out.println("后--" + a--); // 先打印后运算的所以打印后 a= 5-1 a = 4
System.out.println("先--" + --a); // 先自减后打印， 4-1 = 3 a = 3；
}
}5
1
6
1
1
后++3
先++5
后--5
先--3
Process finished with exit code 0关系运算符
==检查如果两个操作数的值是否相等，如果相等则条件为真。（A == B）为假。
!=检查如果两个操作数的值是否相等，如果值不相等则条件为真。(A != B) 为真。
> 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。（A> B）为假。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。（A >=检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。（A> = B）为假。 <=检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。（A <= B）为真。 Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。 位运算符作用在所有的位上，并且按位运算。 ＆如果相对应位都是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 &&称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。（A && B）为假。 | |称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。（A | | B）为真。 ！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。！（A && B）为真。 =简单的赋值运算符，将右操作数的值赋给左侧操作数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 条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。 该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。 ( Object reference variable ) instanceof (class/interface type) 当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。 例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。 再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。 后缀() [] . (点操作符)左到右 一元expr++ expr--从左到右 一元++expr --expr + - ～ ！从右到左 乘性 * /％左到右 加性 + -左到右 移位 >> >>> << 左到右 关系 > >= < <= 左到右 相等 == !=左到右 按位与＆左到右 按位异或^左到右 按位或|左到右 逻辑与&&左到右 逻辑或| |左到右 条件？：从右到左 赋值= + = - = * = / =％= >> = << =＆= ^ = | =从右到左 逗号，左到右 switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。 - switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。 - switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。 - case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。 - 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。 - 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。 - switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。 switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。 如果 case 语句块中没有 break 语句时，JVM 并不会顺序输出每一个 case 对应的返回值，而是继续匹配，匹配不成功则返回默认 case。 如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出。 如果当前匹配成功的 case 语句块没有 break 语句，则从当前 case 开始，后续所有 case 的值都会输出，如果后续的 case 语句块有 break 语句则会跳出判断。 顺序结构的程序语句只能被执行一次。 如果您想要同样的操作执行多次，就需要使用循环结构。 Java中有三种主要的循环结构： while 循环 do…while 循环 for 循环 #### while 循环 while( 布尔表达式 ) { //循环内容 } 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。 do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。 do { //代码语句 }while(布尔表达式); 注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。 虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。 for循环执行的次数是在执行前就确定的。语法格式如下： for(初始化; 布尔表达式; 更新) { //代码语句 } 关于 for 循环有以下几点说明： - 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。 - 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。 - 执行一次循环后，更新循环控制变量。 - 再次检测布尔表达式。循环执行上面的过程。 break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。 break 跳出最里层的循环，并且继续执行该循环下面的语句。 continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。 在 for 循环中，continue 语句使程序立即跳转到更新语句。 在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。 今天的复习到此结束，熟悉了基础语法，条件控制语句，循环语句，接下来的文章将从数组开始复习，数组结合for循环去复习！加油！public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
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) );
}
}a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false位运算符
public class Test {
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 );
}
}a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15 逻辑运算符
public class Test {
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));
}
}
a && b = false
a || b = true
!(a && b) = true 赋值运算符
public class Test {
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 );
}
}c = a + b = 30
c += a = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10条件运算符（?:）
public class Test {
public static void main(String[] args){
int a , b;
a = 10;
// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;
System.out.println( "Value of b is : " + b );
// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
b = (a == 10) ? 20 : 30;
System.out.println( "Value of b is : " + b );
}
}
Value of b is : 30
Value of b is : 20
instanceof 运算符
public class Test {
public static void main(String[] args){
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
}
}
// 执行结果
trueJava运算符优先级
Java 条件语句
if...else
public class Test {
public static void main(String args[]){
int x = 30;
if( x < 20 ){
System.out.print("这是 if 语句");
}else{
System.out.print("这是 else 语句");
}
}
}if...else if...else 语句
/*
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
*/
public class Test {
public static void main(String args[]){
int x = 30;
if( x == 10 ){
System.out.print("Value of X is 10");
}else if( x == 20 ){
System.out.print("Value of X is 20");
}else if( x == 30 ){
System.out.print("Value of X is 30");
}else{
System.out.print("这是 else 语句");
}
}
}嵌套的 if…else 语句
/**
if(布尔表达式 1){
////如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
////如果布尔表达式 2的值为true执行代码
}
}
*/
public class Test {
public static void main(String args[]){
int x = 30;
int y = 10;
if( x == 30 ){
if( y == 10 ){
System.out.print("X = 30 and Y = 10");
}
}
}
}Java switch case 语句
/**
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
*/
public class PrintStudy {
public static void main(String[] args) {
int a = 3,b = 2;
switch(a){
case 3 :
System.out.println("a等于3");
break; //可选
case 4 :
System.out.println("a等于4");
break; //可选
//你可以有任意数量的case语句
default :
System.out.println("没有匹配的值 a = " + a);
}
}
}
// 执行结果
a等于3
Process finished with exit code 0 witch case 语句有如下规则：
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("优秀");
break;
case 'B' :
case 'C' :
System.out.println("良好");
break;
case 'D' :
System.out.println("及格");
break;
case 'F' :
System.out.println("你需要再努力努力");
break;
default :
System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);
}
}良好
你的等级是 Cpublic class Test {
public static void main(String args[]){
int i = 5;
switch(i){
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
default:
System.out.println("default");
}
}
}defaultpublic class Test {
public static void main(String args[]){
int i = 1;
switch(i){
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
default:
System.out.println("default");
}
}
}1
2
defaultpublic class Test {
public static void main(String args[]){
int i = 1;
switch(i){
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
case 3:
System.out.println("3"); break;
default:
System.out.println("default");
}
}
}1
2
3Java 循环结构 - for, while 及 do...while
public class PrintStudy {
public static void main(String[] args) {
int a = 0;
while(a <=5){
System.out.println(a);
a++;
}
}
}0
1
2
3
4
5do…while 循环
public class PrintStudy {
public static void main(String[] args) {
int a = 0;
do {
System.out.println(a);
a++;
}
while(a <=5);
}
}0
1
2
3
4
5 for循环
public class PrintStudy {
public static void main(String[] args) {
int a = 5;
for (int i =0;i<=a; i++){
System.out.print(i + "\t");
}
}
}0 1 2 3 4 5
Process finished with exit code 0break 关键字
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
// x 等于 30 时跳出循环
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}10
20 continue 关键字
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}10
20
40
50for循环嵌套
public class PrintStudy {
public static void main(String[] args) {
// 打印九九乘法表
for (int i = 1; i<10; i++){
for (int j = 1; j<=i;j++){
// \t是转义字符 制表符 \n是回车，换行， + 表示拼接
System.out.print(j + "*" + i + "= " + j * i + "\t");
}
System.out.println();
}
}
}1*1= 1
1*2= 2 2*2= 4
1*3= 3 2*3= 6 3*3= 9
1*4= 4 2*4= 8 3*4= 12 4*4= 16
1*5= 5 2*5= 10 3*5= 15 4*5= 20 5*5= 25
1*6= 6 2*6= 12 3*6= 18 4*6= 24 5*6= 30 6*6= 36
1*7= 7 2*7= 14 3*7= 21 4*7= 28 5*7= 35 6*7= 42 7*7= 49
1*8= 8 2*8= 16 3*8= 24 4*8= 32 5*8= 40 6*8= 48 7*8= 56 8*8= 64
1*9= 9 2*9= 18 3*9= 27 4*9= 36 5*9= 45 6*9= 54 7*9= 63 8*9= 72 9*9= 81