day1-day5听课笔记

DAY1

Typora常用快捷键

标题快捷键

1.ctrl + 1 一级标题

2.ctrl + 2 二级标题

代码块

ctrl shift k 代码快捷键

```java java语言的代码块

```shell shell语言的代码块 #tab上面的一个键， 按shift切换成英文

列表

1. 有序列表

//有序
ctrl + shift + [

1. 无序列表

   //无序
   ctrl + shift + ]

缩进

1. 增加缩进

   • ctrl + ]

2. 减少缩进

   • ctrl + [

常用操作

ctrl + c // 拷贝
ctrl + v // 粘贴
ctrl + x // 剪切
ctrl + z // 撤销

文字格式

1. 加粗

   • ctrl + b

2. 斜体

   • ctrl + i

3. 下划线

   • ctrl + u

常见的系统快捷键

1. dos 命令

   • 键盘

   • 打开运行窗口

   • 常见命令

     wir + r
     ipconfig //查看ip
     cls //清屏
     ping // 查看ip通否
     ​

     • ping

     • p盘符：去对应的盘符

        

     • cd javase 去javase目录

   • 系统常见快捷键

     • win + e 打开我的电脑

     • win + d 快速回到桌面

     • win + l 锁屏

     • alt + tab 切换窗口

java概述

1. 计算机的组成

   • 硬件：CPU、内存、硬盘、主板

   • 软件：系统软件、应用软件

2. 计算机语言的发展史

3. java语言的发展史

4. java语言特点

   • 简单性，没有指针的概念，不允许通过指针操作内存，只支持单继承。

   • java跨平台

     • 平台：windows linux mac

     • java可以运行到任何操作系统之上

     • 实现跨平台需要java虚拟机jvm

JDK安装

 

环境变量

1. 环境变量的配置

   • 此电脑-右键属性-高级系统设置-环境变量-配置JAVA_HOME-配置path-%JAVA_HOME%\bin

   • 测试 java- version javac -version

jdk与jre关系

1. jdk:它是java的开发运行环境，开发人员需要安装jdk

2. jre：java runtime environment（java运行环境），如果只需要运行程序，不需要开发，可以只安装jre

3. jdk包含了jre

 

java加载和执行的过程

1. 源代码.java -----javac------- 字节码文件 -------java-------- 电脑

2. java源文件：程序员编写的，是.java结尾的

3. 编译：通过javac把java源文件编译成字节码文件（.class结尾）

4. 运行：通过解释器（java）运行字节码文件

5. 需要用到dos命令

java第一个程序HelloWorld.java

1. 建好作业的包，practice是课堂练习，task是作业

2. 新建文件 HelloWorld.txt

3. 编写源代码

   public class HelloWorld {
       public static void main(String[] args) {
           System.out.println("HelloWorld");
       }
   }

4. 代码分析

   • 最外层分析

     public class HelloWord {
         //public 代表公共的，是一个修饰符
         //class 代表类的关键词
         //HelloWorld 类名
         //{}
     }

   • 中间层

     public static void main(String[] args) {
         //public 代表公共的，是一个修饰符
         //static 代表静态的，是一个关键字
         //void 代表没有返回类型
         //main 代表程序入口
         //String[] args 代表数组，程序参数
     } 

   • 内层

     System.out.println("HelloWorld");;//输出语句；输出HelloWorld

5. 常见错误

   • 文件名和类名不同

   • 关键字写错

6. 正常运行

   
   

DAY2

notepad++的安装和使用

1. 打开java文件进行编辑，编辑完成记得ctrl + s保存/。

2. 注意编码

java注释、关键字、标识符

 

java注释

1. 单行注释 // 注释内容

2. 多行注释

   /*

   *注释内容

   */

3. 文档注释/**注释内容 */

关键字

1. 关键字是java语言的一些特殊的字母，具有特殊含义，java中关键字是小写字母开头。

    

标识符

1. 标识符就是名称（命名）意思，定义类，包，方法，变量名，目的是一个号的命名。

2. 标识符的组成

   • 英文的大小写字母a-z A-Z

   • 数字0-9

   • 符号 _ 与 $

3. 标识符

   • 数字不能打头

   • 不可以使用关键字

   • 严格区分大小写，做到见名知意

   • 驼峰命名法

     public class StudentTest {
         //驼峰命名法
     }

计算机的存储单元

1. 计算机的内存是如何存储数据？计算机的最小存储单元叫字节（byte）（B）, 计算机存储设备的最小信息单元叫位（bit）(b)。

2. 存储单元

   • 1B（字节） = 8位

   • 1KB = 1024B

   • 1MB = 1024KB

   • 1GB = 1024MB

   • 1TB = 1024GB

进制的换算

1. 十进制

2. 二进制

3. 八进制（0开头）

4. 十六进制（0x开头）

 

数据类型

1. 基本数据类型（八种）

   • byte 1个字节 -128-127

   • short 2个字节 -32768 - 32767

   • int 4个字节 -2147483648 - 2147483648

   • long 8个字节 -2^63 - 2^63 - 1

   • float 4个字节 -3.403E- 3.403E

   • double 8个字节

   • char 2个字节

   • boolean 1

2. 引用数据类型

   • String（字符串）

   • 其他的引用数据类型（数组，类）

 

基本数据类型的强制转换

1. 需求 定义一个byte类型的数，并且给一个值为300；

2. 问题

3. 解决：强制类型转换加上（数据类型）

   byte b = (byte)300;

4. 需求2：给byte类型的数赋值 128

5. 问题：超过给定的数据范围，就会循环。

DAY3

变量

1. 定义格式

   数据类型 变量名 赋值符号 数值
       int num = 10

2. 代码演示

   public class VariableDemo {
       public static void main(String[] args) {
           //定义一个3.5的变量
           double d = 3.5;
       }
   }

    

常量

1. 定义：永远不会变的量，10，10.3，1000L

2. 代码演示

   public class ConstantDemo {
       public static void main(String[] args) {
           System.out.println(10);
       }
   }

3. 常量不能修改，如被final修饰的值。 修改后会报错。

运算符

1. 运算符是用来计算数据的，数据可以是常量，也可以是变量，被我们运算符操作的数，我们称之为操作数。

2. 算术运算符+、-、*、/、%、++、--

   • +可以做连接符

   • ++a是先++再使用a 、 a++是先使用a再++

赋值运算符

1. 赋值运算符，用来为变量赋值的

2. =、+=、-=、*=、/=、%=

关系运算符

1. 关系运算符又叫比较运算符，用来判断两个操作数大小关系，以及是否相等，结果是boolen类型，true false

2. <、<=、 >、 >=、==、!=

3. 注意：赋值运算的=和关系运算符的==是有区别的，=是做赋值，==是做判断比较。

   int a = 5;
   int b = 10;
   System.out.println(a == b);
   System.out.println(a = b);

拓展内容

1. 二进制运算的原码，反码，补码（Integer.toBinaryString()）

   • 原码：1 00000000 00000000 00000000 00000001

   • 反码：1 00000000 00000000 00000000 00000001

   • 补码 ：1 00000000 00000000 00000000 00000001

     -1这个数的原码、反码、补码
         原码10000000 00000000 00000000 00000001
         反码11111111 11111111 11111111 11111110
         补码 = 反码 + 1
             11111111 11111111 11111111 11111111

2. 计算机以补码为运算

逻辑运算符

1. 逻辑运算符，用与boolean类型的值进运算比较。最终的结果true或者是false

2. & 、|、！、^、&&、||

条件运算符

1. boolean？值1：值2

   true?"xx":"yy"

    

位运算符

1. 当你使用数字操作位运算符时，是使用二进制进行操作的。

2. &、|、^、~、<<、>>

3. >>> 无符号右移

    

IDEA工具的安装

1. 项目和模块的之间的关系：project --> 多个模块 --> 多个包--->多个类（包用域名倒着写）www.baidu.com com.baidu

2. idea快捷键

说明	快捷键
主方法	psvm
单行注释	ctrl + /
多行注释	ctrl + shift + /
文档注释	/** + enter
打印输出语句	sout
删除一行	ctrl + y
复制一行	ctrl + d
代码格式化	ctrl + alt + L
重命名	shift + f6(暂时实现不了)
多行输入	alt + 鼠标左键
上下移动	shift + alt + 方向键
自动生成变量名	ctrl + alt + v

 

DAY4

条件与循环语句

选择结构if

1. if 的定义

   if (boolean) {
       
   }
   if (boolean) {
       
   }
   else {
       
   }

2. if...else 语句

3. if..else if....else if...else

选择结构

1. 定义

   switch(表达式) {
       case 目标值:
           执行语句
           break;
       case 目标值:
           执行语句
           break;
       case 目标值:
           执行语句
           break;
       default:
           执行语句
   }

    

循环语句

while循环

1. 循环：重复相同的步骤

   //定义
   while (boolean) {
       代码块
   }
   ​
   //需求1：播放音乐10次
   //需求2：定义一个变量，从0开始，当变量小于5的时候，计算变量之间的和

    

do...while

1. 先做一次，再判断

   do {
       语句块
   }while (boolean);
   ​
   //需求：不管你之前听音乐听了多少次，当我判断的时候都要一次 播放音乐 < 10

    

for循环

1. for 循环的定义

   for (表达式1; 表达式2; 表达式3) {
       内语句
   }
   外语句
   ​
   执行流程
       第一步：先执行表达式1
       第二步：再执行表达式2
       第三步：再执行内语句
       第四步：再执行表达式3
       第五步：回到表达式2 后面重复2 - 5步，直到表达式2为false
       最后：执行外语句

嵌套循环

1. 特点：最外层的循环执行一次，里面全部执行完，再去执行最外层的代码。

   for (; ;) {
       for (; ;) {
           
       }
   }
   //用*打印一个三角形

    

break

1. 在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句之后，作用是终止某个case并跳出switch结构

   • 需求：定义一个变量num = 1， 当num 大于10的时候，循环停止

2. 标记语法

   可以指定break跳出某一层循环

continue

1. 终止本次循环，继续往下执行

   • 需求：对1 - 100内的奇数求和

2. 注意：continue是停止本次循环，继续执行下一次循环，而break是整体把循环结束

    

DAY5

数组

1. 在生活中，会遇到以下的场景，需求：统计班级学生数量，计算学生的平均年龄，找出学生最老的，找出学生最小的的。

   • 加入我们班有35个人，需要35个变量来表示我们学生的年龄，这样做很麻烦而且很臃肿。

2. 数组的概念：一堆数的组合。20，21，23，20。

3. 数组的length属性，就是数组的长度

4. 数组的索引是从0开始的，也就是数组的下标，最大值是数组的长度-1，也就是length - 1

5. 数组长度一但确定，就不可变。

数组的定义

 

1. 动态定义：数组初始化时，数组的元素是空的。需要我们重新赋值才有数据。

   数据类型[] 数组名 = new 数据类型[元素个数];
   //样例
   int[] ages = new int[35];
   ​
   //赋值
   数组名称[对应的索引]

    

2. 数组的静态定义：数组初始化时候，就已经确定了各索引元素的值

   //方式1
   数据类型[] 数组名称 = new 数据类型[]{数据1, 数据2, 数据3};
   ​
   //方式2
   数据类型[] 数组名称 = {数据1, 数据2, 数据3};

3. 获取值，或者赋值

   给数组元素赋值
   数组名称[索引] = 值;
   //获取值
   数据类型 变量 = 数组名称[索引]

   • length:数组的长度

   • 索引：从0开始，比length少1

数组的遍历

1. 在操作数组时，经常需要去拿元素取元素，这种操作就是数组的遍历

2. 遍历的语法

   //for 循环
   for (int i = 0; i < arr.length; i ++) {
       
   }
   //foreach 遍历
   数组变量名.iter
   for (数据类型 变量名:数组名称) {
       
   }

3. foreach底层其实还是使用我们的for循环

数组的特点

1. 常见问题

   • 索引越界（没有在索引范围内）

   • 数组未初始化

   • 空指针异常

2. 数组元素的特点

   • 数组的元素数据类型必须一致。（char 有ASCII码表对应）

   • 数组元素连续，空间大小一致，并且内存地址连续，呈现线性结构。

   • 数组长度固定之后，不可改变

   • 数组不仅可以存储基本数据类型，还可以存储引用数据类型，数组本身就是引用数据类型。

     String[] strs = {"1", "2", "3"};

3. 优缺点

   • 优点

     • 根据索引去访问元素（快）

     • 能存储较多的数据

   • 缺点

     • 数组的长度固定不可改变（超过容量增加数组元素时，只能用新数组代替）

     • 只能存储一种数据类型

     • 删除很慢，根据内容找索引很慢。

 

数组的拷贝及其扩容

1. 需求：原数组不够放，新增加了元素，只能考虑扩容和拷贝

    //原来的5个同学的年龄
   int[] ages = {12, 13, 21, 19, 23};
   //新加入一个同学 18;
   int[] newAges = new int[ages.length + 1];
   ​
   for (int i = 0; i < ages.length; i++) {
       newAges[i] = ages[i];
   }
   newAges[newAges.length - 1] = 18;
   for (int newAge : newAges) {
       System.out.println(newAge);
   }

    

2. 需求2：从原数组某一个位置开始拷贝，拷贝某一个长度到目标数组里面去

   //从原数组的第2个元素，拷贝3个元素到新数组里面去
   //需求2的实现
   int[] ages2 = {12, 13, 21, 19, 23};
   ​
   int[] newAges2 = new int[3];
   ​
   //第二个元素
   int srcPos = 1;
   //拷贝多长
   int index = 3;
   int destPos = 0;
   for (int i = srcPos; i < srcPos + index; i++) {
       //新数组从目标位置开始拷贝，每次递增
       newAges2[destPos++] = ages2[i];
   }
   System.out.println("--------");
   for (int newAge : newAges2) {
       System.out.println(newAge);
   }

    

数组的工具类Arrays简单了解

1. 需求：int[] ages = {1,3, 4, 5, 6};打印输出的时候，[1,3,4,5,6];

   //Array.toString(ages);
   int[] ages = {1, 3, 4, 5, 6};
   //最后的字符串结果
   String ret = "[";
   for (int i = 0; i < ages.length; i++) {
       //如果当前元素是最后一个元素，就不添加。
       if (i == ages.length - 1) {
           ret += ages[i] + "]";
       }
       else {
           ret += ages[i] + ",";
       }
   //            ret += i == ages.length - 1 ? ages[i] + "]" : ages[i] + ",";
   }
   System.out.println(ret);

 

二维数组

1. 定义：二维数组，就是数组中有数组

   //一维数组
   int[] arr = new int[10];
   动态定义
   int[][] arr2 = new int[2][3];
   //静态定义
   int[][] arrays = new int[][]{{1, 2, 3}, {4, 5}};
   int[][] arrays = {{1, 2, 3}, {1, 4}};

   • 遍历：第一层拿到里面的数组元素（数组），第二层拿到具体的值。

简单算法

1. 交换元素

   //方式1中间变量
   int a = 10;
   int b = 20;
   int temp = a;
   a = b;
   b = temp;
   ​
   //方式2不使用中间变量
   int c = 2;
   int d = 3;
   c = c ^ d;
   d = c ^ d;
   c = c ^ d;

    

冒泡排序

1. 做相邻比较

   int[] heights = {9, 2, 6, 7, 4, 1};
   for (int i = 0; i < heights.length - 1; i++) {
       for (int j = 0; j < heights.length - i - 1; j++) {
           if (heights[j] > heights[j + 1]) {
               heights[j] ^= heights[j + 1];
               heights[j + 1] ^= heights[j];
               heights[j] ^= heights[j + 1];
           }
       }
   }
   System.out.println("最终会");
   System.out.println(Arrays.toString(heights));

    

选择排序

int[] height = {9, 2, 6, 7, 4, 1};
//最外层控制找到最小的元素
for (int i = 0; i < height.length - 1; i++) {
    //定位一个元素，不停的去找最小值
    for (int j = i + 1; j < height.length; j++) {
        if (height[i] > height[j]) {
            height[i] ^= height[j];
            height[j] ^= height[i];
            height[i] ^= height[j];
        }
    }
}
System.out.println(Arrays.toString(height));

 

二分查找

1. 要求：要求数组元素是有序的

   int[] arr = {1, 2, 3, 5 ,6 ,8, 9, 11, 12, 16};
   //目标寻找的数
   int num = 1;
   ​
   //从哪里开始找
   int min = 0;
   int max = arr.length - 1;
   while (min <= max) {
       System.out.print("min " + min);
       System.out.println(" max " + max);
       int mid = (min + max) >> 1;
       int midValue = arr[mid];
       if (midValue < num) {
           min = mid + 1;
       }
       else if(midValue > num){
           max = mid - 1;
       }
       else {
           System.out.println("找到了，当前位置的位置是: " + mid);
           break;
       }
   }

2.