零基础学Java语言_翁恺自学笔记

本次自学的是零基础学Java语言教程-翁恺
https://www.icourse163.org/course/ZJU-1001541001?tid=1465613445

使用了官方汉化，汉化教程见文章底部

计算：

变量常量：

变量定义的一般形式是
<类型名称><变量名称>;

int price;
int amount;
int price,amount;

定义一个常量：

final int amount = 100;

输入输出：

System.out.print("请输入票面");
amount = in.nextInt();
System.out.print("请输入金额");
price = in.nextInt();

System.out.print("请输入票面");

amount = in.nextInt();

System.out.print("请输入金额");

price = in.nextInt();

输出字符串：请输入票面
读取一个用户输入的int
输出字符串：请输入金额
读取一个用户输入的int

System.out.print("请输入金额：");
//这个是不回车
System.out.println("请输入金额");
//这个是输出之后回车

System.out.print("请输入金额：");

//这个是不回车

System.out.println("请输入金额");

//这个是输出之后回车

浮点数：

double inch;
inch = in.nextInt();
inch = in.nextDouble();

double inch;

inch = in.nextInt();

inch = in.nextDouble();

可以如第二行把整数交给double

类型转换：

System.out.println((int)((foot+inch/12.0)*0.3048*100));

1	System.out.println((int)((foot+inch/12.0)0.3048100));

在结果前加(int)

这是把它右边的数变成int，所以这样不行：

foot = (int)30/3.0

1	foot = (int)30/3.0

这样才行：

foot = (int)(30/3.0)

1	foot = (int)(30/3.0)

要注意的是并不会改变原来的值

int a = (int)b;

1	int a = (int)b;

判断和分支：

注释：

注释的//和/**/和c一样

比较：

==
!=
>
>=
<
<=

跟c一样

所有关系运算符的优先级比算术运算低比赋值高

bool：

java里是有true和false的，并且true和false之间没有大小关系

c没有bool类型，Java有并且bool就是bool不是数值。

浮点数比较：

“1.0”和“十个0.1相加”之间进行比较是否相等，他们的结果不是true

因为浮点数不是精确的，所以需要用另外的方法

System.out.println(Math.abs(a-b) < 1e-6);

分别是 求绝对值 小于 1乘10的负六次幂(科学计数法)

System.out.println(Math.abs(a-b) < 1e-6);

分别是求绝对值小于 1乘10的负六次幂(科学计数法)

if-else

if (判断对错)

如果if括号内是true那就执行{}内的语句否则跳过{}。

跟c一样不加{}也行

else总是和最近的if匹配

建议ifelse后面总是加{}

级联：
if
else if
else if
else

单一出口

switch-case

if和switch跟c一模一样，一点都不带改的

do-while:至少执行一次

for也完完全全一模一样

+=和-=和/=等等也一样，i++也可以用

i++和++i的区别也一样

break和continue也一样

JAVA的多重循环退出方法：

这个例子是计算某个价钱可以用多少零钱来换，现在的需求是计算出第一个就退出，但是如果是c的话就只能break的接力(或者goto)，而正如图所示，JAVA可以使用“标号”来标记第一个for循环，然后直接跳出多重循环。

Java的逻辑类型(boolean)：

关系运算的结果是一个逻辑值，true或false，这个值可以保存在一个对应的逻辑类型的变量中，这样的变量类型是boolean

布尔（Boolean）是为了纪念George Boole对逻辑计算的贡献

boolean flag = true;
boolean tooHigh, tooSmall, tooRough;
boolean done = false;

逻辑运算的运算符也是一样的：&&和||和!

逻辑运算符的优先级：

！取反>&&与>||或

!done && (count > MAX)

1	!done && (count > MAX)

所以上面的是先算取反，然后算括号内的，最后做"与"的判断

所有的单目运算符的优先级都很高

带格式的输出：

System.out.printf("请输入票面");

1	System.out.printf("请输入票面");

哦我的上帝，printf原来在这里等着呢，如果希望像c那样控制输出，就要从这样改成这样写：

System.out.println(sum);
System.out.printf("%.2f", sum);

1 2	System.out.println(sum); System.out.printf("%.2f", sum);

等下等下，这不就完全变成c语言的形状了吗

数组：

定义：

<类型>[] <名字> = new <类型>[元素个数];
int[] grades = new int[114514];

1 2	<类型>[] <名字> = new <类型>[元素个数]; int[] grades = new int[114514];

int [] numbers = new int[100];

1	int [] numbers = new int[100];

一旦创建，不能改变大小

int[] numbers[] = nwq int[4];
numbers[0] = 11;
numbers[1] = 4;
numbers[2] = 51;
numbers[3] = 4;

int[] numbers[] = nwq int[4];

numbers[0] = 11;

numbers[1] = 4;

numbers[2] = 51;

numbers[3] = 4;

元素个数必须是整数，元素个数必须给出，元素个数可以是变量

数组的length：

每个数组有一个内部成员length，会告诉你它的元素的数量

for (int i = 0; i < 100; i++) {
	sum += a[i];
}
//最好是变成这个：
for (int i = 0; i < a.length; i++) {
	sum += a[i];
}

for (int i = 0; i < 100; i++) {

sum += a[i];

}

//最好是变成这个：

for (int i = 0; i < a.length; i++) {

sum += a[i];

}

直接初始化数组：

用c的方法：

int[] asd = {1};
int bbc[] = {0};
System.out.printf("%d", asd[0]);
System.out.printf("%d", bbc[0]);

int[] asd = {1};

int bbc[] = {0};

System.out.printf("%d", asd[0]);

System.out.printf("%d", bbc[0]);

用这种方法不可以设置数组的大小，必须初始化。

数组变量并不是数据的所有者：

如果定义一个普通的变量，那么就在此处创建了空间，普通变量就是空间里的数据的所有者

定义一个数组变量，会在不知道的地方创建数组的空间

数组变量只是管理者

无论是用什么方法制造出来的数组都是这样的(包括用{}初始化的)，

所以如果写入这样的代码：

int[] b = a;

1	int[] b = a;

那么只是让b也一起去管理a管理的变量，这个时候就是两个管理者管理一串数组

所以这个时候进行b[0] = 16,那么a[0]也等于16

数组变量是数组的管理者而非数组本身
数组必须创建出来然后交给数组变量来管理
数组变量之间的赋值是管理权限的赋予
数组变量之间的比较是判断是否管理同一个数组(不是内容相同，判断的是“是否”是“同一个”)

复制数组必须使用便利的方法逐个的拷贝。

for-each循环：

for (int k : 某个数组) {
	if (k == 想找的那个数) {
		found = true;
		break;	
	}
}

for (int k : 某个数组) {

if (k == 想找的那个数) {

found = true;

break;

}

对于"某个数组"中的每一个元素，循环的每一轮都会将其拿出来作为一个k

k在第一次for的循环等于数组的第0个，第二次是数组的第1个。

k是不断变动的，简单说就是每次循环都会遍历每一个元素然后让k等于这个数。

for与数组的例子：

最基础的方法：

Scanner in = new Scanner(System.in);

int x = in.nextInt();//输入一个数 即将判断它是不是素数
boolean isPrime = true;//默认为是素数

if (x == 1) {
	isPrime = false;
}
for (int i = 2; i < x; i++) {
	if (x % i == 0) {
		isPrime = false;
		break;
	}
}

if (isPrime) {
	System.out.println(x+"是素数");
}
else {
	System.out.println(x+"不是素数");
}

Scanner in = new Scanner(System.in);

int x = in.nextInt();//输入一个数即将判断它是不是素数

boolean isPrime = true;//默认为是素数

if (x == 1) {

isPrime = false;

}

for (int i = 2; i < x; i++) {

if (x % i == 0) {

isPrime = false;

break;

}

if (isPrime) {

System.out.println(x+"是素数");

}

else {

System.out.println(x+"不是素数");

}

对于n要循环n-1遍，当n很大时可以看作n遍

去掉偶数的改进方式：

Scanner in = new Scanner(System.in);

int x = in.nextInt();//输入一个数 即将判断它是不是素数
boolean isPrime = true;//默认为是素数

if (x == 1 || (x%2 == 0 && x!= 2)) { //1不是素数 或者 (不是2的情况下2的倍数也不是) 注意此处&&比||优先级高
	isPrime = false;
}
else {//去掉2的倍数后从3开始按传统方法判断
	for (int i = 3; i < x; i+=2) {
		if (x % i == 0) {
			isPrime = false;
			break;
		}
	}

}

if (isPrime) {
	System.out.println(x+"是素数");
}
else {
	System.out.println(x+"不是素数");
}

Scanner in = new Scanner(System.in);

int x = in.nextInt();//输入一个数即将判断它是不是素数

boolean isPrime = true;//默认为是素数

if (x == 1 || (x%2 == 0 && x!= 2)) { //1不是素数或者 (不是2的情况下2的倍数也不是) 注意此处&&比||优先级高

isPrime = false;

}

else {//去掉2的倍数后从3开始按传统方法判断

for (int i = 3; i < x; i+=2) {

if (x % i == 0) {

isPrime = false;

break;

}

if (isPrime) {

System.out.println(x+"是素数");

}

else {

System.out.println(x+"不是素数");

}

如果x是偶数那么立刻结束判断，否则要循环(n-3)/2+1遍，n很大时就是n/2遍

构造素数表(计算机思维)：

欲构造n以内的素数表

令x为2
将2x、3x、4x直至ax<n的数标记为非素数
令x(循环正指着的位置)为下一个没有被标记为非素数的数，重复步骤2;
直到所有的数都已经尝试完毕（到达设定的素数表的边缘）

本笔记内直接或间接引用了如下内容：

CSDN eclipse汉化教程-Zeromes：
https://blog.csdn.net/qq_43736451/article/details/116240449

计算：

变量常量：

输入输出：

浮点数：

类型转换：

判断和分支：

注释：

比较：

bool：

浮点数比较：

if-else

switch-case

JAVA的多重循环退出方法：

Java的逻辑类型(boolean)：

逻辑运算符的优先级：

带格式的输出：

数组：

定义：

数组的length：

直接初始化数组：

数组变量并不是数据的所有者：

for-each循环：

for与数组的例子：

最基础的方法：

去掉偶数的改进方式：

构造素数表(计算机思维)：

本笔记内直接或间接引用了如下内容：

发表回复 取消回复

发表回复取消回复