重拾Java基础 2021-12-03 第一天打卡

createh51个月前 (02-01)技术教程18

毕业到工作这么多年以来,断断续续的也有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)为真。

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

位运算符

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

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

逻辑运算符

&&称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。(A && B)为假。

| |称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。(A | | B)为真。

!称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。!(A && B)为真。

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

赋值运算符

=简单的赋值运算符,将右操作数的值赋给左侧操作数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

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

条件运算符(?:)

条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

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 运算符

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

( Object reference variable ) instanceof (class/interface type)

public class Test {

   public static void main(String[] args){

      String name = "James";

      boolean result = name instanceof String; // 由于 name 是 String 类型,所以返回真

   }

}
// 执行结果
true

Java运算符优先级

当多个运算符出现在一个表达式中,谁先谁后呢?这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中,运算符优先级不同会导致最后得出的结果差别甚大。

例如,(1+3)+(3+2)*2,这个表达式如果按加号最优先计算,答案就是 18,如果按照乘号最优先,答案则是 14。

再如,x = 7 + 3 * 2;这里x得到13,而不是20,因为乘法运算符比加法运算符有较高的优先级,所以先计算3 * 2得到6,然后再加7。

后缀() [] . (点操作符)左到右

一元expr++ expr--从左到右

一元++expr --expr + - ~ !从右到左

乘性 * /%左到右

加性 + -左到右

移位 >> >>> << 左到右

关系 > >= < <= 左到右

相等 == !=左到右

按位与&左到右

按位异或^左到右

按位或|左到右

逻辑与&&左到右

逻辑或| |左到右

条件?:从右到左

赋值= + = - = * = / =%= >> = << =&= ^ = | =从右到左

逗号,左到右

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 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 语句有如下规则:

- 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,判断是否继续输出,或是跳出判断。

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);

   }

}
良好

你的等级是 C

如果 case 语句块中没有 break 语句时,JVM 并不会顺序输出每一个 case 对应的返回值,而是继续匹配,匹配不成功则返回默认 case。

public 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");

      }

   }

}
default

如果 case 语句块中没有 break 语句时,匹配成功后,从当前 case 开始,后续所有 case 的值都会输出。

public 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

default

如果当前匹配成功的 case 语句块没有 break 语句,则从当前 case 开始,后续所有 case 的值都会输出,如果后续的 case 语句块有 break 语句则会跳出判断。

public 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

3

Java 循环结构 - for, while 及 do...while

顺序结构的程序语句只能被执行一次。

如果您想要同样的操作执行多次,就需要使用循环结构。

Java中有三种主要的循环结构:

while 循环

do…while 循环

for 循环

#### while 循环

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

5

do…while 循环

对于 while 语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。

do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次。

do {

//代码语句

}while(布尔表达式);

注意:布尔表达式在循环体的后面,所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true,则语句块一直执行,直到布尔表达式的值为 false。

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循环

虽然所有循环结构都可以用 while 或者 do...while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下:

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 0

关于 for 循环有以下几点说明:

- 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。

- 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。

- 执行一次循环后,更新循环控制变量。

- 再次检测布尔表达式。循环执行上面的过程。

break 关键字

break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块。

break 跳出最里层的循环,并且继续执行该循环下面的语句。

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 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中,continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。

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

50

for循环嵌套

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


今天的复习到此结束,熟悉了基础语法,条件控制语句,循环语句,接下来的文章将从数组开始复习,数组结合for循环去复习!加油!

相关文章

给32位系统装8g内存条能用吗?为什么?

关于32位和64位,这个概念一直让人比较懵。在买电脑的时候,我们看到过32位和64位CPU。下软件的时候,我们也看到过32位或64位的软件。就连装虚拟机的时候,我们也看过32位和64位的系统。在写代码...

JDK安装、Eclipse安装及运行环境配置

1、eclipse下载打开地址:http://www.eclipse.org/downloads/;根据自己机器的操作系统,页面上显示适应机器操作系统的Eclipse下载列表,也可以点击下图所示位置切...

JDK 17 - Java 17 的新特性速览(jdk17 lts)

JDK 17 于 8 月 5 日进入候选发布阶段,最终候选版本将于 8 月 19 日发布。所有功能/JEP 集都被冻结以进行目标发布。有 10 个新功能 + 2 个功能删除 + 2 个功能弃用,还有...

java采用int32作为hashcode,会不会出现更高的碰撞概率?

在Java中,hashCode方法通常返回一个int类型的值,其范围是从-2^31到2^31-1的整数。尽管这个范围实际上可以容纳2^31个不同的哈希值,但在日常讨论和某些上下文中,可能会将其简化为"...

我的世界内存错误提示怎么办如何修改

我的世界是一款沙盒游戏,所呈现的世界并不是华丽的画面与特效,而是注重在游戏性上面。在游戏中,常常有玩家反映,经常提示内存错误,怎么办?有的玩家估计是自己装的是32位的Java,尝试将最大内存调节到小于...

32位已死,对安卓和苹果意味着什么?

Arm宣布,从2023年起,其所有新智能手机CPU内核都将仅为64位,且没有32位兼容模式。2013年,苹果就在iPhone 5s中使用了64位A7处理器,我们开始拥有支持64位的智能手机处理器。不久...