1. 一个简单的Java应用程序
public class HelloWorld {
public static void main(String[] args) {
System.out.println("We will not use 'hHello,World1'");
}
}
运行结果
1)java区分大小写:例main写成Main将会无法运行
2)public访问修饰符:其他部分对这段代码的访问级别(第五章介绍)
3)关键字class:加载程序逻辑的容器。程序逻辑定义了应用程序的行为(第四章介绍)
class后紧跟类名,类名必须字母开头,后面可以和字母数子组合,不可使用保留字
4)类是构建java程序的块。
5)源代码的文件名必须与公共类的名字相同
6)编译后的class文件,java虚拟机将会从main方法开始执行
7)每个句子必须用分号结束
这里使用了System.out对象并调用了他的println方法【 . 用于调用方法】
例子中println方法传递了字符转参数,并将它显示到了控制台,对于没有参数的方法 【()】也需要写出来
2.注释
注释不会出现在可执行程序中
java中的三种注释
public class HelloWorld {
/**
* @Author akk
* @Description //TODO @Date 22:57 2020/4/6
* @Param [args]
* @return void
*/
public static void main(String[] args) {
// 打印字符串
/*这是
多行的住
注释*/
System.out.println("We will not use 'hHello,World1'");
}
}
1)// 最常用,从//开始到本行结束
2)/* 开始 / 结束 将比较长的一段注释括起来
3)/* 开始 */结束 用于自动生成文档
3.数据类型
java是强类型 语言,每一个变量都需要申明类型。
8种基础类型 |
---|
4种整型 |
2种浮点类型 |
1种表示Unicode编码 |
1种表示真值的布尔类型 |
- 四种整型
类型 | 存储需求 | 取值范围(负数范围 +1 +负号 例如byte:-128) |
---|---|---|
int | 4字节 | 2 147 483 647 |
short | 2字节 | 32 767 |
long | 8字节 | 9 223 372 036 854 775 807 |
byte | 1字节 | 127 |
1)int最常用
2)例如表示星球上的人数就要用long
3)byte和short用于特定场合
长整型后缀L 400000L
十六进制数值前缀0X
- 两种浮点类型
类型 | 存储需求 | 取值范围 |
---|---|---|
float | 4字节 | 有效位6-7 |
double | 8字节 | 有效位15位 |
更多的情况下float类型的精度难以满足需求,少数情况需要float如 单精度数据的库,需要存储大量的数据的时候
1)float后缀F 3.14F 没有写F默认为double
2)三个特殊浮点数值
*正无穷大 Double.POSITIVE_INFINITY
*负无穷大 Double.NEGATIVE_INFINITY
*NaN(不是一个数字)
-
char类型
char类型原本用来表示单个字符,如今一些Unicode字符可以用一个char描述另外一些两个char来描述。
char的字面值只用单引号括起来。
‘A’表示的是Unicode 65
”A“表示的是字符A
char类型的值可以表示为16进制值。因此可以存放转义字符,ASCLL
链接: char类型-转义字符. -
boolean类型
boolean有两个值
1)true
2)false
用于判定逻辑条件
4.变量
每一个变量都有类型,以分号结束
double salary;
int vacationDays;
1)不能使用java保留字
2)变量名必须以一个字母开头,字母数字构成序列
3)如果想知道Unicode字符是否属于Java中的字母,可以在Character类种isJavaIdentifierStart和isJavaIdentifierPart方法来检查
4)变量大小写敏感
变量的初始化
申明一个变量后,必须进行初始化,使用为赋值变量将会报错。
public static void main(String[] args) {
int vacationDays;
// 飘红报错
System.out.println(vacationDays);
}
将变量名放在 = 号左边,值放在右边。
public static void main(String[] args) {
int vacationDays = 12;
System.out.println(vacationDays);
}
显示如下
E:\JDK8_64\bin\
12
Process finished with exit code 0
常量
在java中使用final来指示常量。
1)final表示这个变量只能被赋值一次,一旦赋值不能更改,常量命全大写表示。
2)不变的,在类中多出使用的,通常将这些常量设置为类常量。
3)类常量使用static final设置
4)const是Java保留关键字,目前还没有使用,java中必须使用final来定义常量
5.运算符
Java中算数运算符
算数运算符 | 意义 |
---|---|
+ | 加运算 |
- | 减运算 |
* | 乘运算 |
/ | 除运算(整数为整数除法,否则浮点除法,当除0将会产生异常, ) |
% | 取模(取余数) |
数学函数与常量
1)在Math类中,包含了许多数学函数。开方,三角函数等等
2)数值类型之间的转换
3)强制类型转换
int可以无信息损失的转换为double
但是有时候需要double转换为int,这种情况需要强制类型转换,语法格式如下
double money = 11.111;
int nxmonry = (int) money;
输入结果:11
强制类型转换截断小数部分,转换为整型。
如果想让他进行四舍五入进行如下操作
使用数学类进行四舍五入
使用了round依然需要强制转换是因为round的返回类型是long,long转int 也是精度丢失
double money = 11.66;
int nxmonry = (int) Math.round(money);
4)结合赋值和运算符
赋值中可以使用二元运算符 是一种方便的简写
x += 4;
等价于
x = x + 4;
5)自增和自减运算符
后缀
自增运算符 n++ 将当前n的值加1
自减运算符 n-- 将当前n的值减1
前缀
自增运算符 ++n 将当前n的值加1
自减运算符 --n 将当前n的值减1
- 自增自减运算符只能对应变量,不能是数值如 4++ 这就是不对的
- 前缀后缀都是变量+1或-1,差异在表达式中体现
例子
public static void main(String[] args) {
int m = 7;
int n = 7;
int a = 2 * --m;
int b = 2 * n--;
System.out.println(a);
System.out.println(b);
}
输出结果:a 的值 12,b 的值 14
由此可见在表达式中 自增自减运算符的前缀后缀,表达先自增/自减 还是运算后自增/自减
前缀前自增/自减
6)关系和boolean运算符
检测相等性
使用 == 来检测相等
3 == 7 的值就是false 是不相等的
使用 !=来检测不相等
3 != 7 的值就是true是不相等的
<, >, <=, >= 等等运算符
&& 表示逻辑与
|| 表示逻辑或
!表示逻辑非
三元运算符 ?:
value = a < b ? x : y;
若a < b 成立 则value = x
若a < b 不成立 则value = y
1.&& 和 || 是按照短路方式来求值的 即如果第一个已经能够确定表达式的值,后面一个就不必计算了。
-
位运算符
-
括号与运算符级别
-
枚举类型
当变量的取值只在一个有限的集合内
自定义枚举类型,枚举类型包括有限个命名的值。
详细介绍第五章
emun Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };
6.字符串
概念上字符串就是Unicode字符串序列。
- 子串
String类的 subString方法可以从一个较大的字符串中提取出字串
String greeting = "Hello";
String s = greeting.substring(0,3);
上述方式创建出一个有Hello字符串创建出来子串Hel
substring(0,3) 从第零个开始 第三个结束(不包括第三个)
- 拼接
Java支持 + 号进行拼接两个字符串。
3)不可变字符串
对于String类没有提供修改字符串的方法
只能通过拼接的方式
String greeting = "Hello";
String s = greeting.substring(0,3) + "p!";
拼接成修改成字符串help!
因为不能修改Java字符串,所以java文档中将String类对象称为不可变字符串
不可变字符串的优点:编译器可以让字符串共享。
字符串变量指向存储池中相应的位置。如果复制一个字符串变量,他们将共享相同的字符
4)检查字符串是否相同
使用equals来检查字符串是否相同。
s.equals(t)
以上若相等 返回true 否则返回false。s和t可以是字符串变量,可以是字面值。
1.一定不能使用 == 来比较字符串,== 只能用来确定两个字符串是否放在同一个位置上。
事实上只有字符串常量是共享的,而 + 或者 substring等操作产生的结果并不是共享的。
简而言之,“ ==”测试引用是否相等,而equals()测试值是否相等。
除非要检查两个字符串是否是同一对象,否则应始终使用equals()
5)空串与Null串
空串:长度为0的字符串。
检测方式
if(str.length() == 0)
// 或者
if(str.equals(""))
空串也是一个Java对象,串长0,内容空
Null串:当内容为null表示没有任何对象与本变量有关。
检测方式
if(str == null)
当检查字符串既不是null也不是空串,需要先检查null,因为如果null.length() null上调用方法将会报错。
6)构建字符串
使用字符串连接在拼接次数很多的情况下效率低,每次连接字符串,就会构建一个新的String对象
StringBuilder类可以解决避免
StringBuilder builder = new StringBuilder();
// 当添加一部分内容,就调用append方法
builder.append("xxx");
builder.append("uuu");
// 最后构建一个String对象
String completedString = builder.toString();
7.输入输出
- 读取输入
System.out标准输出流
System.in标准输入流
想要通过控制台进行输入,需要构造一个Scanner对象,并与System.in进行关联
Scanner in = new Scanner(System.in);
这样就可以通过Scanner类的各种方法实现输入操作。
System.out.print("What is your name?");
String name = in.nextLine();
nextLine:读入输入的一行
next:读取有效字符
nextInt:读取一个整数
- 格式化输出
对于Print的格式化,暂不赘述。
可以使用format方法来创建一个格式化的字符串
8.控制流程
条件语句,循环结构控制流程
-
块作用域
控制结构之前,需要了解块的概念
块:一对大括号括起来若干条简单Java语句。块决定了变量的作用域,同时一个块可以嵌套在顶一个块中
注意点:在嵌套块中不能申明相同的名字的变量。 -
条件语句
if(yourSales >= target) {
performance = "akk";
bonus = 100;
}
-
循环语句
while循环
当循环条件为false,循环体就一次都不循环。在循环中要设置退出条件,不然会变成死循环 -
确定循环
for循环是一种支持迭代的通用结构。使用计数器来控制循环次数。
例:
for(int i = 1; i <= 10; i++) {
System.out.frintln(i);
}
- 多重选择:switch语句
switch(choice) {
case 1:
System.out.frintln("1");
break;
case 2:
System.out.frintln("2");
break;
default:
System.out.frintln("default");
break;
}
- 中断控制流程语句
break:退出循环
continue:跳过当前循环体,进入下一次循环中
9.大数值
当整数和浮点精度不能满足需求,那么可以使用java.math包中的
很有用的两个类:BigInteger 和 BigDecimal
BigInteger:实现了任意精度的整数运算
BigDecimal:实现了任意精度的浮点数运算
使用valueOf方法 可以将普通的数值转换为大数值
BigInteger a = BigInteger.valueOf(100);
注意:大数值不能使用+ 和 * ,取而代之的是大数值类中的add 和 multiply方法
BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.valueof(2)));
以上等同于 d = c * (b+2)
10.数组
1.数据简介
数组是一种数据集合,保存同一类型值的集合。
通过下标访问数组中的每一个值
申明一个数组
int[] a
初始化数组
int[] a = new int[100];
以上初始化了数组可以存放100个整数。
[100]中的内xx可以不是一个常量也可以是一个变量
注意点:
下标是从0开始
数字数组初始化都是0
boolean的数组初始化都是false
对象数组初始化都是null
数组一旦创建不能变更大小,需要变更大小需要使用另一种数据结构,数组列表。
2.for each循环
用来依次处理数组中的每个元素。而不必指定下标
for(int element : a){
System.out.println(element);
}
3.数组初始化以及匿名数组
数组还可以通过以下方式赋予初始值。这种方式将不需要调用new
int[] smallPrimes = {2,3,4,5,6};
用如上方式创建一个匿名的数组
new int[] {1,2,3,4,5};
以上方式就是在打括号中提供值进行初始化,数组的大小就是初始化的个数。
这种方式就可以在不创建新的变量的时候重新初始化一个数组
smallPrimes = new int[] {1,2,3,4,5,6}
4.数组的拷贝
一个数组拷贝给另一个数组,两个变量将引用同一个数组。
public static void main(String[] args) {
int[] smallPrimes = {1,2,3,4,5};
int[] luckyNumbers = smallPrimes;
luckyNumbers[0] = 10;
System.out.println(smallPrimes[0]);
}
输出结果:10
如果是希望所有值的拷贝可以使用Arrays类的copyOf方法
public static void main(String[] args) {
int[] smallPrimes = {1,2,3,4,5};
int[] luckyNumbers = Arrays.copyOf(smallPrimes, smallPrimes.length);
for (int x: luckyNumbers) {
System.out.print(x);
}
}
输出结果:12345
copyOf的第二个参数是指带新数组的长度,可以通过第二个参数扩容数组。
5.命令行参数
public static void main(String[] args) {
}
一个main方法中有String[] args表示main方法接收一个字符串数组,也就是命令行参数
添加参数
执行以下代码
public static void main(String[] args) {
if (args.length == 0 || args[0].equals("-h")) {
System.out.print("Hello,");
} else if (args[0].equals("-g")) {
System.out.print("Goodbye,");
}
for (int i = 1; i < args.length; i++) {
System.out.print(" " + args[i]);
}
System.out.println("!");
}
执行结果:Goodbye, cruel world!
6.数组排序
对数形数组进行排序 同样使用Arrays类中的sort方法
sort是优化的快排算法。
public static void main(String[] args) {
int[] excursiveArray = {2, 5, 1, 2, 5, 6};
Arrays.sort(excursiveArray);
for (int x: excursiveArray) {
System.out.print(x);
}
}
输出结果122556
7.多维数组
暂且不赘述
8.不规则数组
暂且不赘述