JAVA入门基础知识点（入门到学废1.1）

6.算术运算符

+ - * / %
+= -= *= %= /= (隐含了强制类型转换)   
++ --
== != < > >= <=(关系运算符，结果是true false) 
&& || ! (结果都是boolean) 
& 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常
=======================
    位运算符
& | ~ ^ 
按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0 
按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1
按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
按位异或 ^: 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.
    ======================
    移位运算符
 移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。
     . 左移 <<: 最左侧位不要了, 最右侧补 0（注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数）
右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1))
无符号右移 >>>: 最右侧位不要了, 最左侧补 0
1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
4. 移动负数位或者移位位数过大都没有意义.
==========================================
条件运算符
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.
    
boolean fag = true == true?false?true:false:true;
        System.out.println(fag);//false 

=========================================
    优先级
运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可.
    

7.逻辑结构

7.1顺序结构

• 顺序结构比较简单，按照代码书写的顺序一行一行执行。

7.2分支结构

7.2.1if语句

if(布尔表达式){
// 语句

if(布尔表达式){
// 语句1
}else{
// 语句2
}

if(布尔表达式1){
// 语句1
}else if(布尔表达式2){
// 语句2
}else{
// 语句3

7.2.2switch语句

switch(表达式){
case 常量值1:{
语句1;
[break;]
}
case 常量值2:{
语句2;
[break;]
}
        ...
default:{
内容都不满足时执行语句;
[break;]
}
}

switch的括号内只能是以下类型的表达式：
基本类型：byte、char、short、int，注意不能是long类型
引用类型：String常量串、枚举类型

7.3循环结构

7.3.1while

while(循环条件){
循环语句;
}

break 的功能是让循环提前结束
continue 的功能是跳过这次循环, 立即进入下次循环（回到循环判定条件的那部分）    

7.3.2for循环

for(表达式①;布尔表达式②;表达式③){
表达式④;
表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
表达式2: 循环条件，满则循环继续，否则循环结束
表达式3: 循环变量更新方式

7.3.3do while 循环

do{
循环语句;
}while(循环条件);
先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。

8.方法

• 方法就是一个代码片段. 类似于 C 语言中的 "函数

• 方法的定义

  修饰符 返回值类型 方法名称([参数类型 形参 ...]){
  方法体代码;
  [return 返回值];
  }
  
  //【注意事项】
  1. 修饰符：现阶段直接使用public static 固定搭配
  2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
  void
  3. 方法名字：采用小驼峰命名
  4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
  5. 方法体：方法内部要执行的语句
  6. 在java当中，方法必须写在类当中
  7. 在java当中，方法不能嵌套定义
  8. 在java当中，没有方法声明一说
      
      
      
  

  8.1形参和实参的关系

  形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值
  public static int getSum(int N){ // N是形参
  return (1+N)*N / 2;
  }
  getSum(10); // 10是实参,在方法调用时，形参N用来保存10
  getSum(100); // 100是实参，在方法调用时，形参N用来保存100
  
  public static int add(int a, int b){
  return a + b;
  }
  add(2, 3); // 2和3是实参，在调用时传给形参a和b
  
  注意：在Java中，实参的值永远都是拷贝到形参中，形参和实参本质是两个实体
  public class TestMethod {
  public static void main(String[] args) {
  int a = 10;
  int b = 20;
  swap(a, b);
  System.out.println("main: a = " + a + " b = " + b);
  }
  public static void swap(int x, int y) {
  int tmp = x;
  x = y;
  y = tmp;
  System.out.println("swap: x = " + x + " y = " + y);
  }
  }
  // 运行结果
  swap: x = 20 y = 10
  main: a = 10 b = 20
  可以看到，在swap函数交换之后，形参x和y的值发生了改变，但是main方法中a和b还是交换之前的值，即没有交
  换成功。
  原因：在swap方法调用时，只是将实参a和b中的值拷贝了一份传递给了形参x和y，因此对形参x和y操作不会对实参a和b
  产生任何影响。
  解决办法：传引用类型参数 (例如数组来解决这个问题)
  public class TestMethod {
  public static void main(String[] args) {
  int[] arr = {10, 20};
  swap(arr);
  System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
  }
  public static void swap(int[] arr) {
  int tmp = arr[0];
  arr[0] = arr[1];
  arr[1] = tmp;
  }
  }
  // 运行结果
  arr[0] = 20 arr[1] = 10
  
  

8.2方法重载

public class TestMethod {
public static void main(String[] args) {
int a = 10;
int b = 20;
int ret = add(a, b);
System.out.println("ret = " + ret);
double a2 = 10.5;
double b2 = 20.5;
double ret2 = add(a2, b2);
System.out.println("ret2 = " + ret2);
}
public static int add(int x, int y) {
return x + y;
}
}
// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);
由于参数类型不匹配, 所以不能直接使用现有的 add 方法.


在Java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了
public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}
注意：
1. 方法名必须相同
2. 参数列表必须不同(参数的个数不同、参数的类型不同、类型的次序必须不同)
3. 与返回值类型是否相同无关
// 注意：两个方法如果仅仅只是因为返回值类型不同，是不能构成重载的

8.3方法签名

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就
可以定义方法名相同的方法呢？
方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成
方法完整的名字