java基知识：

最新推荐文章于 2021-03-01 22:46:47 发布
最新推荐文章于 2021-03-01 22:46:47 发布
阅读量399 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49053267/article/details/107992858
版权

java基知识：

1、java数据类型：

dos的使用快捷键：

盘符的切换符盘名：
看查当前文件dir
看查文件夹命令cd 文件名
出退文件夹命令cd…
退出到硬盘的根路径cd\
清屏cls
退出dosexit

  1. ​ 基本数据类型：整数、浮点数、字符、布尔

  2. ​ 引用数据类型 ：类、数组、接口

关键字内存占用取值范围
byte1-128~127
short2-32768~32767
int(默认)4
long8
float4
double(默认)8
char20-65535
boolean1true、flase

  • long类型：建议数据 后面添加L表示

  • float类型：建议数据后面添加F表示

使用变量的注意事项：

  • ​ 1、如果创建多个变量，变量不能重复的
  • ​ 2、对于float和long类型的变量，值后面加上字母后缀
  • ​ 3、数据类型赋值不能超出数据类型的范围你
  • ​ 4、没有进行赋值的变量不能使用
  • ​ 5、变量一定要先创建，再使用
  • ​ 6、注意作用域：就是大括号( { } )的范围

2、数据类型转换：

当数据类型不一致时，就会发生数据类型转换

  1. ​ 自动转换（隐式）：

    ​ 特点：代码不需要进行特殊处理，自动完成

    ​ 规则：数据范围从小到大

    ​ byte short char——int——long——float——double

  2. ​ 强制转换（显式）：

    ​ 规则：数据范围冲大到小

    ​ 格式：数据类型 变量名 = （数据类型）被转换的数据

    ​ int num = (float)100L;
    数据类型转换的注意事项：

    ​ 1、浮点数转整数会造成数据精度丢失、其他数据类型可能会造成数据溢出

    ​ 2、byte、short、char这三种类型都可以发生数学运算，例如"+"j

    • char ch = 'A';
System.out.println(ch+1);		//66,因为计算机是采用二进制的，所以A的值是65，

    ​ 3、byte、short、char这三种类型在运算的时候，都会被首先提升为int类型，然后在计算

    ​ 4、boolean不能发生任何数据类型转换

    注意事项：

    ​ 1、对于byte、short、char三种类型来说，如果右侧赋值的数值没有超过范围，那么java编译器将会自动隐含的补上（byte）、（short）、（char）强转，如果超过了，编译器就不报错

    ​ 2、在给变量赋值的时候，如果右侧的表达式全部都是常量，没有任何变量，那么编译器将会直接将若干个常量表达式计算得到结果

    short result = 5+8;
sout(result);		//13
这样称为【编译器的常量优化】，但是一旦表达式有变量参与，就不能进行这样的优化
    
  short a = 5;
System.out.println(5+a+8);			//这样编译器会报错
中间有变量，不能使用常量优化

ASCII

字符数值
048
957
A65
Z90
a97
z122

3、运算符：

3.1、算数运算符

加+
减-
乘*
除/
取余%
自增、自减++ 、–

对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果是整数不保留余数

  • 自增和自减：
  • ​ 1、如果是【前++】，那么变量【立刻马上+1】，然后拿着结果再使用【先加后用】
  • ​ 2、如果是【++后】，那么首相使用变量原来的值，【然后在让变量+1】【先用后加】

3.2、赋值运算符

=等于
+=加等于 a+=1 a=a+1
-=减等于 a-=1 a= a-1
*=乘等于
/=除等于
%=取余等于
  • 赋值运算符就是：将右边的值赋值给左边的变量
  • 常量不能进行赋值

3.3、比较运算符

==比较两边的值，如果相等为true，否则为false
>如果大于为true，否则为false
<如果小于为true，否则为false
>=如果大于等于为true，否则为false
<=如果小于等于为true，否则为false
!=如果不想等为true，否则为false

比较运算符是两个数据之间进行比较的运算，运算结果是boolean值：true或者false

3.4、逻辑运算符

&&（逻辑与）两边是true，则是true，一边是false，就是false
||（逻辑或）两边是false，则是false，一边是true，则是true
！（逻辑非）！true就是false， ！false就是true

逻辑运算符：就是用来连接两个boolean类型结果的运算符，运行结果是true或者false

3.5、三元运算符

  • 三元运算符的格式：

    • 数据类型 变量名 = 布尔表达式？ 结果1：结果2

    三元运算符计算方式：

    ​ boolean表达式的结果是true，三元运算符整体结果为结果1，赋值给变量

    ​ boolean表达式的结果是false，三元运算符整体结果为结果2，赋值给变量

    public static void main(String[] args){
	int i = (1==2 ? 100:200);
	sout(1)	;	//200
	int j = (2<=4 ? 500:600);
	sout(j)	;	//500
}

4、方法入门

4.1概述：

概述：就是将一个功能抽取出来，把代码单独定义在大括号内，形成一个单独的功能。当需要这个功能时，就可以去调用，这样即实现了代码的复用性，也解决了代码冗余的现象。

4.2方法的定义：

定义格式：
修饰符 返回值类型 方法名（参数列表）{
    代码……
        return

}

public statci void method(){
	sout("这是一个方法");
}

4.3方法的调用：

方法定义完毕后，方法不会自己运行，必须被调用才能被执行，我们在主方法main中调用我们自己定义好的方法，在主方法中，直接写要调用方法的名字就可以调用了

格式：方法名称（）；

public static void main(String[] args){
    method()		//这样就是调用方法
}

4.4方法定义的注意事项：

  • 1、方法必须定义在类中方法外
  • 2、方法不能定义在另一个方法里面

5、JShell的使用

  • dos窗口输入JShell，可以直接编写代码，不需要写类和方法，可以直接编译运行，回车即可

  • 退出：/exit

  • JShell只适合片段代码的测试，建议代码写下方法中

6、流程控制：

6.1：概述：

概述：在一个程序执行过程中，各条语句的执行顺序对程序的结果是有直接影响到的，也就是说，程序的流程对运行结果有直接影响所以我们必须清楚每条语句的执行流程，而且很多时候需要通过控制语句的执行来实现我们要完成的功能；

6.2、顺序结构：

顺序结构：根据编写的程序，从上到下的执行；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-heEJyfpp-1597327597938)(…/typora_picture/01-%E9%A1%BA%E5%BA%8F%E7%BB%93%E6%9E%84%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

6.3、判断语句：

1、if
if关系表达式{
    语句体
}

public statci void main(String[] args){
    int a = 10;
    int b = 20;
    if(a==b){
        System.out.println("a=b");
    }
    System.out.println("结束");
}

  • 首先判断关系表达式，看其结果是true还是false

  • 如果是true，就执行语句体

  • 如果 false，就不执行语句体

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SgdghokI-1597327597940)(…/typora_picture/02-%E5%8D%95if%E8%AF%AD%E5%8F%A5%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

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

public static void main(String[] args){
    int a = 1;
    if(a % 2 == 0){
        System.out.println("a是偶数");
    }else{
        System.out.println("a是奇数");
    }
}

执行流程：

  • 首先盘算关系表达式看其结果是true还是false
  • 如果是true，就执行语句体1
  • 如果是false，就执行语句体2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6TbuCs6x-1597327597942)(…/typora_picture/03-%E6%A0%87%E5%87%86if-else%E8%AF%AD%E5%8F%A5%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

3、if…else if…else
if(判断条件1){
	执行语句1;
}else if(判断条件2){
    执行语句2
}
……
}else if(判断条件n){
    执行语句n;
}else{
    执行语句n+1
}
   
public static void main(String[] args){
    int score = 100;		//score分数
    if(score < 0 || score>100){
        sout("你的成绩有误！");
    } else if(score >= 90 && score <= 100){
        sout("优秀");
    }else if(score >= 80 && score < 90 ){
        sout("好");
    }else if(score >= 70 && score < 80 ){
        sout("良");
    }else if(score >= 60 && score < 70 ){
        sout("及格");
    }else{
        sout("不及格");
    }
}

//使用三元运算符取两个数中的最大值
public static void main(String [] args){
    int a = 10;
    int b = 20;
    
    int max ;		//定义变量存储最大值
	if(a>b){
        max = a;
    } else{
        max = b;
    }
    max = a > b ? a : b;
    sout(max);
}

执行流程：

  • 首先判断关系表达式1，看其结果是true，还是false

  • 如果是true，就执行语句体1

  • 如果是false就继续判断关系表达式2，看其结果是true还是false

  • 如果是true ，就执行语句体2

  • 如果是false，就继续判断表达式……，看其结果是true还是false

  • ……

  • 如果没有任何关系表达式为true，就执行语句体n+1

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rWQh5Tmy-1597327597945)(…/typora_picture/04-%E6%89%A9%E5%B1%95if-else%E8%AF%AD%E5%8F%A5%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

6.4、选择语句：

switch (表达式){
        case 常量值1;
        语句体1;
        break;
        
        case 常量值2；
        语句体2;
        break;
        ……
}

public statci void main(String[] args){
    //根据输入的数字判断星期
    Scanner sc = new Scanner(System.in);
    int weekend = sc.nextInt();
    System.out.println("请输入数字（1-7） ： ");
    switch(weekend){
        case 1:
            sout("星期一");
            break;
        case 2 :
            sout("星期二");
            break;
        case 3 :
            sout("星期三");
            break;
        case 4:
            sout("星期四");
            break;
        case 5 :
            sout("星期五");
            break;
        case 6 :
            sout("星期六");
            break;
        case 7 :
            sout("星期日");
            break;
        default :
            System.out.println("你输入的数字有误");
    }
    
}

执行流程：

  • ​ 首先计算出表达式的值

  • ​ 其次和case依次比较，一旦有相对应的值，就会执行想对应的额语句，在执行过程中，遇到break就会结束

  • ​ 最后，如果所有的case都和表达式的值不匹配，就会执行default语句部分，盘后程序结束

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k2uJSEM9-1597327597946)(…/typora_picture/switch%E8%AF%AD%E5%8F%A5%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

case穿透：
public static void main(String[] args){
    int i = 5;
    switch(i){
        case 0:
			System.out.println("执行case 0") ;
             break;
        case 5;
         	System.out.println("执行 case 5 ");
            break;
        case 10 ;
            System.out.pritnln("执行case 10");
            break;		//这个break可以省略
        default :
            System.out.println("执行default");
    }

}

在switch语句中，如果case后面不写break，就会出现穿透现象也就是不会判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束
    综上所述，执行【case 5】，后面如果没有break，程序就会一直往下执行，不会判断case，直到遇到break或者运行完switch整体

6.4、循环语句：

1、for循环：
for循环的结构：
for（初始化表达式; 布尔表达式; 步进语句;）{
    循环体
}

//输出100次 helloworld
public static void main(String args[]){
    for(int x  = 1; x <= 100 ; x++){
        System.out.println("helloworld" + i);	//+i可以查到次数
    }
}

//判断1-100之间的偶数和：
public static void main(String[] args){
    int sum = 0;
    for(int i = 1; i<= 100; i++){
        if( i % 2 == 0){
            sum+=1;
        }
    }
    sout(sum);
    
}

执行流程：

  • 执行顺序：1-2-3-4,——2-3-4——2-3-4……2不满足为止

  • 1、负责完成循环的变量的初始化；

  • 2、负责判断时候满足循环条件，不满足就跳出循环

  • 3、执行具体的语句

  • 4、循环后、循环条件所涉及变量的情况

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RpvcCV6i-1597327597947)(…/typora_picture/05-for%E5%BE%AA%E7%8E%AF%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

2、while循环：
while循环的格式：
初始化表达式1
    while(布尔表达式2){
        循环体3；
            步进表达式4；
    }


//输出10次helloworld
public static void main(String [] args){
    int  i = 1;		//定义初始化变量
   	while(i<=10){
        System.out.println("helloworld");
        i++;		//步进表达式
    }
}


//计算1-100之间的和
public static void main(String [] args){
    int sum = 0;	//定义一个累计变量
    
    int x  = 1;		//定义一个初始化表达式
    while(i<=100){
        sum+=1;		//步进语句
    }
    System.out.println(sum)
}

执行流程：

  • 执行顺序：1-2-3-4——2-3-4——2-3-4——2 不满足为止

  • 1、负责完成循环的初始化

  • 2、负责判断时候满足循环条件，不满足则跳出循环

  • 3、执行具体的语句

  • 4、循环后，置换变量的变化情况

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sipvpxc5-1597327597948)(…/typora_picture/06-while%E5%BE%AA%E7%8E%AF%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

3、do…while循环：
do…while循环格式：
初始化表达式1：
    do{
        循环体3
            步进表达式4
    }while(布尔表达式2);
        
//输出10次helloworld
 public static void main(String [] args){
     int x = 10;
        do{
            System.out.println("hellowprld");
            x++;
        }while(x<=10;);
    }

do…while循环的特点:无条件执行一次循环体，即是循环条件是false，也会执行一次循环体，这样的循环具有一定的风险性；

执行流程：

  • 执行顺序：1-3-4——2-3-4——2-3-4…2，不满足为止

  • 1、负责完成村换变量的初始化

  • 2、负责判断是否满足条件，不满足则跳出循环

  • 3、具体执行的语句

  • 4、循环后，循环变量的情况

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-09UaJcNv-1597327597949)(…/typora_picture/do%E2%80%A6while%E5%BE%AA%E7%8E%AF%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]

6.5、循环语句的区别：

1、如果条件判断从来没有满足过，那么for和while将会被执行0次，但是do…while循环至少会执行一次

2、已知循环次数的时候用for，循环次数为止的时候推荐使用while循环

3、控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问，而while循环结束还可以继续使用，如果想继续使用，就用while，如果不想使用就用for，因为for循环结束后，该变量就从内存中消失，能够提内存的使用效率（for循环的变量定义在小括号中，只能循环内部使用，while循环和do…while循环的初始化语句在循环外，所以出来循环还可以使用）

6.6、跳出语句（break、continue）

break：

  • 使用场景：终止switch或者循环

  • 1、在选择结构switch语句中

  • 2、循环语句中

  • 3、离开使用场景是没有意义的；

    public static void mainn(String []args){
    for(int x = 1; x<=10;x++){
        //需求：数据两次helloworld就停止
        if(x==2){
            break;
        }
        System.out.println("helloworld");
    }
}
continue：

使用场景：结束本次循环，继续下一次循环

public static void main(String []  args){
    for(int i = 1; i<=10; i++){
        if(i==4){
            continue;
        }
        System.out.println("helloworld"+"---"+i);
    }
}
//跳过了4
/*
helloworld---1
helloworld---2
helloworld---4
helloworld---5
helloworld---6
helloworld---7
helloworld---8
helloworld---9
helloworld---10
*/

6.6、死循环：

1、死循环：

就是循环逇条件永远是true，死循环的永不结束的循环，例如：while（true）{}。在后期开发中，出现死循环的场景例如：我们需要的读取用户数据的数据，但是用户输入了多少个数据我们并不知道，只能用死循环，单用具不想输入的数据了，就可以结束死循环，结束死循环的方法就需要使用到跳出语句了

2、嵌套循环：

嵌套循环：是指一个循环的循环体是另外一个循环，比如for循环里面嵌套一个for循环，总共循环的次数 = 外循环次数 + 内循环次数

for(初始化表达式;循环条件;步进表达式;){
    for(初始化表达式;循环条件;步进表达式;){
        执行语句
    }
}
//打印输出5*8的矩形
public statci void main(String[] args){
    //5行8列
    for(int x = 0; x < 5 ; x++){
        for(int y = 0; y<8;y++){
            System.out.print("*");
        }
        System.out.println();
    }
}

//九九乘法表
for (int x = 1; x <= 9; x++) {        //x是列，y是行
            for (int y = 1; y <= x; y++) {
                System.out.print(y + "*" + x + "=" + y * x + "\t");
            }
            System.out.println();
        }
/*
1*1=1	
1*2=2	2*2=4	
1*3=3	2*3=6	3*3=9	
1*4=4	2*4=8	3*4=12	4*4=16	
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	
*/

7、idea快捷键

快捷键功能
alt+enter导包，自动补全代码
ctrl+y删除光标所在行
ctrl+d复制光标所在行，插入光标位置下面
ctrl +alt+L格式化代码
ctrl+/单行注释
ctrl+shift+/选中代码注释，多行注释，再按就取消注释
alt+ins（F12）自动生成代码toString，get，set
alt+shift+上下箭头移动当前行代码
tab代码右移
shift+tab代码左移
shift+alt+↑代码上移
shift+alt+↓代码下移
alt+7类的大纲视图
ctrl+shift+alt+s查看项目属性
ctrl+alt+tidea中try—cath
ctrl+shift+alt+uidea查看机场关系
shirt+enteridea光标移动到下一行

debug快捷键：

  • **Show Execution Point (Alt + F10)：**如果你的光标在其它行或其它页面，点击这个按钮可跳转到当前代码执行的行。

  • **Step Over (F8)：**步过，一行一行地往下走，如果这一行上有方法不会进入方法。

  • **Step Into (F7)：**步入，如果当前行有方法，可以进入方法内部，一般用于进入自定义方法内，不会进入官方类库的方法。

  • **Force Step Into (Alt + Shift + F7)：**强制步入，能进入任何方法，查看底层源码的时候可以用这个进入官方类库的方法。

  • **Step Out (Shift + F8)：**步出，从步入的方法内退出到方法调用处，此时方法已执行完毕，只是还没有完成赋值。

  • **Drop Frame (默认无)：**回退断点，后面章节详细说明。

  • **Run to Cursor (Alt + F9)：**运行到光标处，你可以将光标定位到你需要查看的那一行，然后使用这个功能，代码会运行至光标行，而不需要打断点。

  • **Evaluate Expression (Alt + F8)：**计算表达式

for循环的简单使用：

20.fori —— for (int i = 0; i < 20; i++)

8、方法：

package cn.itcast.day04.demo02;
/**
 * 方法其实就是若干语句的功能集合
 * 方法：（好比一个工厂）
 * 参数：进入方法的参数
 * 返回值类型：从方法出来的数据
 *
 * 定义方法的完整格式：
 * 修饰符 返回值类型 方法名称（参数类型 参数名称,……）{
 *     方法体
 *     return
 * }
 *
 *      修饰符 public static
 *      返回值类型：方法最终产生的数据结果的是什么类型
 *      方法名称：方法的名字，规则和变量一样，小驼峰
 *       参数类型：进入方法的数据是什么类型
 *      参数名称：进入方法对应的变量名称
 *
 * 注意参数如果有多个，使用逗号隔开
 * 方法体：方法要做的事情
 * return ：两个作用：
 *      1、停止当前方法，
 *      2、将后面的返回值还给屌用处
 *
 *  返回值：就是方法执行后最终产生的数据结果
 *
 *  return后面的返回值类型必须和方法名称前面的返回值类型保持一致
 *
 *  //定义一个两个int类型的数值相加，
 *  返回值类型：int
 *  方法名称：sum
 *  参数列表：int a ,int b
 *
 *
 *  方法的三种调用格式：
 *      1、单独调用：（方法名称（参数））
 *      2、打印调用  (System.out.println(sum(10,20)))
 *      3、赋值调用
 *
 * */
public class Demo02Method {
    public static void main(String[] args) {
        //单独调用
        sum(10,20);

        //打印调用：
        System.out.println(sum(10,20));

        //赋值调用
        int number  = sum(10,20);       //30
        number+=100;                        //30+100
        System.out.println("number = " + number);

    }

    private static int sum(int a, int b) {
        System.out.println("方法执行了!");
        int result= a+b;
        return result;
    }
}




package cn.itcast.day04.demo02;
/**
 * 方法有参数：
 *      小括号当中有内容，当有个方法需要一些数据条件才能完成任务，就会有参数，
 *      例如两个数相加，鄙俗知道两个数字是多少
 * 方法没有参数：
 *      小括号当中留空，一个方法不需要任何数据条件，自己能够独立完成任务，就是无参数
 *      例如：定义方法，打印固定10次的helloworld
 *
 *
 *
 * */
public class Demo03MethodParam {
    public static void main(String[] args) {
        method1(10,29);
        method2();

    }

    public static void method1(int a ,int b ){
    //两个数字相乘，做乘法，必须知道两个数字的是多少，否则无法计算
    //有参数
        int result= a*b;
        System.out.println("result = " + result);

    }

    public static void method2(){
        for (int i = 0; i < 10; i++) {
            System.out.println("HelloWorld");
        }
    }
}

使用方法的注意事项：

  • ​ 1、方法定义在类中，但不能定义在 方法中，不能嵌套使用
  • ​ 2、方法定义的顺序没有要求
  • ​ 3、方法定义了不会马上执行，需要调用，
  • ​ 4、如果方法有返回值，就必须写上return
  • ​ 5、return后面的额返回值类型，必须和方法的返回值类型相对应
  • ​ 6、对于一个void没有返回值的方法，不能写return后的的返回值，只能写return，没有返回值的return只是结束党发的执行
  • ​ 7、对方法的最后一行的return，可以省略不写
  • ​ 8、一个方法有很多的return语句，但是必须保证同时只会有一个被执行
public static void Method(){
	System.out.println("ccc");
    System.out.println("qqq");
    return	//可以省略
}

public static void method(){
    return 10;		//错误的
    //因为方法没有返回值
}

public statici int method(){
    return 10;
}

1、重载：

* 重载：
*      对于功能类似的方法来说，因为参数列表不同，却需要记住这么多的方法名称，太麻烦，
*
*      为了解决这个问题，java就提供了方法的重载（OverLoad）
*      方法的重载：多个方法的名称一样，但是参数列表不同
*
*      优点：只需要记住唯一的一个方法名称，简便
*
*      注意事项：
*          1、参数的个数不同，
*          2、参数的类型不同
*          3、参数的顺序不同
*
*      方法重载与下列因素无关：
*        1、与参数的名称无关
*        2、与方法的返回值类型无关
    public class DemoMethodOverLoad {
    public static void main(String[] args) {
//        System.out.println(sumTwo(10,20));
//        System.out.println(sumThree(10,20,30));
//        System.out.println(sumFour(10,20,30,40));

        System.out.println(sum(10,30));
        System.out.println(sum(10,20,30,30));

        System.out.println(sum(1.1,1.9));

    }

    两个数相加
//    public static int sumTwo(int a, int b) {
        return a + b;
    }

    //三个数相加
    public static int sumThree(int a, int b, int c) {
        return a + b + c;
    }

    //四个数相加：
    public static int sumFour(int a, int b, int c, int d) {
        return a + b + c + d;

    //两个数相加
    public static int sum(int a, int b) {
        return a + b;
    }

    //三个数相加
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

    //四个数相加：
    public static int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }


    public  static int sum(double a,double b){
        return (int)(a+b);
    }
}

9、数组：

1、数组概念：

概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致

2、数组的定义：

两种常见的初始化：
  • 动态初始化：（指定长度）
  • 静态初始化：（指定内容）
方式1：动态初始化：（指定长度）

格式:数据存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[长度];

int [] arr = new int[100];		//存储100个int类型的数据
String [] arr = new String[5]	//存储5个String的字符串
方式2：静态初始化：（指定内容）

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

int [] arr = new int[]{1,2,3,4,5……}

方式3：静态初始化：（指定内容）(优化)

格式：数据类型[ ] 数组名= {元素1，元素2、元素3……}；

int [] arr = {1,2,3,4,5};
注意：
* 注意事项：
	   1、数组有定长特性，长度一旦指定，不可以更改
*      2、静态初始化没有指定长度，但是仍然会自动推算得到长度
*      3、静态初始化标准格式可以拆分为两个步骤：
*          int[] arr;
*          arr = new int[] {1,2,3,4,5};
*      4、静态初始化一旦使用省略格式，就不能拆分两个步骤
使用建议：

如果不确定数组当中的具体内容，就用动态初始化（指定长度），否则，已经确定了具体的内容就使用静态初始化（指定内容）

3、数组的访问：

索引：

  • 每一个存储到数组的元素，都会自动编号，称为数组索引（index），可以通过数组的索引访问到数组的元素

  • 数组名[索引]

  • 注意：索引元素从0开始，一直到【数组的长度-1】为止

数据长度的属性：

每一个数组都有长度，而且是固定的，java中赋予了数组的一个属性，可以获取到数组的长度，，语句为（数组名.length）,属性length的执行结果就是数组的长度，int类型的结果，由此可以推出数组的最大索引值为（数组名.length-1）

public static void main(String [] args){
    int [] arr = int [] {1,2,3,4,5,5}
	System.out.println(arr.length)	//输出数组的长度

}

使用动态初始化数组的时候，那么其中的元素将会拥有一个默认值，规则如下：

  • 如果是整数类型：默认是0
  • 如果是浮点类型：默认是0.0
  • 如果是字符乐行：默认是’\u0000’

静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换为大括号当中具体的数值

int[] arr = new int[3];
System.out.println(arr);		//[I@1c53fd30
System.out.ptinyln(arr[0]);		//0
System.out.println(arr[1]);		//0

//赋值
arr[1] = 123;
sout(arr[1])		//123

4、java内存的划分：

1、栈（Stack）

存放的都是方法中的局部变量，【方法的运行一定在栈中】

  • ​ 局部变量：方法的参数，或者是{} 内部的变量
  • ​ 作用域：一旦超出作用域，就会从栈内存中消失
2、堆（Heap）:

【凡是new出来的东西，都在堆内存中】，堆内存里面的东西都有一个地址值：16进制，堆内存中的数据都有默认值，规则：

  • 如果是整数： 默认是0
  • 如果是浮点数：默认是0.0
  • 如果是字符 默认是’\u0000’
  • 如果boolean 默认是false
  • 如果 引用类型 默认是null
3、方法区(Method Area)：

存储class相关的信息，包含方法 的信息

4、本地方法栈（Native Method Stack）:

与操作系统相关

5、寄存器（PC Register）

与cpu相关

5、索引越界：ArrayIndexOutOfBoundsException

原因：索引编号写错了，索引从0开始，长度是：数组名.length

解决：写上正确的索引编号

6、空指针异常：NullPointerException

  • 数组必须进行new初始化才能使用元素，没过只是赋值一个null，没有进行new的创建，就会发生空指针异常
  • 原因：没有new
  • 解决：补上new

7、获取数组长度：

格式：数组名.length

public  static void main(String[] args){
    int [] arr = new int[3];
    System.out.println(arr.length);		//3
    
    int [] array = {1,2,3,4,5};
    Sysstem.out.println(array.length);		//5 
}

8、数组的遍历：

public static void main(String[] args){
    int [] arr = {1,2,3,4,5};
    for(int x= 0; x<arr.length; x++){		
        System.out.println(arr[x]);		//1 2 3 4 5
    }
}

9、数组元素的反转：

数组的反转：对称位置的元素交换，1,2,3,4,5反转为1，5,4,3,2,1

实现思想：数组的元素互换位置

package Demo01;

public class Demo06ArrayReverse {
    public static void main(String[] args) {
        int []  array = {10,20,30,40,50};

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        System.out.println("===============");
        /**
         * 初始化语句：int min= 0, max = array.length
         * 条件判断：min<max
         * 步进表达式：min++，max--
         * */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        //反转后遍历
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);

        }
    }
}


//3

int [] array = {1,2,3,4,5};
Sysstem.out.println(array.length);		//5

}


### 8、数组的遍历：

```java
public static void main(String[] args){
    int [] arr = {1,2,3,4,5};
    for(int x= 0; x<arr.length; x++){		
        System.out.println(arr[x]);		//1 2 3 4 5
    }
}

9、数组元素的反转：

数组的反转：对称位置的元素交换，1,2,3,4,5反转为1，5,4,3,2,1

实现思想：数组的元素互换位置

package Demo01;

public class Demo06ArrayReverse {
    public static void main(String[] args) {
        int []  array = {10,20,30,40,50};

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        System.out.println("===============");
        /**
         * 初始化语句：int min= 0, max = array.length
         * 条件判断：min<max
         * 步进表达式：min++，max--
         * */
        for (int min = 0, max = array.length - 1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        //反转后遍历
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);

        }
    }
}
1720500851
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
零基础学java---方法method（4）
小新的博客
04-06 477
方法 6.方法重载 6.1 方法重载概述 方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法互相构成重载 * 多个方法在同一个类中 * 多个放方法具有相同方法名 * 多个方法的参数不相同，类型不同或数量不同 6.2 方法重载特特点 * 重载仅对应方法的定义，与方法的调用无关，调用方法参照标准格式 * 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判断两个方法是否构成重载 示例： public class MethodDemo{.
Math常用方法
大道至简
12-03 264
Math.floor() 通过该函数计算后的返回值是舍去小数点后的数值，如： Math.floor(3.2) // 返回3 Math.floor(3.9) // 返回3 Math.floor(3.0) // 返回3 Math.ceil() ceil函数只要小数点非0，将返回整数部分+1，如： Math.ceil(3.2) // 返回4 Math.ceil(3.9) // 返回4 Math....
java.lang.math.trunc_Java基础练习题附答案
weixin_31419153的博客
03-01 572
word格式}以下哪条语句可以安排在//Here处 ? A．MyOver m = new MyOver(); B．super();C．this(\D．Base b = new Base(10); 14) 设有类定义如下： class InOut{String s= new String(\public void amethod(final int iArgs){ int iam; ...
Java测试（仅选择和判断）
wings的博客
12-25 1003
判断题 1-1 java语言中不用区分字母的大写小写。 F 1-2 系统自动引入java.lang包中的所有类，因此不需要再显式地使用import语句引入该包的所有类。 T 1-3 java.lang包是Java的核心类库，它包含了运行Java程序必不可少的系统类。 T 1-4 在Java程序中，可以使用protected来修饰一个类。F 类的修饰符分为：可访问控制符和非访问控制符两种。 可访问控制符是：公共类修饰符 public 非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final
第四章 方法(4.4 方法的参数)
weixin_30369041的博客
04-28 174
【案例】 【案例目的】 【技术要点】 【代码及分析】 转载于:https://www.cnblogs.com/programme-maker/p/10683337.html
java_folder：核心java编程
02-14
【描述】"java_folder：核心java编程"的描述简洁明了，没有提供具体的内容细节，但我们可以推测它涵盖了Java语言的基础到进阶知识。Java是一门广泛使用的面向对象编程语言，以其平台无关性、高效性和安全性著称。...
java基面试础知识详解
08-25
Java基础知识在面试中占据着重要地位，因为它涵盖了编程的核心概念，包括面向对象的三大特性：封装、继承和多态。接下来我们将深入探讨这些主题。 **封装**是面向对象编程的基础，它强调将数据和操作数据的方法捆绑...
最全的Java程序员知识（专业知识+面试+视频教程）学习资料合集.zip
最新发布
10-29
最全的Java程序员知识学习资料合集，共20+专题。 开源框架面试题系列：Spring+SpringMVC+MyBatis 分布式限流面试专题系列：Nginx+zookeeper 分布式通讯面试专题系列：ActiveMQ+RabbitMQ+Kafka 分布式数据库面试专题...
Java_testWithThread:带有2种变化颜色的弹跳球
05-14
总的来说，这个项目涵盖了以下几个关键知识点： 1. **Java Swing**：如何使用JFrame、JPanel等组件创建窗口和图形元素，以及如何响应用户事件。 2. **多线程**：如何创建和管理线程，理解Thread类和Runnable接口，...
java基础试题答案.zip_Java 基礎面試題 附答案
09-21
Java是世界上最流行的编程语言之一，尤其对于初学者来说，掌握Java基础知识是至关重要的。这份"java基础试题答案.zip"压缩包文件提供了丰富的Java面试复习题，涵盖了Java的基础知识点，非常适合新手进行练习和自我...
公式编辑器MathType6.6一些常见问题的解决方法 (2010年)
05-14
在使用公式编辑器MathType6.6来编辑物理和数学公式时经常会出现一些问题,这些问题影响到了文章的美观甚至是影响到了读者的阅读,本文根据这些常见问题提出了相应的解决方法。
#Java学习总结4
jaingbei的博客
12-08 126
1.方法 方法的概念 方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。 注意： 1.方法必须先创建才可以使用，该过程称为方法定义 2.方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程称为方法调用 无参数方法定义和调用 定义格式： public static void method(){ //方法体； } 调用格式： 方法名()； 方法...
Method详解
热门推荐
zhangquanit的专栏
10-25 2万+
java反射的Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。
Math与Date对象详解
youhebuke225的博客
07-15 301
脑图 目录1 Math对象1.1 Math常用属性1.1.1 Math.PI1.2 Math常用方法1.2.1 [abs(x)](https://www.w3school.com.cn/jsref/jsref_abs.asp)1.2.2 [random()](https://www.w3school.com.cn/jsref/jsref_random.asp)1.2.3 取整向下取整向上取整四舍五入1.2.4 最值 [max(x,y)](https://www.w3school.com.cn/jsr
java base()题目_Java基础练习题 考试题 笔试题 面试题 （3）
weixin_33585889的博客
02-16 1431
八、继承与多态1)以下程序调试结果为：class Base{Base(){inti = 100;System.out.print (i);}}public class Pri extends Base{static int i = 200;public static void main(String argv[]){Pri p = new Pri();System.out.print(i);}}A...
java题1
weixin_42175570的博客
10-05 1万+
  1、面向对象的特征有哪些方面      ①抽象：     抽象是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。     ②继承：     继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类...
java面试题2
weixin_30375427的博客
06-26 561
1、面向对象的特征有哪些方面 (1).抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。(2).继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类...
华为技能鉴定java_华为Java笔试题
weixin_36076907的博客
02-13 4153
华为Java笔试题＋数据库题一、 单项选择题1．Java是从( )语言改进重新设计。A．Ada B．C++ C．Pasacal D．BASIC2．下列语句哪一个正确( )A． Java程序经编译后会产生machine codeB． Java程序经编译后会产生byte codeC． Java程序经编译后会产生DLLD． 以上都不正确3．下列说法正确的有( )A． class中的constructor...
Java核心技术：卷Ⅰ基础知识与集合框架解析
"Java核心技术，卷Ⅰ：基础知识（原书第8版）"，这本书是Sun Microsystems Press出版的Sun公司核心技术丛书中的一本，由Cay S. Horstmann和Gary Cornell合著，中文版由叶乃文、邝劲筠、杜永萍翻译。本书覆盖了Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值