【Java】学习笔记一

一、数据类型

整数数据

byte 、short、int、long

浮点类型

float、double
定义float型变量时，如果不加f或者F，系统会认为使double类型数据，进而出错
定义double型变量时，可不加d，这是默认的浮点类型

float f1 = 13.23f;
double d1 = 456.12d;
double d2 = 45678.1564;

字符类型

char 定义单个字符，占用16位（2个字节）的内存空间
定义字符型变量时，要以单引号表示，'s'表示一个字符，“s”表示一个字符串
使用(int) word来将字符转换为对应的Unicode表中的位置，用(char) p将Unicode表中的位置转换为对应的字符

布尔类型

boolean关键字用于定义布尔类型变量， 在java中布尔类型为true、`false``

boolean b;
boolean b1, b2;
boolean b = true;

标识符

java中的标识符的第一个字符不能是数字，标识符不能是关键字，标识符严格区分大小写

关键字

• abstract：用于声明抽象类或抽象方法。抽象类不能被实例化，只能被继承。抽象方法只有声明，没有具体的实现，需要在具体的子类中重写。

• assert：用于进行断言检查，用于在代码中添加一些条件检查，如果条件不满足，会抛出AssertionError。

• boolean：表示布尔类型，只能取true或false两个值。

• break：用于跳出循环或switch语句块。

• byte：表示字节数据类型，占用8位，可以存储-128到127之间的整数值。

• case：在switch语句中用于定义不同的分支。

• catch：用于捕获异常，跟随在try块之后，用于处理异常并进行相应的处理操作。

• char：表示字符数据类型，占用16位，可以存储Unicode字符。

• class：用于定义类。

• continue：用于跳过循环中的某次迭代，继续下一次迭代。

• default：在switch语句中，用于定义默认的分支。

• do：用于循环执行一段代码块，并在条件满足时继续执行。

• double：表示双精度浮点数数据类型，占用64位，可以存储较大范围的小数值。

• else：在条件语句中，如果条件不满足，则执行else语句块中的代码。

• enum：用于定义枚举类型，枚举类型是一组预定义的常量。

• extends：用于继承一个类。

• final：用于修饰类、方法或变量。修饰类表示它不能被继承，修饰方法表示它不能被重写，修饰变量表示它的值不可被改变。

• finally：用于定义在异常处理后一定会执行的代码块，无论是否发生异常。

• float：表示单精度浮点数数据类型，占用32位，可以存储较小范围的小数值。

• for：用于循环执行一段代码块，定义初始化、条件和迭代语句。

• if：用于定义条件语句，根据条件的真假执行相应的代码块。

• implements：用于实现一个接口。

• import：用于导入其他包中的类或整个包。

• instanceof：用于检查对象是否是某个类的实例，或是否实现了某个接口。

• int：表示整数数据类型，占用32位，可以存储较大范围的整数值。

• interface：用于定义接口，接口可以包含方法和常量的声明，但不能有实现。

• long：表示长整数数据类型，占用64位，可以存储更大范围的整数值。

• native：用于声明一个本地方法，该方法的实现由外部的本地代码提供。

• new：用于创建一个类的实例。

• package：用于定义包，用于组织类和接口。

• private：表示私有访问修饰符，只能在同一个类内部访问。

• protected：表示受保护的访问修饰符，只能在同一个包内或子类中访问。

• public：表示公共访问修饰符，可以从任何地方访问。

• return：用于从方法中返回一个值，并终止方法的执行。

• short：表示短整数数据类型，占用16位，可以存储较小范围的整数值。

• static：用于修饰类成员，表示该成员属于类本身而不是类的实例。

• strictfp：用于声明一个浮点运算符是按照规范（IEEE 754）执行的。

• super：用于在子类中调用父类的构造方法、方法或成员。

• switch：用于多分支选择语句，根据不同的值执行相应的代码块。

• synchronized：用于实现线程同步，用于修饰方法或代码块。

• this：表示当前对象的引用，可用于引用当前类的成员或调用当前类的构造函数。

• throw：用于抛出一个异常。

• throws：用于声明一个方法可能抛出的异常类型。

• transient：用于修饰变量，表示它不会被序列化。

• try：用于定义一个代码块，并标识可能发生异常的代码。

• void：表示方法返回类型为空，即不返回任何值。

• volatile：用于修饰变量，表示它是易变的，每次使用时都从内存重新读取。

• while：用于循环执行一段代码块，根据条件的真假执行循环。

声明变量

声明变量就是要告诉编译器这个变量的数据类型。这样编译器才知道需要配置多少空间给它，以及它能存放什么样的数据。
声明变量时，可以是没有赋值，也可以是直接赋值的

int age;  //没有赋值，声明int变量
char char1 = 'r';  //有赋值，声明char变量

声明常量

使用final来声明一个常量，除了要制定数据类型，还需要赋值，建议使用大写字母表示常量

final double PI = 3.1415926D;

允许的

final int number;
number = 123

不允许的

final int number;
number = 123;
number= 345;

变量的作用域

根据有效范围将变量分为：成员变量、局部变量
成员变量

成员变量

在类体中所声明的变量被称为成员变量，在整个类中都有效。
成员变量又分为：静态变量、实例变量

class demo{
	int x = 45;
	static int y = 90;
}

x为实例变量，y为静态变量（也称为类变量）
使用static可以将成员变量变为静态变量，静态变量的有效范围可以跨类，甚至可达到整个应用程序之内

局部变量

在类的方法体中声明的变量，方法内部定义，{与}之间的代码中申明的变量称为局部变量。局部变量只有在当前代码块中有效，也就是只能在{于}之内使用
当方法调用结束后，会释放方法中局部变量占用的内存空间，局部变量也将会被销毁
局部变量可与成员变量的名字相同，此时成员变量将被隐藏，即这个成员变量在此方法中暂时失效

二、运算符

=

public class eval{
	public static void main(Strin[] args){
		int a,b,c;
		a = 15;
		c = b = a+4;
		System.out.println("c的值为: " + c);
		System.out.println("b的值为: " + b);

}

其中c与b指向同一个内存空间

算术运算符

以下列出了Java中常用的算术运算符：

• +：加法运算符，用于执行两个数字的相加操作。
• -：减法运算符，用于执行两个数字的相减操作。
• *：乘法运算符，用于执行两个数字的相乘操作。
• /：除法运算符，用于执行两个数字的相除操作。
• %：取模运算符，返回两个数字相除的余数。
• ++：自增运算符，用于将一个数值增加1。
• --：自减运算符，用于将一个数值减少1。

这些运算符可以用于处理基本的数学运算，例如计算两个数字的和、差、积、商和余数，还可以用于执行数字的自增和自减操作。在编写代码时，我们可以使用这些算术运算符来实现所需的数学计算和逻辑。

算术运算符

import java.util.Scanner;
public class arithmetic{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入两个数字，用空格隔开(num1 num2);
		double num1 = sc.nextDouble();
		double num2 = sc.nextDouble();
		System.out.println("num1+num2的和为："+(num1+num2));
		System.out.println("num1-num2的差为："+(num1-num2));
		System.out.println("num1*num2的积为："+(num1*num2));
		System.out.println("num1/num2的商为："+(num1/num2));
		System.out.println("num1%num2的余数为："+(num1%num2));
		sc.close();
	}
}

自增和自减运算符

自增、自减运算符是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整型或者浮点型变量。
自增、自减运算符的作用是使变量的值增1或减1。
放在操作元前面的自增、自减运算符，会先将变量的值加1（减1），然后再使用该变量参与表达式的运算。
放在操作元后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将变量加1（减1）

++a(--a) // 表示在使用变量a之前，先使a的值加（减）1
a++(a--) // 表示在使用变量a之后，再使a的值加（减）1

假设a=4，先将a的值加1，然后赋给b，此时a值为5， b值为5

b = ++a

假设a=4, 现将a的值赋给b，再将a的值加1，此时a值为5， b值为4

b = a++

比较运算符

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型
Java中的比较运算符用于比较两个值之间的关系，并返回一个布尔值（true或false）。以下是Java中常用的比较运算符：

• ==：等于运算符，用于检查两个值是否相等。
• !=：不等于运算符，用于检查两个值是否不相等。
• >：大于运算符，用于检查左操作数是否大于右操作数。
• <：小于运算符，用于检查左操作数是否小于右操作数。
• >=：大于等于运算符，用于检查左操作数是否大于或等于右操作数。
• <=：小于等于运算符，用于检查左操作数是否小于或等于右操作数。

逻辑运算符

Java中的逻辑运算符用于在条件语句中结合多个条件，并返回一个布尔值（true或false）。以下是Java中常用的逻辑运算符：

• &&、&：逻辑与运算符，用于检查多个条件是否同时为真。左操作数和右操作数都为true时，结果为true；否则结果为false。
• ||：逻辑或运算符，用于检查多个条件是否至少一个为真。左操作数和右操作数只要有一个为true，结果为true；否则结果为false。
• !：逻辑非运算符，用于对单个条件取反。如果条件为true，则结果为false；如果条件为false，则结果为true。

逻辑运算符在条件语句、循环结构以及布尔表达式的处理中起到了重要的作用。它们允许我们根据多个条件的组合来控制程序的流程和逻辑。需要注意的是，逻辑与运算符（&&）和逻辑或运算符（||）都具有短路特性，即如果左操作数已经确定了整个表达式的结果，那么右操作数将不会被计算。

例如：对于逻辑与运算符&&，如果左操作数为false，则整个表达式的结果一定为false，右操作数将不会被计算。同样，对于逻辑或运算符||，如果左操作数为true，则整个表达式的结果一定为true，右操作数将不会被计算。这种短路特性可以提高程序的效率和性能。

在Java中，逻辑运算符的结合方向是从左到右（!除外）。意味着表达式中的多个逻辑运算符将按照从左到右的顺序进行求值。需要注意的是，当多个逻辑运算符一起出现时，可以使用括号来明确指定运算的顺序，以避免歧义性和误解。
简单的运用场景

public class caculate{
	public static void main(String args[]){
		int boys = 30;
		int girls = 29;
		int total = boys + girls;
		boolean result1 = (boys > girls)&(total >60);
		boolean result2 = (boys>girls)||(total>60);
		System.out.println("boys is more than girls and total is bigger than 60 "+result1);
		System.out.println("boys is more than girls or total is bigger than 60 "+ result2);
	}
}

三元运算符

三元运算符的语法

条件式 ? 值1 : 值2

比如

boolean b = 20 < 45 ? true:false;

表达式20<45为真，返回对应的值1也就是true，相反如果为假，返回对应的值2也就是false，三元运算符等价于if..else语句
上面的代码等价于

boolean b;
if (20<45){
	b = true;
} else{
	b = false;
}

三、流程控制

复合语句

public class Compound{
	public static void main(String args[]){
		int x = 20;
		{
			int y = 40;
			System.out.println(y);
			int z = 245;
			boolean b;
			{
				b = y > z;
				System.out.println(b);
			}
		}
		String word = "hello java";
		System.out.println(word);
	}
}

复合语句要在{与}之内，在之外引用会报错

条件语句

if条件语句

简单的if条件语句

if(布尔表达式){
	语句序列
}

当语句序列仅有一条语句时，可以省略条件语句中的{}， 但最好不要省略

int a = 100;
	if(a==100)
	 System.out.println("a 的值是100");

以下情况都是合法的

boolean b = false;
if(b);
boolean b = false;
if(b){}
boolearn b = false;
if  (b) {
}

简单的if应用场景

public class phonenumber{
	public static void main(String args[]){
		int phone = 123456;
		if (phone!=345678){
			System.out.println("the phone number dosen't exist");
		}
	}
}

if.. else语句的简单应用场景

if(条件表达式){
	function1
}else{
	function2
}

使用if...else进行密码判断

public class password{
	public static void main(String args[]){
		int password = 123;
		if (password == 345){
			System.out.println("password is correct");
		}else{
			System.out.println("password is incorrect");
		}
	}
}

这里的else位置没有R语言中那么严格
if...else if多分支语句，语法

if (boolean_function1){
	function1
}else if(boolean_function2){
	function2
}

使用if...else if...else进行用餐人数场景模拟

public class restaurant{
	public static void main(String args[]){
		System.out.println("how manay customer?");
		int count = 7;
		System.out.println("answer: "+count+" people");
		if (count <=4){
			System.out.println("go to the 4p table");
		}else if (count>4&&count<=8){
			System.out.println("go to the 8p table");
		}else if (count>8&&count<=16){
			System.out.println("go to the 16p table");
		}else{
			System.out.println("sorry, we could not support service");
		}
	}
}

switch多分支语句

switch的语法

switch(expression){
case constant1:
	function 1;
	[break;]
...
case constantn:
	function n;
	[break;]
default:
	function n+1;
	[break;]

• expression中的值必须是整型、字符型、字符串类型或枚举类型，
• constant的值必须与expression的类型相同
• switch语句首先计算表达式的值，如果表达式的计算结果和某个case后面的常量值相同，则执行该case语句后的若干个语句直到遇到break;语句。
• 此时，若case语句中没有break;语句，将继续执行后面case中的若干个语句，直到遇到break;语句为止。
• 若没有一个constant的值与expression相同，则执行default后面的语句，如果没有default语句，则不做任何处理
• 同一个switch语句，case的常量值必须互不相同
• expression表达式不可以是浮点数据

使用switch来模拟成绩评估

import java.util.Scanner;
public clas grade{
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		System.out.println("please enter grade");
		int grade = sc.nextInt();
		switch(grade){
		case 10:
		case 9:
			System.out.println("the performance is excellent");
			break;
		case 8:
			System.out.println("the performance is great");
			break;
		case 7:
		case 6:
			System.out.println("the performance is mediate");
			break;
		case 5:
		case 4:
		case 3:
		case 2:
		case 1:
		case 0:
			System.out.println("the performance is bad");
			break
		default:
			System.out.println("the grade is invalid");
		}
		sc.close();
	}
}

循环语句

while

while的语法

while(expression){
	function
}

计算1——1000的相加结果

public class getsum{
	public static void main(String args[]){
		int x = 1;
		int sum = 0;
		while (x<=1000){
			sum = sum+x;
			x++
		}
		System.out.println("sum = "+sum);
	}
}

do…while

do..while的语法

do{
	function
} while (expression);

• while先进行条件判断，再执行循环体
• do...while先执行循环体，再进行条件判断，do...while结尾有;
  使用do..while模拟登入验证

import java.util.Scannner;
public class loginservice{
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		int password;
		do{
			System.out.println("please enter your password")
			password = sc.nextInt();
		}while(password!=123);
		System.out.println("login success");
		sc.close();
	}
}

for

for的语法

for (expression1, expression2, expression3){
	function
}

• expression1: 初始化表达式，负责完成变量的初始化
• expression2:循环条件表达式，值为boolean型的表达式，指定循环条件。等同于while循环里的表达式
• expression3:每次循环结束后执行的语句，通常用来改变循环条件

使用for循环计算2——100所有偶数之和

public class circulate{
	public static void main(String args[]){
		int sum = 0;
		for (int i = 2； i <= 100； i += 2){
			sum = sum + i;
		}
		System.out.println("the sum is :" +sum);
	}
}

foreach

foreach是一种特殊的for循环，但是它并不是关键字，而是指这种特殊的for循环为foreach循环
foreach 类似于python中的可遍历数据的遍历体比如

x = [1,2,3]
for i in x:
	print(i)

foreach的语法

for(元素类型 x: 遍历对象 obj){
	引用了x的java语句
}

使用foreach结构遍历整型数组

public class repetition{
	public static void main(String args[]){
		int arr[] = {5, 13, 96};
		System.out.println(" the number is ")
		for（int x:arr){
			System.out.println(x);
		}
	}
}

break

break可以跳出当前循环体，从而中断当前循环

while (){
	...
	break
}

输出1——20出现的第一个偶数

public class breaktest{
	public static void main(String args[]){
		for (int i=1; i<=20； i++){
			if (i%2==0）{
				System.out.println("the fist double"+i);
				break;
			}
	}
	System.out.println("the project end"）;
	}
}

循环嵌套情况下，break语句只会使程序流程跳出包含它的最内层的循环结构，即只跳出一层循环，如果想让break跳出外层循环， java提供了标签的功能，语法

标签名： 循环体{
	break 标签名;
}

使用标签让break跳出外层循环体

public class breaktest{
	public static void main(String args[]){
		Loop: for (int i = 1; i <= 3; i++){
			for (int j = 1; j<=5;j++){
				if (j==4){
					break Loop;
				}
				System.out.println("i="+i+"j="+j);
			}
		}
	}
}

continue

continue语句时针对break语句的补充，continue不是立即跳出循环体，而是跳过本次循环，回到循环的条件测试部分，重新开始执行循环。
使用continue跳过1-20中的偶数

public class skipdouble{
	public static void main(String args[]){
		for (int i = 1; i<=20; i++){
			if (i%2==0){
				continue;
			}
			System.out.println(i);
		}
	}
}

与break一样，continue也支持循环体的标签功能

四、数组

数组是相同类型的用一个标识符封装到一起的基本类型数据序列或对象序列

一维数组

一维数组实质上是一组相同类型数据的线性组合
数组作为对象允许使用new关键字进行内存分配
声明一维数组的两种方式

	数组元素类型 数组名字[];
	数组元素类型[] 数组名字;

[]指标该变量是一个数组类型变量，单个[]表示要创建的数组是一个一维数组
例子， 声明int类型数组，数组中的每个元素都是int型数组

int arr[];

声明数组后，要分配内存空间才能访问数组的元素，分配空间时必须指明数组的长度

数组名字 = new 数组元素的类型[数组元素的个数];

为数组分配内存

arr = new int[5];

数组元素的访问也是从0开始的，这个和访问python的列表一样
声明的同时为数组分配内存

数组元素的类型 数组名 = new 数组元素的类型[数组元素的个数];

例子

int month[] = new int[12];

初始化一维数组的两种方法

int arr[] = new int[]{1,2,3,4,5,6};
int arr2[] = {1,2,3};

使用一维数组

public class getday{
	public static void main(String args[]){
		int day[] = new int[]{31,28,31,30,31,30,31,30,31,30,31,30}
		for (int i = 0; i<12; i++){
			System.out.println((i+1)+"月有"+day[i]+"天");
		}
	}
}

等价于
使用foreach结构遍历整型数组

public class getday{
	public static void main(String args[]){
		int day[] = new int[]{31,28,31,30,31,30,31,30,31,30,31,30};
		int month = 1
		for（int x:day){
			System.out.println(month+":"+x);
			month++
		}
	}
}