Java基本语法入门

这是一份个人向的笔记，供个人复习参考用，也适合有一定程序语言基础的初学者入门。希望看完能够对你会有所帮助^ ^（可以配合网课食用）

第一个程序：

//class是一个类，helloworld是类名，类名尽量跟文件名保持一致
public class helloworld{	
    //main:主方法（程序的入口）
    public static void main(String[] args) {
        //输出双引号中的语句
        System.out.println("Hello, World!");	
    }

}

tips：编写Java时应该注意以下内容

大小写敏感：如标识符Hello和hello是不一样的
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行
源文件名：源文件名必须和类名相同

字面量分类

类型	说明	举例	字符
整数类型	/	114	byte(范围是-128~128)、shout、int、long（一般默认用int
小数类型	/	114.514	float、double（一般默认用double
字符串类型	用双引号括起来的内容	“Megumin”，“ ”	string
字符类型	用单引号括起来的内容，内容只能有一个	‘a’	char
布尔类型	布尔值，表示真假	true\false	boolean
空类型	空值，一个特殊值	null

取值范围大小关系：double > float > long > int > short > byte

tips：

键盘输入

//首先在类之前先导包，找到Scanner这个类（严格区分大小写）
import java.util.Scanner;

public class Valuedemo1 {
    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);//输入前要创建对象，表示准备使用Scanner
        int a = sc.nextInt(); //输入一个整数
        double b = sc.nextDouble();//输入一个小数
        double c = sc.nextDouble();
        

        System.out.println(a);//输出整数
		System.out.println(b);//小数
    }
}

除了变量a可以更改，其他尽量保持原样

tips:

注意定义不同类型输入时写法也不一样：

int a = sc.nextInt(); //整数类型是用sc.nextInt

double b = sc.nextDouble(); //小数类型是用sc.nextDouble

使用上面方法输出时不需要手动换行，想让输出内容在同一行应该使用System.out.print(“输出内容”);（删去了ln

类型转换分类
**数据类型不一样时，不能进行计算，**需要转成一样的才能进行计算

类型不同的数字相加减时，先把取值范围小的数值类型转变为取值范围大的数据再进行操作

取值范围： double > float > long > int > short > byte

例：
1
2
3
4
5
6
7
public class test1{
public static void main(String[] arg){
int a = 10;
double b = 20.0;
double c = a + b;
}
}

byte short char 三种类型的数据在运算时，都会直接先升为int，然后再运算

public class test2{
	public static void mian(String[] args){
		byte a = 10;
		byte b = 20;
		int c = a + b;
	}
}

强制转换

如果把一个取值范围大的数赋值给取值范围小的变量，是不允许直接赋值的。如果要赋值就必须做强制转换

public class test3{
	public static void main(String[] args){
		double a = 12.3;
		int b = (int) a;
	}
}

格式：目标数据类型变量名 = （目标数据类型）被强转的数据；

字符和字符串的加操作

当 “ + ” 操作中出现字符串时，这个 “ + ” 是字符串连接符，而不是算数运算符。会将前后数据进行拼接，产生一个新的字符串。（只要出现字符串就都是字符串拼接，不出现就是单纯的加法）
连续进行 “ + ” 操作时，从左到右逐个执行。
字符串只有加运算。

三元运算符

格式：关系表达式 ? 表达式1 : 表达式2

范例：求较大的值

public class test2{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		int max = a > b ? a : b;//若关系表达式符合条件则将冒号前的值赋值给max，否则把b赋值给max
		System.out.println(max);//最后输出20
	}
}

分支结构

主要包含了 if 和 switch 两种语句，使用方法均跟c语言相同，就不过多介绍。但是因为switch使用频率较低已经忘得差不多了，就顺便记一下

switch语句

switch(表达式){	 //计算表达式的值，跳转到对应的case中执行相应指令

	case 值1:
		执行指令;	//当跳转到这里时会执行这个指令
		break;	   //执行结束之后退出switch
	case 值2:
		执行指令;
		break;
	……
    default:		//当表达式都不满足以上的值时会跳转到这里
    	执行指令;
    	break;
    	
}

如果case后只有一行代码，可以通过以下方式简化代码

switch(表达式){	 //计算表达式的值，跳转到对应的case中执行相应指令

	
	case 值1,值2 -> 执行指令1; //用箭头代替冒号，接上执行的指令。当存在相同输出结果的值，用逗号隔开即可
	case 值3 -> 执行指令2;  
			
	……
    default -> 执行指令;	//当表达式都不满足以上的值时会跳转到这里
    	
}

循环语句

使用的是for、while、do…while语句，使用方法均与c语言相同，就不多赘述了（真的不是懒得写

下面用一道例题来说明写法

需求：输入一个数判断是否为回文数

例子：

输入1：121 输入2：123

输出1：true 输出2：false

//使用for语句
import java.util.Scanner;

public class test8{
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个数字：");
		int num = sc.nextInt();
		int temp = num;
		int result = 0;
		
		for(;temp != 0;){
			int ge = temp % 10;
			result = (result * 10) + ge;
			temp /= 10;
		}
		
		System.out.println(result == num);
		
	} 
}

//使用whlie语句
import java.util.Scanner;

public class test8{
	public static void main(String[] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个数字：");
		int num = sc.nextInt();
		int temp = num;
		int result = 0;
		
		while(temp != 0){
			int ge = temp % 10;
			result = (result * 10) + ge;
			temp /= 10;
		}
		
		System.out.println(result == num);
		
	} 
}

随机数生成

用Random生成随机数。使用方法跟Scanner相同：

①导包：import java.util.Random;

②创建对象： Ramdon r = new Ramdon( );

③生成随机数：int

举例：

import java.util.Scanner;
import java.util.Random;	//导包
public class test_2 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        Random r = new Random();	//创建对象
        int result = r.nextInt(100); 	//生成随机数
        int count = 1;
        for (; ; count++){
            System.out.println("请输入一个数字：");
            int num = sc.nextInt();
            if(num == result){
                System.out.println("使用了" + count + "次猜出答案");
                break;
            }else if(num > result){
                System.out.println("猜大了");
            
            }else{
                System.out.println("猜小了");
            }
        }
    }
}

数组

定义

数组指的是一种容器，可以用来存储同种数据类型的多个值

数组容器在存储数据时，需要结合隐式转换考虑

int类型数组容器（~~boolean~~ byte short int ~~double~~）

double类型数组容器（byte short int long float double）

数组完整格式：数据类型[] 数组名 = new 数据类型[] { 元素1, 元素2, 元素3…}；//前后数据类型应保持一致

但是过于繁杂，一般只使用简化格式

简化格式：数据类型[] 数组名 = { 元素1, 元素2, 元素3}；

举例：int[] array = { 11, 22, 33}; //完整格式是 int[] array = new int[]{ 11, 22, 33};

double[] array2 = {11.1, 22.2, 33.3};

数组的地址值

如上，执行之后的结果是一串字符，这些是这个数组的地址值。数组的地址值表示数组在内存中的位置。

解释此地址值含义 [I@54bedef2 :

[ ：表示当前是一个数组

I ：表示当前数组里元素类型都为Int类型

@：表示一个间隔符号（固定格式

54bedef2：数组真正的地址值（十六进制）

索引

array	1	2	3	4
索引	0	1	2	3

索引：也叫做下标，角标

特点：从零开始，逐次增加

如上，如果想要输出数组中的第n个数字，则在括号中输出 array[n - 1]。

数组动态规划

初始化格式：数据类型[] 数组名 = new 数据类型[数组长度];

范例： int[] arr = new int[3]; // 创建了一个数据类型为int的数组，他的长度为3（能存放三个数字）

数组默认初始化值规律：

整数类型：默认初始值为0

小数类型：0.0

字符类型：’/u0000’ 空格

布尔类型：false

引用数据类型：null （除了上面四类其他都属于引用数据类型

动态初始化和静态初始化的区别

动态初始化：手动指定数组长度，由系统给出默认初始值

只明确元素个数，不明确具体数值，推荐使用动态初始化

静态初始化：手动指定数组元素，系统根据元素个数，计算出数组长度

需求中明确了要操作的具体数据，直接静态初始化即可

方法（method）

方法（method）是程序中最小的执行单元。同一个方法中的代码要么全部执行，要么都不执行。

格式：

public static void 方法名( ){

执行内容;

}

public static void 跟 main 前三个单词一样，main入口也是一种方法。

举例：

public class Methondemo{
	public static void main(String[] args){
		methon();
	}
	public static methon(){
		System.out.println("这是一个方法");
	}
}

带参数的方法

public class Methondemo{
    public static void main(String[] args){
        sum(1, 2);
    }

    public static void sum(int a, int b){
        int c = a + b;
        System.out.println(c);
    }  
}

如上，仅通过对a，b的值进行修改，就可以计算出多组数的和，而不用重复修改方法内容。其中方法中的参数a、b成为形参，而引用方法sum(1, 2);中的1， 2为实参。

带返回值方法

方法的返回值就是方法运行的最终结果。

格式（只需把方法中的void改成返回值类型即可）：

public static int sum(int a, int b){
	int c = a + b;
	return c;
}

调用方法：

直接调用：方法名( 实参 ); //没有返回值
赋值调用：整数类型变量名 = 方法名(实参);
输出调用：System.out.println( 方法名( 实参 ) );

写方法注意事项

方法不调用就不执行
方法与方法之间是平级关系，不能互相嵌套定义
main方法也可以写在自己定义的方法下面，只不过因为个人习惯放在最前面
return语句之后不能写代码，永远无法执行。无返回值（使用void）可以省略不写

重载

在一个类中，定义了多个同名方法，这些方法具有同种功能
每个方法有不同参数类型或参数个数，这些同名方法就构成重载关系

特点：在同一个类中，方法名相同，参数不同的方法，与返回值无关。

参数不同：个数不同、类型不同、顺序不同

拷贝数组

import java.util.Scanner;

public class copyarr {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        Scanner sc = new Scanner(System.in);

        int from = sc.nextInt();	//从该位置开始复制
        int to = sc.nextInt();		//到该位置复制结束
        int[] b = copy(arr, from, to);
        for (int i = 0; i < b.length; i++){
            System.out.print(b[i] + " ");
        }
    }
	//返回复制后的数组
    public static int[] copy(int[] a, int from, int to){
        int[] b = new int [to - from + 1];
        int index = 0;	//创建一个伪索引
        for (int i = from; i <= to; i++){
            b[index] = a[i];
            index++;
        } 
        return b;
    }
}

和c语言不同的地方：

存在区别	c语言	Java
输出	printf(“abc”); printf(“abc\n”); //换行	System.out.print(“abc”); System.out.println(“abc”);
float和long定义	float f = 114.514; long n = 1145141919;	float f = 114.514F; long n = 1145141919L;
输入	scanf(“%d”, &num);	import Java.util.Scanner; …… Scanner sc = new Scanner(System.in); int num = sc.nextInt();

感觉基本就是这些了（？）后面如果想到什么再另外补充。

第一个程序：

字面量分类

键盘输入

类型转换分类

强制转换

字符和字符串的加操作

三元运算符

分支结构