JAVA笔记_盘符名称加冒号-CSDN博客

本文链接：https://blog.csdn.net/xiaoyixiaowow/article/details/127029398

常用的CMD命令

1.盘符名称+冒号

说明：盘符切换

2.dir

说明：查看当前路径下的内容

3.cd 目录

说明：进入单级目录

4.cd

说明：回退到上一级目录

说明：进入多级目录

6.cd \

说明：回退到盘符目录

7.cls

说明：清屏

8.exit

说明：退出命令提示符窗口

JAVA基础概念

注释分类

1.单行注释

格式：// 注释信息

2.多行注释：

格式：/* 注释信息 */

3.文件注释

格式：/* */

字面量的分类

字面量类型	说明	举例
整数类型	不带小数点的数字	666，-88
小数类型	带小数点的数字	13.14，-5.21
字符串类型	用双引号括起来的内容	"sadasda"，"你好"
字符类型	用单引号括起来的，内容只能有一个	'A'，'0'，'我'
布尔类型	布尔值，表示真假	只有两个值：true，false
空类型	一个特殊的值，空值	值：null

\t 制表符

在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补一个空格，最多补8个空格。

变量的定义格式

数据类型变量名 = 数据值；

基本数据类型

数据类型	关键字	取值范围
整数	byte	-128~127
	short
	int（默认）
	long
浮点数	float
浮点数	double（默认）
字符	char
布尔	boolean	true，false

标识符

硬性要求

由数字，字母，下划线（_）和美元符（＄）组成
不能以数字开头
不能是关键字
区分大小写

软性要求

1.小驼峰命名法：方法，变量

规范1：标识符是一个单词的时候，全部小写

范例1：name

规范2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写

范例2：firstName

2.大驼峰命名法：类名

规范1：标识符是一个单词的时候，首字母大写

范例1：Student

规范2：标识符由多个单词组成的时候，每个单词的首字母大写

范例2：GoodStudent

键盘录入

步骤一：导包）

import java.util.Scanner；（导包必须再类定义的上边）

步骤二：创建对象

Scanner sc = new Scanner(System.in)；

步骤三：接收数据

int i = sc.nextInt()；

运算符

算术运算符

符号	作用
+	加
-	减
*	乘
/	除
%	取余

取值范围

byte < short < int < long < float < double

隐式转换（自动提升类型）

把一个取值范围小的数值，转换成取值范围大的数据

转换规则1：

取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行计算

转换规则2：

byte short char 三种类型的数据在运算的时候，都会直接先提升为 int ，然后再进行运算

强制转换

不能直接把一个取值范围大的数值，赋值给取值范围小的变量

强转格式：目标数据类型变量名 = （目标数据类型）被强转的数据；

范例：

byte  b  =（byte）a；

byte result = (byte)(b1 + b2) ;

字符串的 " + "操作

当 " + "操作中出现字符串时，这个 " + "是字符串连接符，而不是算术运算符。会将前后的数据进行拼接，产生一个新的字符串。
连续进行 " + "操作时，从左到右逐一执行。

自增自减运算符

符号	作用	说明
++	加	变量的值加1
--	减	变量的值减1

赋值运算符

符号	作用	说明
=	赋值	int a = 10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a=b，将ab的值给a
/=	除后赋值	a/=b，将a➗b的商给a
%=	取余后赋值	a%=b，将a➗b的余数给a

关系运算符

符号	说明
==	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

注意事项：关系运算符的结果都是boolean类型，要么是true，要么是false。

逻辑运算符

符号	作用	说明
&	逻辑与	并且，两边都为真，结果才为真
\|	逻辑或	或者，两边都为假，结果才为假
^	逻辑异或	相同为false，不同为true
！	逻辑非	取反

短路逻辑运算符

符号	作用	说明
&&	短路与	结果和&相同，但是有短路效果
\|\|	短路或	结果和\|相同，但是有短路效果

注意事项：
& |，无论左边true，false，右边都要执行。
&& ||，如果左边能确定整个表达式的结果，右边不执行。
&&：左边为false，右边不管是真是假，整个表达式的结果一定是false。
||：左边为true，右边不管是真是假，整个表达式的结果一定为true。

三元运算符

格式：关系表达式？表达式1：表达式2；

解释：如果关系表达式为true，则返回表达式1，如果关系表达式为false，则返回表达式2。

范例：

int max = a > b? a : b;
System.out.println(max);

判断和循环

if语句的第一种格式

格式：if(关系表达式){
        语句体;    
     }


范例：if(酒量>2){
       System.out.println("酒量不错");
     }

执行流程：

先计算关系表达式的值
如果关系表达式的值为true就执行语句体
如果关系表达式的值为false就不执行语句体
继续执行后面的其他语句

if语句的第二种格式

格式： if(关系表达式){
        语句体1;
    }else{
        语句体2;
    }


范例： if(酒量 > 2){
        System.out.println("酒量不错");
    }else{
        System.out.println("酒量不行");
    }

执行流程：

先计算关系表达式的值
如果关系表达式的值为true就执行语句体1
如果关系表达式的值为false就不执行语句体2
继续执行后面的其他语句

if语句的第三种格式

格式： if(关系表达式){
        语句体1;
    }else if(关系表达式){
        语句体2;
    }
        ...
        else{
        语句体 n + 1;
    }


范例： if(score >= 95 && score <= 100){
        System.out.println("送自行车一辆");
    }else if(score >= 90 && score <= 94){
        System.out.println("游乐场玩一天");
    }else{
        System.out.println("打一顿");    
    }

执行流程：

先计算关系表达式1的值
如果为true就执行语句体1；如果为false就计算关系表达式2的值
如果为true就执行语句体2；如果为false就计算关系表达式3的值
......
如果关系表达式结果都为false，就执行语句体n+1。

switch语句格式

格式： switch(表达式) {

           case 值1:
                语句体1;
                break;
           case 值2:
                语句体2;
                break;
           ...
           default:
                语句体 n+1;
                break;

}


范例：switch(心里想吃的面) {
          case "兰州拉面":
                吃拉面;
                break;
          case "热干面":
                吃热干面;
                break;
         default :
                吃泡面;
                break;              
}

执行流程：

先计算表达式的值。
依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后结束整个switch语句。

格式说明：

表达式：（将要匹配的值）取值为byte，short，int，char。
case：后面跟的是要和表达式进行比较的值（被匹配的值）。
break：表示中断，结束的意思，用来结束switch语句。
default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
case后面的值只能是字面量，不能是变量。
case给出的值不允许重复。

for循环

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



范例： for(int i = 1; i <= 10; i++){
         System.out。println("HelloWord");
        }

执行流程：

1.执行初始化语句

2.执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，执行循环体语句

3.执行条件控制语句

4.回到2继续执行条件语句

while循环的执行流程

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

范例：int i = 1;
      while(i <= 10){
          System.out.println(i);
          i++;
      }

执行流程：

初始化语句只执行一次
判断语句为true，循环继续
判断语句为false，循环结束

for和while的对比

相同点：运行规则一样
区别：for循环中，初始化语句，因为属于for循环中，在for循环结束后，就不能再次使用变量。
while循环中，初始化语句，因为不属于while中，在while循环结束后，还可以继续使用变量。

使用for和while的区别：

for循环：知道循环次数或者循环的范围
while循环：不知道循环的次数和范围，只知道循环的结束条件

do...while循环

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


    执行流程：先执行后判断


范例： int i = 1;
       do{
         System.out.println(i);
         i++;
     }while(i <= 5);

无限循环

for(;;){
    System.out.println("学习");    
}


while(true){
    System.out.println("学习");
}


do{
    System.out.println("学习");
}while(true);

跳转控制语句

continue：跳过本次循环，继续执行下次循环。
break：结束整个循环。

获取随机数

1.导包

import java.util。Random;

2.创建对象

Random r = new Random ();

3.生成随机数

int number = r.nextInt(随机数的范围);

数组

数组：是一种容器，可以用来存储同种数据类型的多个值
注意事项：数组容器在存储数据的时候，需要结合隐式转换考虑。
建议：容器的类型，和存储的数据类型保持一致

数组的定义

格式： 数据类型 [] 数据名

范例： int [] array

数组的静态初始化

初始化：在内存中，为数组容器开辟空间，并将数据存入容器中的过程

格式： 数据类型 [] 数组名 = {元素1, 元素2, 元素3, ...};


范例：int [] array = {11, 22, 33};

索引

索引：也叫坐下标，角标。
索引的特点：从0开始，逐一+1增长，连续不间断

数组的地址值

int [] arr = {1，2，3，4}；

System.out.println(arr);//[I@6d03e736 (地址值)

拓展：

格式的含义：[D@776ec8df
[ : 表示当前是一个数组
D : 表示当但数组里面的元素都是double类型的
@：表示一个间隔符号（固定格式）
776ec8df：才是数组真正的地址值（十六进制）

数组元素访问

格式：数组名 [索引] ；

把数据存储到数组当中

格式：数组名[索引] = 具体数据/变量;

细节：一旦覆盖之后，原来的数据就不存在了。

范例：arr[0] = 100;

获取数值：可以直接打印，或者赋值变量

int number = arr [0];

System.out.println(arr[0]);

数组遍历

数组遍历：将数组中所有的内容取出来，取出来之后可以（打印，求和，判断...）
注意：遍历指的是取出数据的过程，遍历不是打印！！！

java中，数组的长度属性：length

调用方法：数组名.length

拓展：

快速生成数组的遍历方式：数组名.fori

遍历出数组中的每一个元素

    for(int i = 0; i <= arr.length; i++){
        //i：表示数组每一个元素的索引
        //arr[i]：表示数组每一个元素
        System.out.println(arr[i]);
    }

数组动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始化。

格式： 数组类型 [] 数组名 = new 数组类型[数组长度];

范例：int[] arr = new int[3];

数组默认初始化的值

数组类型：	默认初始化值为 0
小数类型：	默认初始化值为 0.0
字符类型：	默认初始化值为 '/u0000' 空格
布尔类型：	默认初始化值为 false
引用数据类型：	默认初始化值为 null

数组动态初始化和静态初始化的区别

动态初始化：手动指定数组长度，由系统给出默认初始化值。
使用条件：只明确元素个数，不明确具体数值，推荐使用动态初始化

举例：使用数组容器来存储键盘录入的5个整数。

int [] arr = new int [5];

静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组长度。
使用条件：需求中已经明确了要操作的具体数据，直接静态初始化。

举例：将全班的学生成绩存入数组中 11,22,33

范例：int [] arr = {11,22,33};

数组常见问题总结

索引越界异常：访问了不存在的索引
最小索引：0
最大索引：（数组长度 -1）

方法

方法：程序中最小的执行单位
用法：重复的代码，具有独立功能的代码可以抽取到方法中

最简单的方法定义

格式： public static void 方法名(){
        方法体 (打包起来的代码);
      }

范例： public static void getSum(){
        int num1 = 10;
        itn num2 = 20;

        int result = num1 + num2;
        System.out.println(result);
      }

注意：方法必须先定义后调用

带参数的方法定义

单个参数

格式： public static void 方法名(参数){
        方法体;
    }

范例： public static void method(int number){
        System.out.println(number);
    }


多个参数

格式： public static void 方法名(参数1, 参数2, ...){
        方法体;
    }

范例： public static void getSum(int num1, int num2){
        int result = num1 + num2;
        System.out.println(result);
    }

注意：方法调用时，参数的数量与类型必须与方法定义中小括号里面的变量——对应。

带返回值方法的定义

格式： public static 返回值类型 方法名(参数){
        方法体;
        return 返回值;
    }


范例：public static int getSum(int a, int b){
      int c = a + b;
      return c;  
    }

方法调用的三种方法

直接调用：

方法名（实参）；

赋值调用：

整数类型变量名 = 方法名（实参）；

输出调用：

System.out.println（方法名(实参)）；

return关键字

方法没有返回值：可以省略不写。如果书写，表示结束方法
方法有返回值：必须要写。表示结束方法和返回结果

方法的重载

同一个类中，方法名相同，参数不同的方法。与返回值无关。
参数不同，个数不同，类型不同，顺序不同（不建议）

范例： 

正确： public class MethodDemo {
        public static float fn(int a){
            //方法体
        }
        public static int fn(int a, int b){
            //方法体
        }
      }


错误： public class MethodDemo {
     public static void fn(int a){
            //方法体
        }
        public static int fn(int a){
            //方法体
        }
      }

形参和实参

形参：全称形式参数，是指方法定义中的参数
实参：全称实际参数，方法调用中的参数

注意：方法调用时，形参和实参必须——对应。

范例： public static void mian (String [] args){
        getSum(10,20);//实参

        
        int a = 10;
        int b = 10;
        getSum(a,b);//实参
    }    

      public static void main (int num1,int mun2)//形参{
        int result = num1 + mum2;
        System.out.println(result);
  }

方法的注意事项

方法不调用就不执行
方法与方法之间是平级关系，不能互相嵌套定义、
方法的编写循序和执行循序无关
方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据
return语句下面，不能编写代码，因为永远执行不到，属于无效代码。