0.学前基础知识

基础知识总结

一、jdk环境配置

1.Path环境变量

• Path环境变量用于配置程序的路径
• 方便我们在命令行窗口的任意目录启动程序

2.注意点

• 较新版本的JDK会自动配置PATH环境变量，较老的JDK版本则不会
• 建议自己配置 Path 和 JAVA_HOME

二、Java基本书写规范

• java注释：单行(//)、多行注释(/* /)、文档注释(/** */)

• 字符必须单引号围起来，有且仅能一个字符

• 字符串必须使用双引号围起来

• 变量使用注意点：

  • 变量要先声明，才能使用；
  • 类型与数据对应；
  • 变量存在访问范围，同一范围不能出现一样的变量名字；
  • 变量定义时可以不赋初值，但在使用时必须有值。

• 关键字：

  • 关键字就是Java自己要用到的词，并且具有特殊的含义
  • 关键字不能用来做：类名、变量名

三、类型转换、常用运算符

1.字符数据存储

ASCII标志对应数字：A=65,a=97,0=48

• 字母和数字的转换：

  (–Random rd = new Random()—)

  随机A~Z:

  ​ int n1 = rd.nextInt(26) + 65;
  ​ char c1 = (char)n1;
  随机a~z:
  ​ int n1 = rd.nextInt(26) + 97;
  ​ char c1 = (char)n1;

2.数据类型的分类

• 基本数据类型：4大类8大种

  byte short int(默认) long ——>整型

  float double(默认) ——>浮点型

  char ——>字符型

  boolean ——>布尔型

• 引用数据类型：String、数组、类

• 类型转换：

  • 意义：存在不同类型的变量赋值给其他类型的变量
  • 类型范围小的变量，可以直接赋值给类型范围大的变量
  • 表达式最终类型由 表达式中最高类型决定

• 强制类型转换：

  • 默认情况下，大范围类型的变量直接复制给小范围类型的变量会啊拨错！

  • 可以强行将类型范围大的变量、数据复制给类型范围晓得变量

    • 数据类型 变量 = (数据类型)变量 数据

  • 注意点：

    • • 可能出现数据丢失
      • 小数强制转换成整数是 直接截断小数保留整数

3.常用运算符

• +: 有时用作字符串的【连接符】
  -: 减
  *: 乘
  /: 除
  %: 求余
  

• ++: 自增>放在某个变量前面或者后面，对变量自身的值加 1
  –: 自减>放在某个变量前面或者后面，对变量自身的值减 1

  两个运算符只能操作变量，不能操作字面量

  • 放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算

  • 放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1

4.扩展运算符

符号	用法	作用	底层代码形式
+=	a += b	加后赋值	a = (a的类型)(a+b)
-=	a -= b	减后赋值	a = (a的类型)(a-b)
*=	a *= b	乘后赋值	a = (a的类型)(a*b)
/=	a /= b	除后赋值	a = (a的类型)(a/b)
%=	a %= b	取余后赋值	a = (a的类型)(a%b)

5.关系运算符

符号	例子	作用	结果
>	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

6.注意点

• 三元运算符：格式> 条件表达式 ？ 值1：值2(首先计算关系表达式的值，若true，则返回值1，反之…)
• 在表达式中，运算符执行要看优先级(* / 优先级 > + -)
• ==类型大小:==byte——>short/char——>int——>long——>float——>double

1. 八种基本数据类型中，除了boolean类型不能转换，剩下七种类型之间都可以进行转换

2. 如果整数型字面量没有超过byte、short、char的取值范围，可以直接将其赋值给byte、short、char类型的变量

3. 小容量向大容量转换称为自动类型转换，容量从小到大排序为：byte<short(char)<int<long<float<double，其中short和char都占用两个字节，但是char可以表示更大的正整数。

4. 大容量转换为小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能会出现精度损失，谨慎使用。

5. byte、short、char类型混合运算时，先各自转换成int类型再做运算。

多种数据类型混合运算时，各自先转换成容量最大的那一种再做运算。

算术运算符 > 关系运算符 > 逻辑运算符
！ 大于 && 大于 ||

四、程序流程控制

1.顺序结构

不加任何控制，代码从main方法开始自上而下执行

2.分支结构

根据条件判断是true还是false，有选择性的执行代码**[if switch]**

1. if分支

1.第一种形式
   if(条件){
         语句体;
     }...
      
2.第二种形式
   if(条件){
       语句体1;
   }else{
       语句体2;
   }...
         
3.第三种形式
    if(条件1){
        语句体1;
    }else if(条件2){
        语句体2;
    }else if(条件3){
        语句体3;
    }...
    else{
        语句体n;
    }

2. swith分支

1.执行流程：是通过 比较值 来决定执行哪条分支代码
    
2.注意事项：
    (1).表达式类型只能是byte、short、int、char
	   JDK5开始支持枚举，JDK7开始支持String
	   不支持double、float、double
    
     (2).case给出的值不允许重复，且只能是字面量，不能是变量。
		
     (3).正常使用switch的时候，不要忘记写break，否则会出现穿透现象。

3. 使用场景

• 如果是对一个范围进行判断，建议使用if分支结构

• 如果是与一个一个的值比较的时候，建议使用switch分支结构

3.循环结构

控制某一段代码重复执行**【for、while、do-while】**

1. for循环

for (初始化语句; 循环条件; 迭代语句) {
    循环体语句(重复执行的代码);
}

初始化语句：一般是定义一个变量，并给初始值
循环条件：一般是一个关系表达式，结果必须是true或者false
迭代语句：用于对条件进行控制，一般是自增或者自减
循环语句体：需要重复执行的代码

2. while循环

初始化语句；
while (循环条件){
    循环体语句;
}

3. do-while循环

初始化语句;
do{
    循环体语句;
    迭代语句;
}while(循环条件);

4. 使用场景

• 从功能来说：能够用for循环做的，都能用while循环做。

• 使用规范上来说：知道循环几次，建议使用for；不知道循环几次建议使用while

5. 区别

1. for循环 和 while循环（先判断后执行）; 
   do...while （先执行后判断）
   
2. for循环和while循环的执行流程是一模一样的，
	功能上无区别，for能做的while也能做，反之亦然。
	如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。
	
3. for循环中控制循环的变量只在循环中使用
  while循环中，控制循环的变量在循环后还可以继续使用

6. 死循环

//for死循环
for ( ; ; ){
    System.out.println("Hello World1");
}

//while死循环
while (true) {
    System.out.println("Hello World2");
}

//do-while死循环
do {
    System.out.println("Hello World3");
}while (true);

7. 跳转语句 break、continue

• break作用：跳出并结束当前所在循环的执行
• continue作用：结束本次循环，进入下一次循环

五、Java数组

1.数组要点

• 数组就是一个容器，用来存一批同种类型的数据的。

• 数组的初始化

1.静态初始化
    数据类型[] 变量名 = new 数据类型[]{元素1,元素2,元素3};
    数据类型[] 变量名 = {元素1,元素2,元素3};
2.动态初始化
    //数据类型[]  数组名 = new 数据类型[长度];
	int[] arr = new int[3];

注意点：

• 定义数组时， 数据类型[] 数组名 也可写成 数据类型 数组名[]
• 方法区：字节码文件先加载到这里
• 栈：方法运行时所进入的内存区域，由于变量在方法中，所以变量也在这一块区域中
• 堆：存储new出来的东西，并分配地址。由于数组是new 出来的，所以数组也在这块区域。

// 这里的int a是一个基本类型变量，存储的是一个数值
int a = 10 ; 
//这里的int[] arr是一个引用类型的变量，存储的是一个地址值
int[] arr = new int[]{44,55,66};

2.数组使用

1. 求最大值

数组求最大值思路：
	1)先找出数组中0索引的元素，假设为最大值，用max表示【擂主】
	2)遍历后面的每一个元素和max比较，把较大的元素值重新赋值给max(擂主换人)
    3)最后max就是所有元素的最大值(最后站在台上的擂主)
    
public class Test1 {
    public static void main(String[] args) {
        // 1、把颜值数据拿到程序中来，用数组装起来
        int[] faceScores = {15, 9000, 10000, 20000, 9500, -5};
        // 2、定义一个变量用于最终记住最大值。
        int max = faceScores[0];
        // 3、从数组的第二个位置开始遍历。
        for (int i = 1; i < faceScores.length; i++) {
            // i = 1  2  3  4  5
            // 判断一下当前遍历的这个数据，是否大于最大值变量max存储的数据，
            //如果大于，当前遍历的数据需要赋值给max
            if(faceScores[i] > max ){
                max = faceScores[i];
            }
        }
        System.out.println("最高颜值是：" + max);
    }
}

2. 数组元素反转

需求：某个数组有5个数据：10,20,30,40,50，请将这个数组中的数据进行反转。
      [10, 20, 30, 40, 50]  反转后 [50, 40, 30, 20, 10]
    
public class Test2 {
    public static void main(String[] args) {
        // 目标：完成数组反转。
        // 1、准备一个数组
        int[] arr = {10, 20, 30, 40, 50};  

        // 2、定义一个循环，设计2个变量，一个在前，一个在后
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

3. 随机排名

需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
    
public class Test3 {
    public static void main(String[] args) {
        // 目标：完成随机排名
        // 1、定义一个动态初始化的数组用于存储5名员工的工号
        int[] codes = new int[5];
        // 2、提示用户录入5名员工的工号。
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            // i = 0 1 2 3 4
            System.out.println("请您输入第" + (i + 1) +"个员工的工号：");
            int code = sc.nextInt();
            codes[i] = code;
        }
        // 3、打乱数组中的元素顺序。
        // [12, 33, 54, 26, 8]
        //  i       index
        Random r =  new Random();
        for (int i = 0; i < codes.length; i++) {
            // codes[i]
            // 每遍历到一个数据，都随机一个数组索引范围内的值。
            //然后让当前遍历的数据与该索引位置处的值交换。
            int index = r.nextInt(codes.length); // 0 - 4
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }
        // 4、遍历数组中的工号输出即可
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + " ");
        }
    }
}

六、方法

1.方法概述

方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用。

1. 格式：

修饰符  返回值类型  方法名(形参列表){
    方法体代码;
    return 返回值;
}

2. 使用方法的好处:

• 提高代码的复用性，提高开发效率，使程序逻辑更清晰。

2.方法形式

设计一个合理的方法的原则如下：

• 如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明）, 此时方法内部不可以使用return返回数据。
• 方法如果不需要接收外部传递进来的数据，则不需要定义形参，且调用方法时也不可以传数据给方法。
• 没有参数，且没有返回值类型（void）的方法，称为值无参数、无返回值方法。此时调用方法时不能传递数据给方法。

3.方法使用常见问题

- 1. 方法在内种没有先后顺序，但是不能把一个方法定义在另一个方法中。

- 2. 方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，
	如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。

- 3. return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。

- 4. 方法不调用就不会执行,  调用方法时，传给方法的数据，必须严格匹配方法的参数情况。

- 5. 调用有返回值的方法，有3种方式：
     ① 可以定义变量接收结果 
     ② 或者直接输出调用，
     ③ 甚至直接调用；

- 6. 调用无返回值的方法，只有1种方式： 只能直接调用。

4.方法参数的传递机制

Java的参数传递机制都是：值传递

1. 参数传递的基本类型数据

Java的参数传递机制都是：值传递，传递的是实参存储的值的副本。

2. 参数传递的是引用数据类型

实际上也是值传递，只不过参数传递存储的地址值

5.方法重载

一个类中，出现多个相同的方法名，但是它们的形参列表是不同的，那么这些方法就称为方法重载了

1.什么是方法重载？
	答：一个类中，多个方法的名称相同，但它们形参列表不同。
2.方法重载需要注意什么？
	- 一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，
	  其它的都不管（如：修饰符，返回值类型是否一样都无所谓）。
	
	- 形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。
	
3、方法重载有啥应用场景？
	答：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很	        专业的。

6.return单独使用

• 返回方法指定的值
• 结束方法的执行