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