java基础-标识符、数据类型、运算符、流程控制、数组

标识符

java 对包名 类名 方法名 变量名 参数名等命名时采用的字符序列

规则：

1. 由 字母 数字 下划线 美元符（$）组成
2. 不能以数字开头
3. 严格区分大小写
4. 不能是java中的关键字和保留字
   

规范：

5. 见名知意
   例：username，password
6. 驼峰命名：当变量名 方法名 参数名 由两个或两个以上单词组成时
   例：userName，passWord
7. 对常量进行命名时，每个单词的字母都大写，单词之间下划线相连
   例：USER_NAME
8. 对类命名时，每个单词首字母大写

---

数据类型

1. 基本数据类型：四类八种
   整数型 ：byte 、short 、int、long
   浮点类型（小数）：float、double
   字符型：char
   布尔型：boolean（true、false）
2. 引用数据类型：类、接口、数组

常量：固定不变的量

final

1. 修饰类时，此类不能被继承
2. 修饰方法时，子类不能重写
3. final修饰的【变量：成原变量，局部变量】是常量（固定不变的量，不能修改）
4. final修饰的对象地址值不能改变

变量：在java运行过程中值可以改变的量

数据类型 变量名 变量值
先声明 在赋值

运算符

分类	运算符
算数运算符	+、-、*、/、%、++、–
赋值运算符	=、+=、-=、*=、/=、%=等
关系运算符	>、>=、<、<=、==、!=
逻辑运算符	&、丨 、^、！、&&(短路：有假则假)、丨丨(短路：有真则真)
条件运算符	（条件表达式）？结果1：结果2；
位运算符	&、丨、~、^、<<、>>、>>>

流程控制

输入语句

Scanner:接收键盘录入的数据
使用方法：导包->创建对象->对象调用方法

import java.util.*;//导入java.util包下的资源
class Test{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);//创建对象
		//对象调方法
		String name = scanner.next();//无法接收空格之后的内容
		//String name = scanner.nextLine();可以接收整行内容，可接收空格，接收到回车终止
		int age = scanner.nextInt();
		double height = scanner.nextDouble();
		char c = name.charAt(0);//Scanner没有提供返回char类型数据的方法，可采用：char c = "字符串".charAt(下标); 
		System.out.prinln("字符："+c);
		System.out.println("姓名："+name);
				System.out.println("年龄："+age);
						System.out.println("身高："+height);
	}
}

if分支

if单分支	↓
if(表达式1){
	分支1
} 只有一条语句时可省略{}
if双分支 ↓
if(表达式1){
	分支1
}else{
	分支2
}
if多分支 ↓
if(表达式1){
	分支1
}else if(表达式2){
	分支2
}else if(表达式3){
	分支3
}……

判断输入年份是不是闰年 ↓

import java.util.*;
class Test{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个年份");
		int year = scanner.nextInt();
		if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
		{
			System.out.println(year+"是闰年");
		}else{
			System.out.println(year+"不是闰年");
		}
	}
}

switch

switch
输入分数输出等级 ↓

import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的分数");
        int score = scanner.nextInt();
        switch (score/10){
            case 10:
            case 9:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
                break;
            case 7:
                System.out.println("C");
                break;
            case 6:
                System.out.println("D");
                break;
            default://默认
                System.out.printf("不及格");
                break;
        }
    }
}

循环:while do-while for

一般情况如何选择循环结构？

1. 当循环次数固定的时候用 for
2. 当循环次数不固定的时候用 while
3. 当初始化条件不满足循环条件，也想执行一次循环体用 do-while

while循环：0到100的和 ↓

条件初始化
while(循环条件){
	循环体语句;
	迭代条件;
}

public class Test {
    public static void main(String[] args) {
      int i = 0;
      int sum = 0;
      while (i<=100)
      {
          sum += i;
          i++;
      }
        System.out.printf("0-100的和："+sum);
    }
}

do-while循环：0到100的和 ↓：至少执行一次循环

条件初始化
do{
	循环体语句;
	迭代条件;
}while(循环条件);
**当初始化条件，不满足循环条件也会执行一次循环体**

public class Test {
    public static void main(String[] args) {
      int i = 0;
      int sum = 0;
      do{
          sum +=i;
          i++;

      }while(i<=100);
        System.out.printf("0-100的和："+sum);
    }
}

for循环：0到100的和

for(初始化条件;循环条件;迭代条件){
	循环体;
 }

public class Test {
    public static void main(String[] args) {
        int sum = 0;
        for(int i =0;i<=100;i++){
            sum = sum+i;
        }
        System.out.println("0-100的和："+sum);
    }
}

continue and break

特殊的流程控制语句下，不能存在其他内容，因为无法访问！

continue：结束本次循环，继续下一次循环
只能用在循环

public class Test {
    public static void main(String[] args) {
        for(int i =0;i<=10;i++){
            if(i==6){
                continue;//当i==6时结束本次循环，执行下一次循环，不会输出6
            }
            System.out.println(i);

        }
    }
}

break：结束循环
可用在 循环 和 switch 中

public class Test {
    public static void main(String[] args) {
        for(int i =0;i<=10;i++){
            if(i==6){
                break;//当i==6时结束循环，6-10不会被输出
            }
            System.out.println(i);
        }
    }
}

return

1. 结束方法
2. 将值返回到方法调用处
   注：如果一个方法带有返回值类型，必须返回一个对应的值，否则报错

public class Test {
    public static void main(String[] args) {
        for(int i =0;i<=10;i++){
            if(i==6){
                return;//当i==6时结束main方法，6-10不会输出
            }
            System.out.println(i);
        }
        System.out.println("return");//不会输出
    }
}

数组

一维数组

相同类型数据的有序集合（数组内元素的类型要保持一致）

public class Test {
    public static void main(String[] args) {
       //声明数组
       int[] Arr ;//推荐使用
       int Arr1[];

       //数组的初始化     两种

       //静态初始化     已经指定元素
       Arr = new int[]{1,2,3,4,5};
       int[] arr1 = new int[]{1,2,3,4,5};//声明和赋值可分开
       int[] arr ={1,2,3,4,5};//这种方法：声明和赋值必须放在一起
        //访问数组元素：以下标的方式访问
        System.out.println(arr[0]);//输出arr数组里的第一个元素
        System.out.println(arr.length);//输出arr数组的长度
        System.out.println(arr[arr.length-1]);//输出arr数组里的最后一个元素

       //动态初始化      没有指定元素
        /**
         数组默认初始化：
         声明之后，数组类型不同，默认值不同：
          byte 0、short 0、int 0、long 0、float 0、double 0.0、char ‘\u000’、boolean false
          引用数据类型，默认值都是null :String
        */
        Arr1 = new int[4];
        int[] arr2 = new int[4];

        //遍历
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);;
        }
        /*增强for循环
        for (数组的类型 标识符:数组名) {
            标识符:数组内的元素
        }*/
        for (int e:arr) {
            System.out.println(e);
        }
    }
}

二维数组

存储一维数组的数组

class Test{
	public static void main(String[] args){
		//二维数组的声明
		int[][] arr;//推荐使用
		int[] arr1[];
		int arr2 [][];
		//静态初始化
		//方式1：数据类型[][] 标识符 = {{一维数组元素},{一维数组元素},……};
		int[][] arr3 = {{1,2},{3,4}};
		//方式2：数据类型[][] 标识符 = new int[][]{{一维数组元素},{一维数组元素},……};
		int[][] arr4 = new int[][]{{1,2},{2,3}}
		System.out.println(arr3[0][0]);//输出 1
		System.out.println(arr3[1][0]);//输出 3 
		System.out.println(arr3.length]);//输出 1,二维数组的长度为一维数组的个数
		
		//动态初始化
		//方法1：数据类型[][] 标识符 = new 数据类型[一维数组的个数][一维数组元素的个数];
		int[][] arr5 = new int[3][2];
		//方法2：数据类型[][] 标识符 = new 数据类型[一维数组的个数][];
		int[][] arr6 = new int[2][];
		//System.out.plintln(arr6[0][0]);//空指针报错
		arr6[0] = new int[]{1,2,3};//静态初始化给第一个一维数组赋值
		arr6[1] = new int[2];//动态初始化给第二个一维数组赋值

		//二维数组遍历
		//for循环
		int[][] arr7 = {{1,2},{3,4,5}};
		for(int i = 0;i < arr7.length;i++){
			for(int j = 0;j < arr7[i].length;j++){
				System.out.println(arr7[i][j]);//i表示第几个一维数组，j表示一维数组的第几个元素
			}
			System.out.println();//换行
		}
		//增强for循环
		for(int[] e:arr7){//e代表二维数组内的元素即一维数组
			for(int ele:e){//遍历二维数组内的一维数组
				System.out.print(ele+"\t");
			}
			System.out.plintln();
		}
	}
}

对象类型数组

public class Test{
	public static void main(String[] args){
		Person person = new Person();
		person.name = "张三";
		person.age = 18;
		Person person1 = new Person();
		person1.name = "李四";
		person1.age = 19;
		//数据类型[] 标识符 = {数据类型的元素};
		Person[] perArr = {person,person1};
		for(Person p:perArr){
			p.show();
		}
	}
}
class Person{
	String name;
	int age;
	public void show(){
		System.out.println("名字是："+name+",年龄是："+age);
	}
}