day1:java概述，环境变量配置，数与操作数

1.jdk,jvm,jre,环境变量配置：

JRE包括虚拟机，运行时类核心库（rt.jar），主要给已经写好的java程序使用，java程序能在操作系统中 运行，必须有JRE
JDK包含JRE，还包含一些供开发者在JAVA程序开发阶段使用的工具，如javac,javap等，要开发java程序必须安装JDK
jvm：java程序通过JVM形成字节码文件，就可以直接在对应的操作系统上运行
原理：我们通过javac命令使我们编写的java文件生成字节码文件，再通过java命令启动虚拟机，让虚拟机来执行字节码文件
java语言可以跨平台 jvm不可跨平台
环境变量配置
方法一（官方推荐，相对路径）：
1.我的电脑->属性->高级系统设置->环境变量 讲jdk的目录放入path文件中（告诉操作系统去哪里找执行java文件的程序）
classpath:告诉jvm去哪里找执行java文件的程序（现在都是在集成环境集成环境中去写java程序，此项可以不用配置）
2.设置相对路径，%JAVA_HOME%\bin
方法二：
在环境变量的path中，直接将bin目录的全部地址放入即可
https://blog.csdn.net/sinat_30973431/article/details/82556821（有详细注释）

2.Hello world

  1. public class HelloWorld {
  2.     public static void main(String[] args){
  3.         System.out.println("hello world");
  4.     }
  5. }

3.数字存储

原码：给二进制数（字长最高位）看做符号位的表示，称之为二进制数的原码表示
缺点：当两个数以原码进行计算时，符号位和数值位分开计算，效率过低
反码：原码符号位不变，其他的按位取反
补码：符号位和数值位可以一起参与运算，对于正数其原码就是补码表示，对于负数，在原码基础上符 号位不变其余各位按位取反，末位加1
补码转原码：原码和补码互为补码，求原码即对补码求补（符号位不变其余各位依次取反，末位加1）
（特殊的，在补码中，0只有一种表示方式，（原码中有两种，正0和负0））（-127-+127）
（补码中，最高位为1，其余各位都为0（即1,0000000），多表示一个负数即-2^（字长-1） -128）

4.各种进制表示

二进制：由0,1组成，以0b开头，比如0b1100
八进制：由0~7组成，以0开头， 比如014
十进制：由0~9组成，默认10进制，比如12
十六进制：由0~9，A~F(或a~f)表示0~15，以0x开头

5.数据类型

boolean不能直接转换为其他类型
byte,short,char—>int—>long—>float—>double
byte,short,char之间不能相互转换（小类型向大类型转换）

强制类型转换：type a=（type）XX （将XX强制转换为想转换的type类型，如果是低类型向高进制类型转换，按低类型的数据的位数进行取补码，再计算数值，回导致输出错误数据）

day2:运算符与流程控制

运算符

1.算数运算符：+，-，*，/，%，++，—

对于+运算符，Java中还可用于字符串拼接

2.赋值运算符：=, +=, -=, *=, /=, %=

所有的复合运算算符运算规则:
a. 让赋值符号左右两边的操作数，参与运算
b. 将结果赋值给，=左边的变量
ps:复合赋值运算，隐含了强制类型转化

3.关系运算符：==，!=,<,>,>=,<=

== ： 判断是否相等!= : 判断是否不相等5>, <, >=, <=
关系运算符的结果只有两种true or false注意和“=”区分不要把“==”写成“=

4.逻辑运算符：&，|，！，^

  1.     &： 只针对二进制的一位 0或者1，只有两个二进制都为1的时候结果为1，其余全为0
  2.        0 & 1 = 0     0 & 0 = 0    1 & 0 = 0  1 & 1 = 1
  4.    |:  只有两位全为0的时候结果才为0
  5.      0 | 1 = 1    0 | 0 = 0     1 | 0 = 1  1 | 1 = 1
  7.   ^: 相同为0，不同为1
  8.      0 ^ 1 = 1    0 ^ 0 = 0      1 ^ 0 = 1   1 ^ 1 = 0
  9.  性质：
  10.     1. 一个数和它自己异或运算的结果：a ^ a = 0
  11.     2. 任何一个数和0做异或运算：a ^ 0 = a
  12.     （若三个数中有两个数相同，a^b^c可以直接求出与另两个数不相同的数）
  14.    ~: 按位取反(包括符号位)
  15.  & 与运算: true & false = false  true & true = true  false & true = false   false & false = false
  16.      （只要至少有一个操作数是false，结果就是false，只有当两个操作数都是true的时候，&运算的结果，才是true）
  18.  | 或运算:  true | false = true  true | true = true  false & true = true   false | false = false
  19.                 只要至少有一个操作数是true，结果就是true，只有当两个操作数都是false，|运算的结果采薇false
  21.  ! 非运算:  !true = false  !false = true
  23.  ^ 异或运算:  相同为false， 不同为true
  24.          true ^ true = false  false ^ false = false
  25.          true ^ false = true  false ^ true = true
  27.      & VS && 从运算结果的角度，都做与运算，没有区别
  28.      | VS || 运算结果的角度，都做或运算，没有区别
  31.      注意事项:
  32.          1. 单“&”与双“&&”的区别(短路)
  34.             && 与运算比较智能, 当它发现&&运算符的第一个操作数结果已经是false，
  35.                第二个操组数(对应的表达式)不去管他，直接得到结果&&的结果false
  37.            &  这种与运算，比较的死板，即使&第一个操作数，它已经是false，此时它仍然会计算第二个操作数(表达式)，
  38.               在把计算好的两个操作数的结果，做与运算，得到最终结果
  40.            &&: 有短路效果，当第一个操作数为false，直接得出与运算的结果
  42.            | VS ||： || 也会有一个短路效果
  43.            当 || 运算的第一个操作数的结果是true，不会计算第二个操作数(表达式)的值，直接得到||运算的结果true
  45.         2.关于数值范围的描述的表达，比如  1 < a < 10
  47.         3. 异或(^)  VS 或(|)运算符

5.位运算符

三目运算符：(a > b ? a : b)

若a>b为真，则取a，否则取b

  1. // 1. 求 a,b的大者
  2.         a = 100;
  3.         b = 44;
  4.         int c = 0;
  5.         int r = a > b ? a : b;
  7. // 2. a，b 中的大者，和c
  8.         r = r > c ? r : c;
  9.         System.out.println(r);
  11. // 三目运算的嵌套
  12.         r = (a > b ? a : b) > c ? (a > b ? a : b) : c;

6.导包语句：

  1. 1.导包语句(放到class定义的上面)：
  2.        import java.util.Scanner;
  4. 2.创建对象
  5.         Scanner sc = new Scanner(System.in);// sc是一个标识符，是可以变的
  7. 3.从键盘输入读取数据
  8.          int x = sc.nextInt();
  9.          x是我们自己定义的一个接收键盘输入的整型变量，x名字可变
  10.  eg:
  11.     import java.util.Scanner;
  12.     public class Demo1 {
  13.     public static void main(String[] args) {
  15.         // 2. 创建Scanner对象
  16.         Scanner scanner = new Scanner(System.in);
  18.         // 3. 利用Scanner对象的nextXxx方法读取键盘输入的值
  19.         int first = scanner.nextInt();
  20.         int second = scanner.nextInt();
  21.         System.out.println(first);
  22.         System.out.println(second);
  25.     }
  26. }

流程控制

1.顺序结构

顺序结构描述的是Java语句之间，从上到下(或从左到右)依次执行的执行顺序（先写先执行）

2.选择结构

选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断
Java中，选择结构有2种实现形式，if语句 和switch语句
if的使用场景 针对结果是boolean类型的判断 对多种不同条件的选择（if 语句多选一）
switch的使用场景 针对结果是固定类型的判断 表达式的取值范围只是固定的离散值集合，分支对应表达式的某一种取值（注意switch中的break语句，可以有效控制case穿越）

3.循环结构

我们可以利用循环结构，来实现重复执行的特征。从语法上来讲，有3种实现形式：for、while、do while（do while循环至少执行一次）
不管哪种实现形式，都由4部分组成： 

  1.   - 初始化语句:    记录循环的初始状态 （一条赋值语句）
  2.   - 条件判断语句:  判断 是否 应该继续重复(一定是一个关系表达式)
  3.   - 循环体语句:    我们要重复执行的动作循环控制语句:  改变循环状态
  4.   - 循环控制语句：改变循环状态

while 与 for 循环的区别，for循环适合针对一个范围判断进行操作(循环次
数比较明确），while循环适合判断次数不明确操作

day3:循环控制、方法与数组

1.循环控制（补充）：

为了实现对循环结构更加细粒度的控制，我们得通过跳转控制 

  1. //1.break 中断： 跳出单层循环，结束switch语句（如果要跳出整层循环，可用带标签的break） 
  2. outer:
  3.         for (int i = 0; i < 3; i++) {
  4.             for (int j = 0; j < 3; j++) {
  5.                 System.out.println("i = " + i + ", j = " + j);
  6.                 if (j == 0) {
  7.                     break outer;
  8.                 }
  9.             }
  10.         }
  11. //2.continue:退出循环的一次迭代过程，也可以使用标签
  12. outer:
  13.         for (int i = 0; i < 3; i++) {
  14.             for (int j = 0; j < 3; j++) {
  15.                 System.out.println("i = " + i + ", j = " + j);
  16.                 if (j == 0) {
  17.                     //continue outer;
  18.                     break;
  19.                 }
  20.             }
  21.         }                            //此时达到的效果与break相同
  23. //3.return:更常用的功能是结束一个方法，也就是退出一个方法,也可以用于退出循环

2.方法：

1.定义：

方法就是完成特定功能的代码块(在有些其他语言中，也称为函数)

2.定义格式：

  1.  修饰符  方法返回值类型  方法名(参数1类型 参数1名称, 参数2类型 参数2名称, ……) {
  2.                       方法体语句;
  3.                       return 返回值；
  4.                }
  5. 方法定义的格式说明：
  6.             修饰符：现在先认为是固定的 public static
  7.             返回值类型：方法体中的代码执行结果的数据类型
  8.             方法名 ：标识符
  9.             参数 ：类比数学中函数的自变量 z = f(x, y), 一个参数的本质，就是一个变量
  10.             方法体：实现具体功能的语句结合
  11.             return：跳转控制关键字，如果计算结果，返回计算的最终结果
  12.             返回值：方法执行的到的最终结果

3.书写范例：

  1.  1.两个明确     
  2.         a.返回值类型 明确功能结果的数据类型（方法功能来确定）
  3.     b.参数列表 明确有几个参数，以及参数的类型()
  5.  2.按照格式和两个明确来完成如下功能
  6.         a. 有返回值的方法
  7.            求两个（int 类型）数据之和的案例
  9.         b. 没有返回值的方法
  10.            用void声明，方法没有返回值
  11.        注意：return 返回值；这句并非必须（针对没有返回值的方法）

_

  1.  public static int add(int a, int b) {
  2.         int result = a + b;
  3.         return result;
  4.     }
  6.     public static  void  print(String s) {
  7.         System.out.println("hello, " + s);
  8.         return;
  9.     }

4.方法重载：

a. 在同一个类中，允许存在一个以上的同名方法
b.只要它们的
1)参数个数
2)参数类型不同
3)参数顺序不同（这里的参数顺序，不是变量名的顺序，而是参数的类型顺序）

编译器是根据方法签名，唯一确定一个方法的
方法签名： 方法名 + 参数列表

3.数组

1.数组的定义：

数据类型[] 数组名;

2.数组的初始化：

1.Java中的数组必须先初始化,然后才能使用。
2.所谓初始化：
a. 就是为数组中的数组元素分配内存空间
b. 并为每个数组元素赋初值

数组的初始化方式：
1. 动态初始化
初始化时程序猿只指定数组长度，由系统为数组分配初始值。
int[] arr = new int[3];
（ 数组长度其实就是数组中元素的个数。）

  1. 静态初始化
    初始化时指定每个数组元素的初始值，由系统决定数组长度。
    格式： 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
    int[] arr = new int[]{1,2,3};
    简化写法：
    int[] arr = {1,2,3};（简化写法只在数组定义时有效！）

    3.数组操作常见错误

    _ 1.数组索引越界 ArrayIndexOutOfBoundsException
    访问了数组中不存在的存储单元(元素)
     2.空指针异常 NullPointerException
    null空常量，表示无效的内存地址(内存中不存在的东西)