第一节：基础语法

1. 基础知识

1.1 命名限制

编写Java程序时，应注意以下几点：

变量名：Java是大小写敏感的
类名：使用驼峰命名，即每个单词首字母大写
方法名：以小写字母开头，若含有多个单词，则后面的每个单词首字母大写
源文件名：源文件名必须和类名相同
主方法入口：所有的Java 程序由main方法开始执行

1.2 命名规则

所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的

1.3 `Java`修饰符

Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, strictfp

默认访问修饰符 - 无关键字

默认访问修饰是指没有为类，字段，方法等显式声明访问修饰符，可用于同一包中的任何其他类
接口中的字段隐式为public static final，接口中的方法默认为public

class Order{
    String version = "1.0.1";

    boolean processOrder() {
       return true;
    }
}

私有访问修饰符 - private

声明为private的方法，变量和构造函数只能在声明的类本身中访问
类和接口不能声明为：private
如果类中存在公共getter方法，则可以在类中将变量声明为private

public class Logger {
   private String format;

   public String getFormat() {
      return this.format;
   }

   public void setFormat(String format) {
      this.format = format;
   }
}

公共访问修饰符 - public

可以从任何其他类访问使用public声明的类，方法，构造函数，接口等
如果尝试访问的公共类位于不同的包中，则仍需要导入公共类

受保护的访问修饰符 - protected

在超类中声明受保护的变量，方法和构造函数只能由其他包中的子类或受保护成员类的包中的任何类访问
受保护的访问修饰符不能应用于类和接口

访问控制和继承

在超类中声明为public的方法也必须在所有子类中都是public
在超类中声明为protected的方法必须在子类中也要声明为：protected或public; 不能声明为：private
声明为private的方法根本不能被继承，因此没有规则

1.4 `Java` 注释

快捷键：

使用Ctrl+/快捷键
使用Ctrl+Shift+/快捷键，注释选中的代码

public class day1A {
	/* 这是第一个Java程序
	*它将打印Hello World
	* 这是一个多行注释的示例
	*/
	public static void main(String[] args) {
		// 这是单行注释的示例
		/* 这个也是单行注释的示例 */
		System.out.println("hello world");
		
	}
}

2. 变量,常量

2.1 `Java` 变量

变量三元素：变量类型，变量名，变量值

type identifier [ = value][, identifier [= value] ...] ;

变量类型

Java中主要有如下几种类型的变量

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

public class Variable{
	static int allClicks=0; // 类变量
	String str="hello world"; // 实例变量
	public void method(){
		int i =0; // 局部变量
	}
}

变量值

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "zyiz"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'

2.2 `Java` 常量

常量在程序运行时是不能被修改的，通常使用大写字母表示常量

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

3. 数据类型

3.1 基本数据类型

byte 字节型

byte 数据类型是8位、有符号的，以二进制补码表示的整数
最小值是 -128（-2^7），最大值是 127（2^7-1），默认值是 0

private void Fun() {
    byte a = 100;
    byte b = -50;
}

short 短整型

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15），最大值是 32767（2^15 - 1），默认值是 0

private void Fun() {
    short s = 1000;
    short r = -20000;
}

int 整型

int 数据类型是32位、有符号的以二进制补码表示的整数
最小值是 -2,147,483,648（-2^31），最大值是 2,147,483,647（2^31 - 1），默认值是 0

private void Fun() {
    int s = 1000;
    int r = -20000;
}

long 长整型

long 数据类型是 64 位、有符号的以二进制补码表示的整数
最小值是 -9,223,372,036,854,775,808（-2^63），最大值是 9,223,372,036,854,775,807（2^63 -1），默认值是 0L

private void Fun() {
    long a = 100000L;
    Long b = -200000L;
}

float 单精度浮点数

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数
后缀加大写（F）或小写（f）默认值是 0.0f

private void Fun() {
    float f1 = 233.4f;
    float f2 = 235.35F;
}

double 双精度浮点数

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数
浮点数的默认类型为double类型，默认值是 0.0d

private void Fun() {
    double f1 = 233.4d;
    double f2 = 235.35D;
}

boolean 布尔类型

boolean数据类型表示一位的信息
只有两个取值：true 和 false，默认值是 false

private void Fun(){
    boolean one = true;
    boolean two = false;
}

char 字符型

char类型是一个单一的 16 位 Unicode 字符，可以存储任何字符
最小值是 \u0000（即为0），最大值是 \uffff（即为65,535）

private void Fun() {
    char c1 = 'a';
    char c2 = '0';
    char c3 = 54;
}

3.2 类型转换

转换说明

不能对boolean类型进行类型转换
不能把对象类型转换成不相关类的对象
在把容量大的类型转换为容量小的类型时必须使用强制类型转换
转换过程中可能导致溢出或损失精度
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

自动类型转换/隐式类型转换

前提：必须满足转换前的数据类型的位数要低于转换后的数据类型

强制类型转换

前提：转换的数据类型必须是兼容的

格式：(type)value，type是要强制类型转换后的数据类型

private void Fun() {
    int i1 = 123;
    byte b = (byte) i1;
    System.out.println("int强制类型转换为byte后的值等于" + b);
}

4. 运算符

4.1 算术运算符

假设整数变量A的值为10，变量B的值为20

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取模 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
--	自减: 操作数的值减少1	B-- 或 --B 等于 19

除法

分子分母都是整数时，结果为整除的结果（结果不保留小数）

System.out.println(5 / 2);	/* 2 */

分子或分母有为浮点数时，结果为浮点数（结果保留小数）

System.out.println(5 / 2.0);	/* 2.5 */
System.out.println(5.0 / 2);	/* 2.5 */

自增/自減符號在前在后的区别

在后：使用后自增，先进行表达式运算，再进行自增或者自减运算
在前：使用前自增，先进行自增或者自减运算，再进行表达式运算

4.2 关系运算符

整数变量A的值为10，变量B的值为20

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真	（A == B）为假(非真)
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真	（A != B）为真
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真	（A > B）非真
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真	（A < B）为真
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真	（A >= B）为假
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真	（A <= B）为真

字符比较

字符之间比较的是字符的ASCII值

System.out.println('A' > 'B');	/* false */

4.3 赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将A+B的值赋给C
+ =	加和赋值操作符，将左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，将左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，将左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，将左操作数和右操作数相除赋值给左操作数	C / = A等价于C = C / A
（％）=	取模和赋值操作符，将左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A

4.4 逻辑运算符

假设布尔变量A为真，变量B为假

操作符	描述	例子
&&	与运算，当且仅当两个操作数都为真，条件才为真	（A && B）为假
\| \|	或运算，如果任何两个操作数任何一个为真，条件为真	（A \| \| B）为真
！	非运算，用来反转操作数的逻辑状态	！（A && B）为真

4.5 条件运算符

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

variable x = (expression) ? value if true : value if false

int result = 1 > 2 ? 1 : 2;

4.6 其他运算符

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

如果运算符左侧变量所指的对象，是操作符右侧类或接口的一个对象，那么结果为真，如果被比较的对象兼容于右侧类型,该运算符仍然返回真

简单类型

String str = "李白";
boolean result = str instanceof String;
System.out.println(result);	/* true */

继承类型

class Vehicle {}
class Car extends Vehicle {}

private void Fun() {
    Vehicle a = new Car();
    boolean result = a instanceof Car;
    System.out.println(result);	/* true */
}

5. 流程语句

5.1 `if` 语句

一个 if 语句包含一个布尔表达式和一条或多条语句

语法格式

if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后
if 语句可以有若干个 else if 语句，必须在 else 语句之前
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行

if(布尔表达式 1){
	//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
	//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
	//如果布尔表达式 3的值为true执行代码
}else {
	//如果以上布尔表达式都不为true执行代码
}

嵌套 if

if(布尔表达式 1){
    //如果布尔表达式 1的值为true执行代码
    if(布尔表达式 2){
    	//如果布尔表达式 2的值为true执行代码
    }
}

5.2 `switch` 语句

switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

语法格式

switch语句中的变量类型可以是： byte、short、int 或者 char，String
当遇到 break 语句时，switch 语句终止，如果case 语句没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句
switch 语句可以包含一个 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句

switch (key) {
case value:
    // 逻辑语句
    break;
default:
    break;
}

6. 循环语句

6.1 `while` 循环

语法格式

如果不满足条件，则不能进入循环
只要布尔表达式为 true，循环体会一直执行下去

while(布尔表达式) {
	//循环内容
}

6.2 `do-while` 循环

语法格式

do…while 循环至少会执行一次

do {
   //代码语句
}while(布尔表达式);

6.3 `for` 循环

简单语法格式

循环执行的次数是在执行前就确定的
最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句
检测布尔表达式的值。如果为 true，循环体被执行
执行一次循环后，更新循环控制变量，再次检测布尔表达式

for(初始化; 布尔表达式; 更新) {
	//代码语句
}

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

增强语法格式

类似 foreach 语句
声明新的局部变量，该变量的类型必须和数组元素的类型匹配，其值与此时数组元素的值相等
表达式是要访问的数组名，或者是返回值为数组的方法

for(声明语句 : 表达式){
	//代码句子
}

int[] numbers = { 10, 20, 30, 40, 50 };
for (int x : numbers) {
    System.out.print(x);
    System.out.print(",");
}

String[] names = { "James", "Larry", "Tom", "Lacy" };
for (String name : names) {
    System.out.print(name);
    System.out.print(",");
}

6.4 其它语句

break 关键字

用在循环语句或者 switch 语句中，用来跳出当前循环语句块

for (int j = 0; j < 3; j++) {
    if (j == 2)
        break;
    System.out.println(j);
}

continue 关键字

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

for (int i = 0; i < 5; i++) {
	if(i == 2)
        continue;
}

跳出所有循环

方式一：使用 break 关键字

for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 2)
            break;
    }
    break;
}

方式二：使用标记跳出指定循环

a: for (int i = 0; i < 5; i++) {
    b: for (int j = 0; j < 3; j++) {
        if (j == 2)
            break a;
    }
}

7. `Java` 数组

7.1 一维数组

声明数组

首先必须声明数组变量，才能在程序中使用数组，声明数组变量的语法：

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

double[] myList; // 首选的方法
或
double myList[]; // 效果相同，但不是首选方法

创建数组

使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

声明创建

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];
或
dataType[] arrayRefVar = {value0, value1, ..., valuek};

元素引用

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到数组的长度减一

7.2 多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

7.3 冒泡排序

private static void Fun() {
    int IntArray[] = { 2, 9, 7, 4, 3, 1 };
    int temp = 0;
    /* 外层循环控制比较次数 */
    for (int i = 0; i < IntArray.length - 1; i++) {
        /* 内层循环控制每次排序的比较 */
        for (int j = 0; j < IntArray.length - 1 - i; j++) {
            if (IntArray[j] > IntArray[j+1]) {
                temp = IntArray[j];
                IntArray[j] = IntArray[j+1];
                IntArray[j+1] = temp;
            }
        }
    }
    for (int i : IntArray) {
        System.out.println(i);
    }
}

8. `Java` 方法

8.1 命名规则

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符
下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件

8.2 方法分类

无参数无返回值方法
无参数有返回值方法
有参数无返回值方法
有参数有返回值方法

8.3 方法声明

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

8.4 方法重载

方法名称相同
参数数量不同
参数类型不同

public void Mo1() {

}

public void Mo1(int index) {

}

public int Mo1(double index) {
    return 1;
}

posted @ 2021-05-27 10:36 位永光阅读(211) 评论(0) 收藏举报

刷新页面返回顶部

位永光

第一节：基础语法

1. 基础知识

1.1 命名限制

1.2 命名规则

1.3 Java修饰符

1.4 Java 注释

2. 变量,常量

2.1 Java 变量

2.2 Java 常量

3. 数据类型

3.1 基本数据类型

3.2 类型转换

4. 运算符

4.1 算术运算符

4.2 关系运算符

4.3 赋值运算符

4.4 逻辑运算符

4.5 条件运算符

4.6 其他运算符

5. 流程语句

5.1 if 语句

5.2 switch 语句

6. 循环语句

6.1 while 循环

6.2 do-while 循环

6.3 for 循环

6.4 其它语句

7. Java 数组

7.1 一维数组

7.2 多维数组

7.3 冒泡排序

8. Java 方法

8.1 命名规则

8.2 方法分类

8.3 方法声明

8.4 方法重载

公告

1.3 `Java`修饰符

1.4 `Java` 注释

2.1 `Java` 变量

2.2 `Java` 常量

5.1 `if` 语句

5.2 `switch` 语句

6.1 `while` 循环

6.2 `do-while` 循环

6.3 `for` 循环

7. `Java` 数组

8. `Java` 方法