基础知识总结01

不定时更新学习总结。

day01

java概述

java语言：创始人是詹姆斯.高斯林， 所在公司为sun公司（1995-2006） Oracle（2006-至今）
java为什么能跨平台运行？
因为java虚拟机的存在，java虚拟机由Oracle公司提供，不同的平台对应不同的虚拟机版本，这使得java的代码能在所有已安装jdk的机器上运行。
开发的准备工作：
安装JDK，JDK包括开发工具包和JRE+开发工具
JRE【java运行环境】包括JVM+核心类库，JVM-java虚拟机让java运行的环境，核心类库-JDK提供的一些已经写好的核心类
开发工具：javac.exe命令用作编译java代码。java.exe命令用作运行.class代码。

注释

1.注释包括单行注释（//）及多行注释（/* */）

单行注释：//+注释内容

多行注释：/* + 注释内容 + */

2.idea部分快捷键

Ctrl+d  复制当前行数据到下一行

Ctrl+y  删除所在行，建议用Ctrl+x

ctrl+Alt+l格式化代码（与其他应用快捷键冲突）

Alt+shift+↑+↓  上下移动当前代码啊

3.idea快速键入部分代码

psvm  main（主方法）

sout  System.out.println("输出")

字面量

字面量就是java程序中的数据

数据分类：整型（int） 浮点型（double，float） 字符型（char） 字符串型（String） 布尔型（boolean）

变量

• 认识变量
  用来存数据的空间（在内存中开辟一个空间）
  对于数据的操作更加的灵活、方便
  格式：数据类型 变量名 = 数据值；（注意分号不能丢）
  格式中的数据类型告诉计算机开辟空间的大小以及存储的数据类型
  格式中的变量名是用于标识变量空间、方便空间中数据的查找
• 变量的应用场景
  操作数据
• 使用时的注意事项
  1.定义什么类型的变量就只能存对应类型的数据
  2.变量在使用前，必须赋值
  3.变量的作用域只在它所在的大括号内有效
  4.变量不能同名
  5.变量可以一行定义多个
  

关键字、标识符

关键字（全部小写）是在java中被赋予了特殊含义的单词，它一般在程序中有特定的作用，只有使用到的时候才能用，不能在其他地方乱用。如图

注意 ：虽然 true, false, 和 null 看起来像关键字但实际上他们是字面值，同时也不可以作为标识符来使用。
标识符（类名、方法名、变量名的一个统称）

标识符的命名规则：

1.必须是大小写的英文、数字、$、_组成。

2.不能以数字开头

3.不能使用关键字

标识符的命名规范：

1.类名（大驼峰：HelloWorld）

2.方法名。变量名（小驼峰：number是变量   getNumber（）是方法）

[========]

day02

类型转换

隐式类型转换
数据类型由小转到大时，自动进行转换
byte b = 10; int a = b;
不同数据类型，在运行时会自动把小的类型的变量提升为大的类型的变量。
byte/short/char类型的变量在运算时，都会自动提升为int类型的变量。
强制类型转换
数据类型由大转到小时，需要进行强制转换
byte b1 = (byte) 300;
强制类型转换可能存在丢失精度，丢失数据的问题。
常量优化机制
多个常量运算时，会在编译的时候直接运算好并直接赋值给变量。
byte b = 10 + 20；

点击查看代码

public class Demo03 {
    public static void main(String[] args) {
        //小类型赋值给大类型：隐式类型转换 a-->b 没问题
        int a = 10;
        System.out.println(a);
        long b = a;
        System.out.println(b);
        //不同数据类型进行运算，小类型的变量会提升到大类型
        byte d = 10;
        System.out.println(d);
        int e = 15;
        System.out.println(e);
        int f = e+d;//byte d 转成了 int d 再运算
        System.out.println(f);
        //数据类型大小排序byte < short/char < int < long < float < double

        //大类型的变量强制转换成小类型
        byte b1 = (byte) 300;
        System.out.println("b1数据 " + b1);
        System.out.println("300的二进制 " + Integer.toBinaryString(300));
        System.out.println("b1的二进制 " + Integer.toBinaryString(b1));//造成了数据丢失
        //byte只有八位所以强转后数据溢出了    b的二进制: 0010 1100  最高位为0 正数 不用进行反码补码的转码计算
        //但是在大类型的变流的数据没有超过转成的小类型时，不会数据溢出丢失。
        //注意：不能直接赋值
        int d1 = 10;
        byte x1 = (byte)d1;
        System.out.println(x1);

        byte c1 = 10;
        byte c2 = 20;
        //byte c3 = c1 + c2; 报错
        //常量优化机制
        byte c4 = 10 + 20;

补充计算机底层二进制运算！

各类运算符

算术运算符
+、-、*、/：

1.两个整数相除，结果一定是整数。
2.想要得到浮点数，必须要有浮点数参与运算。

%：

1.得到两数相除的余数 
int a = 10%6; //结果为4

++、-- ：

1.变量自增1、或自减1
符号在前：先自增/自减，再用。
符号在后：先用，再自增/自减。
单独使用没有区别。

赋值运算符
=、+=、-=.....

int a = 10; a += 10; a = a + 10;
注意：+=这些符号的内部隐含了一个强制类型转换。

代码举例

点击查看代码

public class Demo04 {
    public static void main(String[] args) {
        //算术运算符
        //+ - * /
        System.out.println(1+1);
        System.out.println(1-1);
        System.out.println(2*4);
        System.out.println(10/4);//java中整数相除，结果一定是整数
        System.out.println(10.0/4);//如果想要得到浮点数，必须要有浮点数参与运算
        System.out.println("-------------");
        //字符可以转成数字，所以可以进行加减乘除任意操作
        System.out.println('a'+'w'*'m');
        System.out.println("-------------");
        //字符串不能转成数字，所以不能进行算术操作，只能进行字符串拼接
        //300天地无极，乾坤借法100200
        System.out.println(100+200+"天地无极，乾坤借法"+100+200);//算术运算从左往右
        //% 取余
        System.out.println(10%3);
        //判断奇数偶数
        System.out.println(10%2);
        //++  --  变量的自增1和自减1
        // a++ [先用后加]   ++a [先加后用]   单独使用没有区别
        int a = 10;
        a++;
        System.out.println(a);
        a--;
        System.out.println(a);
        //面试题
        int i = 0;
        //       1    1     3    3
        int k = ++i + i++ + ++i + i;
        System.out.println("i= "+i);
        System.out.println("i= "+k);
        //赋值运算符：=  +=  -=  *=  /=  %=
        //除了=意外的赋值运算符内部都隐含了强制类型转换
        int c = 10;
        c += 10;
        System.out.println(c);
        c -= 2;
        System.out.println(c);
        c *= 5;
        System.out.println(c);
        c /= 5;
        System.out.println(c);
        c %= 2;
        System.out.println(c);
        System.out.println("-----------------");
    }
}

关系运算符(> / >= / < / <= / == / !=)
关系运算符的结果一定是一个boolean值。

逻辑运算符（连接多个关系表达式）
&：逻辑与【并且】 多个条件必须同时满足，结果才为true
|: 逻辑或【或者】 满足其中一个条件，结果为true
^: 逻辑异或【互斥】 相同为false 不同为true
!: 逻辑非【取反】
&&: 短路逻辑与 false&&xxx=false(左边为false，右边不执行)
||: 短路逻辑或 true || xxx =true(左边为true，右边不执行)

三元运算符：用作判断
格式为: 布尔表达式 ？ 表达式1 ：表达式2;

	真       执行表达式1
	假      执行表达式2

点击查看代码

public class Demo05 {
    public static void main(String[] args) {
        //关系运算符：>  >=  <  <=  ==  != (完成比较或判断)
        int money = 10;
        System.out.println(money > 10);
        System.out.println(money >= 10);
        System.out.println(money < 10);
        System.out.println(money <= 10);
        System.out.println(money == 10);
        System.out.println(money != 10);
        System.out.println("-------------");
        //逻辑运算符是用来连接多个关系表达式的
        //逻辑运算符 &：逻辑与【并且】 多个条件必须同时满足，结果才为true
        //逻辑运算符 |: 逻辑或【或者】 满足其中一个条件，结果为true
        //逻辑运算符 ^: 逻辑异或【互斥】 相同为false  不同为true
        //逻辑运算符 !: 逻辑非【取反】

        System.out.println(true & false);
        System.out.println(true & true);
        System.out.println(false & false);
        System.out.println(false & true);
        System.out.println("-------------");
        System.out.println(true | false);
        System.out.println(true | true);
        System.out.println(false | false);
        System.out.println(false | true);
        System.out.println("-------------------");
        System.out.println(true ^ false);
        System.out.println(true ^ true);
        System.out.println(false ^ false);
        System.out.println(false ^ true);
        System.out.println("-----------------");
        System.out.println(!false);
        System.out.println(!true);
        System.out.println("----------------");
        //逻辑运算符 &&: 短路逻辑与  false&&xxx=false(左边为false，右边不执行)
        //逻辑运算符 ||: 短路逻辑或  true || xxx =true(左边为true，右边不执行)
        int a1 = 10;
        int b1 = 20;
        System.out.println(++a1 <= 10 && b1++ > 20);
        System.out.println("a1 = "+a1);
        System.out.println("b1 = "+b1);
        System.out.println("----------------");


        int x = 10;
        int y = 20;
        System.out.println(x++ != 10 || ++y == 20);
        System.out.println("x = "+x);
        System.out.println("y = "+y);
        System.out.println("----------------");

        //运算符优先级：&& > ||
        System.out.println(true || false && false);
        System.out.println((true || false) && false);
        System.out.println("----------------");


        //三元运算符：用作判断
        //格式为: 布尔表达式 ？ 表达式1 ：表达式2;
        //         真       执行表达式1
        //          假      执行表达式2
        int q = 10,w = 20,e = 30;
        int temp = q > w ? q : w;
        int max = temp > e ? temp : e;
        System.out.println(max);
    }
}

键盘录入

[========]

day03

流程控制

流程控制就是程序的执行结构

顺序结构
代码从上往下逐行执行

分支结构
根据条件判断，选择执行某些代码
if语句（完成判断）

1.if（判断条件）{语句体}
2.if（）{}else{}
3.if(){}else if(){}...else
注意：if()小括号后不要写分号。if(){}后面的大括号可以省略，但是省略之后只能控制离他最近的一行代码。

Switch语句（完成等值匹配）

switch(变量){
case 常量：
语句体;
break;
....
default:
语句体;
break;
}
注意：
1. switch只能做【等值匹配】，不能做范围的判断。
2. switch小括号中，只能放 byte/short/char/int/String/枚举 这几种数据类型的变量。
3. case后面只能跟常量，且不能重复。
4. default效果等同于 else，如果上面case都匹配不成功，则执行default，也可以不写。
5. break可以不写，但是不写会造成case穿透。

循环结构
让程序帮我们执行一些重复的代码

for循环

格式：
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
初始化语句：定义一个变量
条件判断语句：判断循环是否继续
条件控制语句：控制变量的变化
循环体语句：需要重复执行的代码
快捷键：n.fori
执行流程：
1. 先初始化变量
2. 判断条件是否成立
2.1. 成立，则执行循环体语句
2.2 不成立，则循环结束
3. 循环完，再执行条件控制语句

while循环（与for循环效果一样）

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

do...while循环（基本不会用到，先执行后判断）

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

使用场景
1.for:明确循环次数，因为在一行中，能看到所有的循环条件。
2.while: 不明确循环次数，因为循环条件，分布在三个不同的地方。

死循环

循环一直执行
for(;;){}
while(true){}
do{}while(true);
注意：如果死循环没有结束条件，那么循环下面的代码，永远无法执行，就会报错。

循环控制语句

break:
	结束整个循环
continue:
	结束本轮循环，直接进入下一轮循环
注意：
	break可以在循环、switch中使用
	continue只能在循环中使用

循环嵌套

就是循环中，套一个循环
执行特点：
	外层循环执行一次，内循环需要执行全部。
	例如：时钟。分钟每走一分钟，秒钟走一圈。

随机数

随机数

让程序在运行过程中，随机生存一个数字。
死步骤：
	1、 导包
	import java.util.Random；
	2. 创建对象
	Random r = new Random();
	3. 调用方法
	int num = r.nextInt(10);
	生成的随机数0-9区间之间的数字

[========]

day04

数组

就是一个用来装同一个类型，多个元素的容器。
较比变量：变量是一次只能装一个数据。
数组一次可以装多个数据。
通过索引访问，索引就是数组空间的编号
	范围：0~arr.length-1
	如果访问的索引超过范围，则报角标越界异常
	ArrayIndexOutOfBoundsException
必须掌握的点
	创建
	动态创建
		确定长度
		int[] arr = new int[3];
		数组内的元素为默认值
	静态创建
		确定内容
		int[] arr = {1,2,3,4};
	赋值
		arr[0] = 10;
	取值
		int a = arr[0];
	遍历
		arr.length: 表示数组的长度
		快捷键：arr.fori
		遍历是为了拿到数组的每一个元素，不是单单为了打印。
空指针异常
	数组赋值为null，则还想要访问数组，则会报错。

代码示例

点击查看代码

public class Demo01 {
    public static void main(String[] args) {
        /*
        数组：就是一个可以同时存储多个同类型数据的【容器】
        掌握四个点即可
        1.创建：把容器造出来
        2.赋值：把数据装入容器
        3.取值：把容器中的数据拿出来
        4.遍历：把数据从容器中一个个拿出来的过程
         */
        //静态初始化数组的格式:把数组容器造出来，同时将数据存入容器
        //完整格式: 数组类型  数组名  =  new  数组类型[]{数组元素1,2,3.。。}
        //数组是一种引用数据类型，数组变量名中存的是数组首个元素的内存地址
        int[] ages = new int[]{12,54,65};
        System.out.println(ages);
        //遍历...数组名.fori
        //遍历...对数组中的元素求和
        int sum = 0;
        for (int i = 0; i < ages.length; i++) {
            System.out.print(ages[i]+"  ");
            sum+=ages[i];//求和
        }
        System.out.println("年龄和为："+sum);
        System.out.println(ages[1]);
        ages[1] = 250;
        System.out.println(ages[1]);
        double[] prices = new double[]{250.2,151.15,324.8};
        System.out.println(prices);
        boolean[] booleans = new boolean[]{true,false,false,true};
        System.out.println(booleans);
        String[] strings = new String[]{"ad","ac","ab"};
        System.out.println(strings);
        //因为输出流System.out是PrintStream对象，PrintStream有多个重载的println方法，
        // 其中一个就是public void println(char[] x)，
        // 直接打印字符数组的话，不像int[]等其他数组，它会直接调用这个方法来打印，
        // 因而可以打印出数组内容，而不是地址。其实char类型的数组就相当于一个字符串
        char[] chars = {'5','b','a','2'};
        for (int i = 0; i < 4; i++) {
            System.out.print(chars[i]+ "  ");
        }
        System.out.println();
        System.out.println("输出地址："+chars);
        System.out.println(chars);//相当于打印字符串
        System.out.println(Arrays.toString(chars));//数组形式打印输出
    }
}

。。。。。。。。。。。。。

拓展

java数组内存分配：

多个引用变量指向同一地址：