【Java 1】Java的基础语法

一、Java运算符

1.1.1 运算符和表达式

运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

int a = 10;
int b = 20;
int c = a + b;

+：是运算符，并且是算术运算符。
a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

1.1.2 算术运算符

符号	作用	说明
+	加	参看小学一年级
-	减	参看小学一年级
*	乘	参看小学二年级，与“×”相同
/	除	参看小学二年级，与“÷”相同
%	取余	获取的是两个数据做除法的余数

注意：

1. /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

int a = 10;
int b = 3;
System.out.println(a / b); // 输出结果3
System.out.println(a % b); // 输出结果1

1.1.3 “+”号运算的特殊

字符类型参与算术运算，使用的是计算机底层对应的十进制数值;

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：
byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
​等级顺序：byte,short,char --> int --> long --> float --> double

int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("itheima"+ 666); // 输出：itheima666

1.2 赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意：
扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报错，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

1.3 自增自减运算符

符号	作用	说明
++	自增	变量的值加1
–	自减	变量的值减1

注意事项：

​ ++和-- 既可以放在变量的后边，也可以放在变量的前边。
​ 单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
​ 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
​ 参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。
​ 最常见的用法：单独使用。

int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

1.4 关系运算符

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：
​ 关系运算符的结果都是boolean类型，要么是true，要么是false。
​ 千万不要把“”误写成“=”，"“是判断是否相等的关系，”="是赋值。

1.5 逻辑运算符

• 逻辑与&，无论左边真假，右边都要执行。

• 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

• 逻辑或|，无论左边真假，右边都要执行。

• 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
|	逻辑或	a|b，a和b都是false，结果为false，否则为true
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

1.6 三元运算符

int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

1.7 数据输入Scanner

1、导包。Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。

import java.util.Scanner; 

2、创建Scanner对象。

Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变

3、接收数据

int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

二、流程控制语句

2.1 if语句格式

格式：
if (关系表达式) {
   语句体1;	
} else {
   语句体2;	
}

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

2.2 switch语句

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

举例

public class Demo1 {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
        //case穿透
        switch(month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }
    }
}

2.3 for循环结构

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}

举例：冒泡排序

    public static void max_Arr(int [] arr){
        int temp;
        for (int i = 0;i<arr.length;i++){
            for(int j = arr.length-1;j>i;j--) {
                if (arr[j] > arr[j - 1]) {
                    temp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(arr[0]);
    }

2.4 while结构

初始化语句;
while (条件判断语句) {
	循环体语句;
    条件控制语句;
}

举例：

//需求：在控制台输出5次"HelloWorld"
		//for循环实现
		for(int i=1; i<=5; i++) {
			System.out.println("HelloWorld");
		}
		
		//while循环实现
		int j = 1;
		while(j<=5) {
			System.out.println("HelloWorld");
			j++;
		}

2.5 do…while循环结构

初始化语句;
do {
	循环体语句;
	条件控制语句;
}while(条件判断语句);

2.6 三种循环的区别

• 三种循环的区别
  • for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
  • do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
• for循环和while的区别
  • 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
  • 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
• 死循环（无限循环）的三种格式
  1. for(;😉{}
  2. while(true){}
  3. do {} while(true);

2.7 跳转控制语句

• 跳转控制语句（break）
  • 跳出循环，结束循环
• 跳转控制语句（continue）
  • 跳过本次循环，继续下次循环
• 注意： continue只能在循环中进行使用！

三、java导包（Scanner、Random……）

3.1 Random

• 使用步骤：

  1. 导入包

     import java.util.Random;

  2. 创建对象

     Random r = new Random();

  3. 产生随机数

     int num = r.nextInt(10);

     解释： 10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19

四、数组

4.1 数组定义格式

int[] arr;        
double[] arr;      
char[] arr;

int arr[];
double arr[];
char arr[];

4.2 动态/静态-数组定义格式

####### 4.2.1 动态定义数组

数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

####### 4.2.2 静态定义数组

• 完整版格式

  数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
  

• 简化版格式

  数据类型[] 数组名 = {元素1,元素2,...};
  

####### 4.2.3什么是索引

​ 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

​ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

####### 4.2.4访问数组元素格式

数组名[索引];

五、方法

5.1 方法的概念

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

• 注意：
  • 方法必须先创建才可以使用，该过程称为：方法定义
  • 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程称为：方法调用

5.2 方法的定义和调用

public static void 方法名 (   ) {
	// 方法体;
}

• 调用格式：

方法名();

5.3 带参数方法的定义和调用

public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

public static void isEvenNumber(int number){
    ...
}
public static void getMax(int num1, int num2){
    ...
}

方法名(参数)；

方法名(参数1,参数2);

5.4 带返回值方法的定义和调用

public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

• 调用格式

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

5.5 方法的注意事项

• 方法不能嵌套定义

• void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

• 方法的通用格式：

  public static 返回值类型 方法名(参数) {
     方法体; 
     return 数据 ;
  }
  

六、方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

• 多个方法在同一个类中

• 多个方法具有相同的方法名

• 多个方法的参数不相同，类型不同或者数量不同

• 注意：

  • 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
  • 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
    举例：

  举例一：参数类型不同（在一个class、方法名称一致）
  public class MethodDemo {
  	public static void fn(int a) {
      	//方法体
      }
      public static int fn(double a) {
      	//方法体
      }
  }
  举例二：参数数目不同（在一个class、方法名称一致）
  public class MethodDemo {
  	public static float fn(int a) {
      	//方法体
      }
      public static int fn(int a , int b) {
      	//方法体
      }
  }
  

  七、方法重载-示例

  public class MethodTest {
      public static void main(String[] args) {
          //调用方法
          System.out.println(compare(10, 20));
          System.out.println(compare((byte) 10, (byte) 20));
          System.out.println(compare((short) 10, (short) 20));
          System.out.println(compare(10L, 20L));
      }
  
      //int
      public static boolean compare(int a, int b) {
          System.out.println("int");
          return a == b;
      }
  
      //byte
      public static boolean compare(byte a, byte b) {
          System.out.println("byte");
          return a == b;
      }
  
      //short
      public static boolean compare(short a, short b) {
          System.out.println("short");
          return a == b;
      }
  
      //long
      public static boolean compare(long a, long b) {
          System.out.println("long");
          return a == b;
      }
  
  }
  

  八、方法入参（基本类型、引用类型）的区别

  • 基本数据类型的参数，形式参数的改变，不影响实际参数

  public class ArgsDemo01 {
      public static void main(String[] args) {
          int number = 100;
          System.out.println("调用change方法前：" + number);//100
          change(number);
          System.out.println("调用change方法后：" + number);//还是：100
      }
  
      public static void change(int number) {
          number = 200;
      }
  }
  
  

  • 对于引用类型的参数，形式参数的改变，影响实际参数的值

  public class ArgsDemo02 {
      public static void main(String[] args) {
          int[] arr = {10, 20, 30};
          System.out.println("调用change方法前：" + arr[1]);// arr数组的第二个元素：20
          change(arr);
          System.out.println("调用change方法后：" + arr[1]);// arr数组的第二个元素 变了：200
      }
  
      public static void change(int[] arr) {
          arr[1] = 200;
      }
  }