//**笔记知识点汇总主要源自B站黑马程序员Java零基础视频教程**//

按Win+R并输入cmd回车打开cmd控制台

常用CMD命令

1.盘符名称＋冒号：盘符切换

例：F:回车，即切换至F盘

 2.dir：查看当前路径下内容(展示隐藏目录)

例：dir回车，即展开当前路径下内容

 3.cd目录：进入单级目录

例：cd .android回车，即进入该目录

4.cd..：退回到上一级目录

例：cd..回车，即退回上级目录

5.cd 目录1\目录2\...:进入多级目录

例：进入E:ODIS\CER

6.cd\：回退到盘符目录

例：cd \回车

7.cls：清屏

例：cls回车

8.exit:退出命令提示符窗口

例：exit回车，即退出cmd命令窗

*9.练习：打开网易云音乐

法一：

 法二：

点击高级系统设置、环境变量

双击系统变量中Path并添加路径

注：

（1）为什么要配置环境变量？

在任意目录下可以打开指定软件。

安装好java JDK后

（1）按Win+R并输入cmd回车打开cmd控制台

（2）输入java -version，如果能够成功输出java jdk 的版本，即表明java JDK 环境变量配置完成。

编译程序（入门案例）

public class helloworld
{public static void main(String[] args){System.out.println("Hello World!");}
}

注：

javac工具：把.java文件编译成.class文件

java工具：运行代码

常见高级记事本：Editplus、Notepad++、Sublime...

Notepad++配置

注释

1.单行注释：//注释信息

2.多行注释：/*注释信息*/

3.文档注释：/**注释信息*/

关键字

关键字全部小写且高亮显示

class：用于（创建/定义）一个类

类是Java最基本的组成单位

HelloWorld在本段代码中表示类的名字

{}表示类的范畴

public class HelloWorld
{
}

字面量

布尔类型：布尔值，表示真假。只有两个值：true,false

空类型：空值：null

输出语句：System.out.println();

public class ValueDemol{public static void main(String[] args){System.out.println(666);System.out.println(-666);System.out.println(6.66);System.out.println(-6.66);System.out.println(true);System.out.println(false);System.out.println("菜菜不是菜菜");System.out.println('菜');System.out.println("null");
//null不能直接打印,要用字符串的形式进行打印
}
}

 \t 制表符：

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

public class ValueDemol{public static void main(String[] args){System.out.println("name" + '\t' + "age");System.out.println("sue" + '\t' + "18");
}
}

变量

注：只能存一个值；变量名不允许重复定义；一条语句可以定义多个变量；变量在使用之前一定要进行赋值；变量的作用域范围。

public class ValueDemol{public static void main(String[] args){//定义变量//数据类型 变量名 = 数据值//数据类型：限定了变量能存储数据的类型//int(整数) double(小数)//变量名：就是存储空间的名字//作用：方便以后使用//数据值：真正存在变量中的数据//等号：赋值。把右边的数据赋值给左边的变量int a = 10;System.out.println(a);
}
}


public class ValueDemol{public static void main(String[] args){//定义变量int a = 10;System.out.println(a);System.out.println("--------");//变量参与计算int b = 30;int c = 20;System.out.println(b + c);System.out.println("--------");//修改变量记录的值a = 50;System.out.println(a);System.out.println("--------");//一条语句中可定义多个变量int d = 100,e = 200, f = 300;System.out.println(d);System.out.println(e);System.out.println(f);//变量在使用之前必须要赋值，不要把赋值分开写}
}

变量的练习-计算公交车的人数

public class ValueDemol{public static void main(String[] args){//一开始没有乘客int count = 0;//第一站：上去一位乘客count = count + 1;//第二站：上去一位乘客，下来一位乘客count = count + 2 - 1;//第三站：上去一位乘客，下来一位乘客count = count + 2 - 1;//第四站：下来一位乘客count = count - 1;    //第五站：上去一位乘客count = count +1;System.out.println(count);}
}

整数和小数取值范围大小关系：double>float>long>short>byte

long类型变量：需要加入L标识（大小写都可以）

float类型变量：需要加入F标识（大小写都可以）

byte b = 10;
short a = 20;
int c = 30;
long n = 999999L;
float f = 10.1F;
double d = 20.2;

定义变量的三个练习

public class ValueDemol{public static void main(String[] args){//定义变量记录姓名String name = "菜菜不是菜菜";//定义变量记录年龄int age = 10;//定义变量记录性别char gender = '无';//定义变量记录身高double height = 151.2;//定义变量记录是否单身//true单身，false不是单身boolean flag = true;//输出变量的值System.out.println(name);System.out.println(age);System.out.println(gender);System.out.println(height);System.out.println(flag);
}
}

标识符：给类，方法，变量等起的名字。

命名规则--硬性要求

1.由数字、字母、下划线（_）和美元（$）组成

2.不能以数字开头

3.不能是关键字

4.区分大小写

命名规则--软性建议

小驼峰命名法：方法、变量

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

范例1：name

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

范例2：firstName

大驼峰命名法：

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

范例1：Student

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

范例2：GoodStudent

键盘录入

Scanner:可以接收键盘输入数字的类

步骤一：导包-Scanner这个类在哪

import java.util.Scanner;
//导包的动作必须出现在类定义的上边

步骤二：创建对象-表示我要开始用Scanner这个类了

Scanner sc = new Scanner(System.in);
//只有sc是变量名，可以变

步骤三：接收数据

int i = sc.nextInt();
//只有i是变量名，可以变
import java.util.Scanner;
public class ScannerDemol{public static void main(String[] args){Scanner sc = new Scanner(System.in);int i = sc.nextInt();System.out.println(i);
}
}

error:编码 UTF-8 的不可映射字符

解决方案一：添加命令

例 javac -encoding gbk 文件名.java，即可识别中文

键盘录入小练习

import java.util.Scanner;
public class ScannerText{public static void main(String[] args){Scanner sc = new Scanner(System.in);System.out.println("请输入i值");int i = sc.nextInt();System.out.println("请输入y值");int y = sc.nextInt();System.out.println(i + y);
}
}

IDEA项目结构介绍

project(项目)---module(模块)---package(包)---class(类)

（在类里面编写代码）

 等待读取完成

新建与打开包

 多级包之间用.来隔开

编写代码

IDEA个性化设置

重命名（shift+f6）

%：取模、取余

System.out.println(10 / 3);//3
System.out.println(10.0 / 3);//3.3333333
System.out.println(10 % 2);//0
System.out.println(10 % 3);//1

数值拆分

需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

package www.demol;
import java.util.Scanner;public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("Please input a three-digit");int number = sc.nextInt();//个位：数值%10int ge = number % 10;//十位：数值/10%10int shi = number / 10 % 10;//百位：数值/100%10int bai = number / 100 % 10;System.out.println(ge);System.out.println(shi);System.out.println(bai);}
}

类型一样的数据才可运算

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

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

隐式转换的两种提升规则

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

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

小byte<<short<<int<<long<<float<<double大

练习

byte b1 = 10;
byte b2 = 20;
result = b1 + b2;
//数据类型 (int)result = (int)b1 + (int)b2;
-------------------------------
int i = 10;
long n = 100L;
double d = 20.0;
result = i + n + d;
//数据类型（double）result = (double)[(long)i + n] + d;
-------------------------------
byte b = 10;
short s = 20;
long n = 100L;
result = b + s + n
//数据类型 (long)result = (long)[(int)b + (int)s] + n;

强制转换

把一个取值范围大的数值赋值给取值范围小的变量

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

double a = 12.3;
int b = (int)a;
int a = 300;
byte b = (byte)a;
//数据较大转较小会出错

数据类型

关键字    占用    取值范围
整数              byte    1Byte    -128~127
整数              short    2Byte    -32768~32767
整数              int       4Byte    -231~231-1
整数              long    8Byte    -263~263-1
浮点数          float    4Byte    -3.402823E+38~-1.401298E-45
                                              1.401298E-45~3.402823E+38
浮点数         double  8Byte    -1.797693E+308到-4.9000000E-324
                                              4.9000000E-324到1.797693E+308
字符             char    2Byte    0-65535
布尔            boolean   1Byte    true    false

算数运算符

字符串的“+”操作
有字符串参与就是拼接，反之相加。

含字符的运算会把字符通过ASCII码表查询到对应的数字再进行计算

“123”+123   》》》》》“123123”

1+99+“年黑马”》》》》》“100年黑马”

System.out.println(1 + 'a');//98
System.out.println('a' + "abc");//"aabc"

练习

package www.demol;
import java.util.Scanner;public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入一个三位数");int number = sc.nextInt();//个位：数值%10int ge = number % 10;//十位：数值/10%10int shi = number / 10 % 10;//百位：数值/100%10int bai = number / 100 % 10;System.out.println("个位是："+ge);System.out.println("十位是："+shi);System.out.println("百位是："+bai);}
}

IDEA编译中文报错

环境

Windows 10
IntelliJ IDEA Community Edition 2022.2
JDK18

步骤

第一步 Settings-File Encodings中将Global和Project的编码都改成Default

第二步 在Help-Edit Custom VM Option中添加 -Dfile.encoding=GBK（让第一步中Default的编码方式固定为GBK）

注：与在源文件bin中的idea64.vmoption中增加-Dfile.encoding=xxx 相比 ，Edit Custom VM Option的优先级更高

第三步 重启IDEA（重启软件后操作生效）
————————————————
版权声明：本解决方案为CSDN博主「AShyyyyyyy」的原创文章，本菜菜遵循CC 4.0 BY-SA版权协议进行转载。
原文链接：https://blog.csdn.net/weixin_45074731/article/details/125681535

自增自减运算符

package www.demol;
public class text111 {public static void main(String[] args) {int x = 10;int y = x++;//先用后加 y=10,x=11int z = ++x;//现加后用 x=12,z=12System.out.println("x："+x);//12System.out.println("y："+y);//10System.out.println("z："+z);//12}
}

赋值运算符

 注：拓展的赋值运算符隐含了强制类型转换

关系运算符

例

 System.out.println(a == b);

练习（约会）

package www.demol;import java.util.Scanner;
//键入
public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);//键入System.out.println("请输入自己衣服的时髦度");int myfashion = sc.nextInt();//键入System.out.println("请输入女生衣服的时髦度");int girlfashion = sc.nextInt();//键入boolean result = myfashion >= girlfashion;//布尔System.out.println(result);}
}

逻辑运算符

短路逻辑运算符

注：& |，无论左边true false，右边都要执行

      &&  ||，如果左边能确定整个表达式的结果，右边不执行

     &&左边为false，右边不管是真是假，整个表达式的结果一定是false

     ||左边为true，右边不管是真是假，整个表达式的结果一定是true

    这两种情况下，右边不执行，提高了效率

练习（数字6）

//键盘录入两个整数，如果其中一个为6，最终结果输出true.如果它们的和为6的倍数，最终结果输出true.其它结果为false.
package www.demol;
import java.util.Scanner;
//键入
public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);//键入System.out.println("请输入一个整数");int number1 = sc.nextInt();//键入System.out.println("请输入第二个整数");int number2 = sc.nextInt();//键入boolean result = number1 ==6 || number2 ==6 || (number2+number1)%6==0;//布尔System.out.println(result);}
}

三元运算符

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

注：三元表达式的结果必须被使用，否则

范例：求两个数的较大值

int max = a>b ? a :b;//把结果赋值给一个变量
System.out.println(a>b ? a :b);//把结果直接打印

练习（两只老虎）

//比较两只老虎的体重
package www.demol;
import java.util.Scanner;
//键入
public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);//键入System.out.println("请输入第一只老虎的体重");int number1 = sc.nextInt();//键入System.out.println("请输入第二只老虎的体重");int number2 = sc.nextInt();//键入String result = number1 == number2 ?"相同" :"不同";System.out.println(result);}
}

 ctrl+alt+l自动格式化代码

运算符优先级

原码、反码、补码

原码(是一种计算机中对数字的二进制定点表示方法。原码表示法在数值前面增加了一位符号位（即最高位为符号位）：正数该位为0，负数该位为1（0有两种表示：+0和-0），其余位表示数值的大小。

反码：正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外

补码：正数的补码与其原码相同;负数的补码是在其反码的末位加1

if语句

一种情况的判断

格式：   if(关系表达式){

                        命令

                                    }

注：如果对一个布尔类型的变量进行判断，不要用==号，直接把变量写在小括号即可

boolean flag = false;
if (flag){............
}
//flag为true时执行

两种情况的判断

格式：if(关系表达式){

           语句1;

}        else{

           语句2;

}

多种情况的判断

格式：if(关系表达式){

           语句1;

}        else if{

           语句2;

}

......

           else{

   语句n+1;

}

switch语句   

格式1：

switch(表达式){

 case1:      语句1;   break;

 case2:      语句2;   break;

....

default:      语句n+1;  break;

}

注：表达式：（将要匹配的值）取值为byte、short、int、char

   JDK5以后可以是枚举，JDK7以后可以是String

格式2：

switch(表达式){

 case1->   {语句1;}

 case2,3,4->   {语句2;}

....

default:->     {语句n+1;}

}

for循环

格式：

for(初始化语句;条件判断语句;条件控制语句){

            循环体语句；

}

for(int i = 1;i <=10;i++){System.out.println("HelloWorld")
}

while循环

格式：

初始化语句；

while(条件判断语句){

         循环体语句;

         条件控制语句;

}

int i = 0;
while(i < 4){i++;
}
System.out.println(i);

for和while的对比

for循环中，控制循环的变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问了；知道循环的次数和范围

while循环中，控制循环的变量，因为while循环来说不归属其语法结构中，在while循环结束后，其变量还可以继续被访问;只知道循环的结束条件

do...while循环(先执行后判断-至少执行一次)

格式：

初始化语句；

do{

 循环体语句;

条件控制语句;

}while(条件控制语句);

无限循环

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

注：无限循环的下面不能写其它代码，因为循环不止

练习

package www.demol;
public class text111 {public static void main(String[] args){for( int x=1; x<=5; x++){if(x==3){continue;}System.out.println("小老虎在吃第"+x+"个包子");}}
}

package www.demol;
public class text111 {public static void main(String[] args) {for (int x = 1; x <= 5; x++) {System.out.println("小老虎在吃第" + x + "个包子");if (x == 3) {break;}}}

JAVA：找不到符号（ＩＤＥＡ定义变量）

环境

Lombok:bundled 222.3345.118

IDEA:2022.2

JDK1.8

步骤

右键点击此电脑-属性

%JAVA_HOME%\bin

-Djps.track.ap.dependencies=false

点击修复IDE,跟随右下角提示进行操作

关闭IDEA进程再打开

练习（循环）：逢七过

package www.demol;
public class text111 {public static void main(String[] args) {for (int x = 1; x <= 100; x++) {if (x %10 == 7 ||x/10%10 == 7||x%7 == 0) {System.out.println("过");／／１００以内含７或７的倍数打印“过”continue;}System.out.println(x);}}}

练习（循环）：求平方根

package www.demol;
import java.util.Scanner;
//键入.导包
public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);//键入.创建对象System.out.println("请输入一个整数");int number = sc.nextInt();//键入.接收数据for (int x = 1; x <= number; x++) {if (x*x==number) {System.out.println(x+"就是"+number+"的平方根");break;}else if (x*x>number){System.out.println((x-1)+"就是"+number+"平方根的整数部分");break;}}}}

练习（循环）：质数判断

package www.demol;import java.util.Scanner;
//键入.导包public class text111 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);//键入.创建对象System.out.println("请输入一个正整数");int number = sc.nextInt();//键入.接收数据boolean flag = true;for (int x = 2; x <= number; x++) {if (number % x == 0) {flag = false;//System.out.println(number+"不是一个质数");break;}/*else{System.out.println(number+"是一个质数");break;}*/}if(flag){System.out.println(number+"是一个质数");}else{System.out.println(number+"是一个质数");}}}

 简化版

int number = 100;
for (int x = 2; x <= number的平方根; x++) ｛// System.out.println(number+"是一个质数");
｝

练习（循环）：猜数字

类：Random，可以生成一个随机数

 注：在小括号中，书写的是生成随机数的范围

       这个范围一定是从0开始，到这个数-1结束

口诀：包头不包尾，包左不包右

package www.demol;import java.util.Scanner;
//键入import java.util.Random;
//随机数public class text111 {public static void main(String[] args) {Random r = new Random();//创建对象int number = r.nextInt(100)+1;//1-100//生成// int count = 0;//计数器Scanner sc = new Scanner(System.in);//键入while (true){System.out.println("请输入你要猜的数字");int getnumber = sc.nextInt();//键入count ++;/*  if (count ==3 ){System.out.println("猜中了");break;}*/if(getnumber >number){System.out.println("大了");}else if(getnumber < number){System.out.println("小了");}else {System.out.println("猜中了");break;}}}}

数组

数组：是一种容器，可以用来存储同种数据类型的多个值

数组容器在存储数据的时候，需要结合隐式转换考虑

例：int类型的数组容器（boolean byte short int double）

       double 类型的数组容器(byte short int long float double)

 建议：容器的类型，和存储的类型保持一致

数组的定义：        数据类型 [ ]数组名      int  [ ] array 

                             数据类型  数组名[ ]     int  array[ ]  

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

数组的静态初始化：数据类型 [ ]数组名 = new 数据类型 [ ]{元素1，元素2...};

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

        double[ ] array2 = new double[ ]{1.1,2.2,3.3};

简化：int[ ] array = {11,22,33};

        double[ ] array2 = {1.1,2.2,3.3};

       String[ ] array3 = {"zs","ls","ww"};

    System.out.println(array);//[I@6d03e736为数组地址值

[:表示当前是一个数组

I、D:表示当前数组类型int、double

@：表示一个间隔符号（固定格式）

6d03e736：数组真正地址值（十六进制）

索引：也叫下标，角标

索引的特点：从0开始，逐个+1增长，连续不间断

例：int number =array[0];//0索引上对应的值赋给number

    System.out.println(array[0]);//打印0索引对应的值

   array[0]=100;在0索引中覆盖存储100

package www.demol;
public class text111 {public static void main(String[] args) {int[] arr = {1,2,3,4,5};//定义数组/*System.out.println(arr[0]);  数组名[索引]*///利用循环改造代码//开始条件：0//结束条件：数组的长度-1（最大索引）/*输入fori生成for (int i = 0; i < 5; i++) {}*/for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);//i:0 1 2 3 4}//idea提供：数组名.fori，自动的快速生成数组的遍历方式}}

练习（数组）：求和

package www.demol;
public class text111 {public static void main(String[] args) {int[] arr = {1,2,3,4,5};//定义数组int sum = 0;//求和变量for (int i = 0; i < arr.length; i++) {sum = sum + arr[i];}System.out.println(sum);}}

练习（数组）：求值

package www.demol;
public class text111 {public static void main(String[] args) {int[] arr = {1,2,3,4,5,6,7,8,9,10};//定义数组int count = 0;//计数for (int i = 0; i < arr.length; i++) {if(arr[i] % 3 == 0){count++;}}System.out.println("数组中能被3整除的数有"+count+"个");}}

练习（数组）：变化数据

package www.demol;
public class text111 {public static void main(String[] args) {int[] arr = {1,2,3,4,5,6,7,8,9,10};//定义数组for (int i = 0; i < arr.length; i++) //遍历数组得到每一个元素{if(arr[i] % 2 == 0){                    //偶数 变成二分之一arr[i]/=2;}else {arr[i]*=2;                         //奇数 扩大两倍}}for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}}}

注：一个循环只做一个事情

数组动态初始化

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

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

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

数组默认初始化值规律

整数类型：默认初始化值0

小数类型:默认初始化值0.0

字符类型:默认初始化值‘/u0000’空格

布尔类型:默认初始化值false

引用数据类型:默认初始化值null

package www.demol;
public class text111 {public static void main(String[] args) {String[] arr =new String[50];//创建数组arr[0] = "zs";arr[1] = "ls";System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);int[] arr2 =new int[3];System.out.println(arr2[0]);System.out.println(arr2[1]);System.out.println(arr2[2]);}}

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

动态初始化：手动指定数组长度，由系统给出默认初始值

*只明确元素个数，不明确具体数值，推荐使用动态初始化

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

int[] arr = {?????};

int[] arr = new int[5];

-------------------------------------------------------------------------------------------------------------------

静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度

*需求中已经明确了要操作的具体数据，直接静态初始化即可

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

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

数组常见问题：当访问了数组中不存在的索引，就会引发索引越界异常

练习（数组）：最值

package www.demol;
public class text111 {public static void main(String[] args) {int[] arr ={33,5,22,44,55};int max = arr[0];for (int i = 0; i < arr.length; i++) {if(arr[i]>max){max=arr[i];}}System.out.println(max);}}

练习（数组）：求和并统计个数

package www.demol;
import java.util.Random;
//随机数
public class text111 {public static void main(String[] args) {int []arr = new int[10];//定义数组Random r = new Random();//创建对象for (int i = 0; i < arr.length; i++) {int number = r.nextInt(100)+1;//1-100//生成arr[i]=number;}
int sum = 0;//遍历数组for (int i = 0; i < arr.length; i++) {sum =sum + arr[i];}System.out.println("和为"+sum);int avg = sum / arr.length;System.out.println("平均值为"+avg);int count = 0;for (int i = 0; i < arr.length; i++) {if(arr[i]<avg){count++;}}System.out.println("有"+count+"个数据比平均数小");for(int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}}
}

练习（数组）：交换数据

package www.demol;
public class text111 {public static void main(String[] args) {int a = 10;int b = 20;int temp = a;a = b;b = temp;System.out.print(a);System.out.print(" ");System.out.print(b);}}

package www.demol;
public class text111 {public static void main(String[] args) {int []arr = {1,2,3,4,5};int temp = arr[0];arr[0] = arr[4];arr[4] = temp;for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}}}

package www.demol;
public class text111 {public static void main(String[] args) {int []arr = {1,2,3,4,5};for (int i = 0,j = arr.length - 1; i < j;i++,j--) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}}}

练习（数组）：打乱数组中的数据

package www.demol;
import java.util.Random;
public class text111 {public static void main(String[] args) {int []arr = {1,2,3,4,5};Random r = new Random();int randomIndex = r.nextInt(arr.length);System.out.println(randomIndex);}}

package www.demol;
import java.util.Random;
public class text111 {public static void main(String[] args) {int []arr = {1,2,3,4,5};Random r = new Random();for (int i = 0; i < arr.length; i++) {//生成一个随机索引int randomIndex = r.nextInt(arr.length);int temp = arr[i];arr[i] = arr[randomIndex];arr[randomIndex] = temp;}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}}}

JAVA内存分配

*栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行

*堆：存储对象或者数组，new来创建的，都存储在堆内存，并产生地址值

方法区：存储可以运行的class文件

本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关

寄存器：给CPU使用

int[] arr={11,22};
sout(arr[0]);//打印11

方法

方法是程序中最小的执行单元

例：main为主方法

重复的代码、具有独立功能的代码可以抽取到方法中

方法可以提高代码的复用性和可维护性

方法定义：把一些代码打包在一起的过程

public static 返回值类型 方法名（参数）{方法体;return 返回值;
}方法名（）;//调用方法

方法调用：方法定义后并不是直接运行的，需要手动调用才能执行

最简单方法定义和调用

package www.demol;
public class text111 {public static void main(String[] args) {System.out.print("a");method();System.out.print("b");}public static void method() {System.out.print("c");System.out.print("d");}}

package www.demol;
public class text111 {public static void main(String[] args) {sum();}public static void sum() {int a = 10;int b = 20;int result = a + b;System.out.print(result);}}

带参数方法定义和调用

package www.demol;
public class text111 {public static void main(String[] args) {method(10,20);//10、20为实参}public static void method(int a,int b)//a、b为形参{int result = a + b;System.out.print(result);}}

形参（形式参数）： 方法定义中的参数

实参（实际参数）：方法调用中的参数

带返回值方法的定义和调用

public static 返回值类型 方法名（参数）{方法体;return 返回值;
}public static int getsum（int a,int b）{int c = a + b;return c;
}

package www.demol;
public class text111 {public static void main(String[] args) {//  getsum(10, 20, 30);直接调用//  int sum = getsum(10, 20, 30);赋值调用// System.out, println(sum);//  System.out, println(getsum(10, 20, 30));输出调用int sum1 = getsum(10, 20, 30);int sum2 = getsum(10, 20, 30);int sum3 = getsum(10, 20, 30);int sum = sum1+sum2+sum3;System.out.println(sum);}public static int getsum (int a, int b, int c){int result = a + b + c;return result;}
}

注：

方法不调用就不执行

方法与方法之间是平级关系，不能互相嵌套

方法的编写顺序和执行顺序无关

方法的返回值类型为void,表示该方法没有返回值，没有返回值的方法可以省略return语句不写。

如果要编写return，后面不能跟具体的数据，return语句下面永远执行不到

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

方法有返回值：必须要写。表示结束方法和返回结果

方法的重载

同一个类中，方法名相同，参数不同（个数不同、类型不同、顺序不同）的方法，构成重载关系，且与返回值无关

package www.demol;
public class text111 {public static void main(String[] args) {compare(10,20);}public static void compare(int a,int b){System.out.println(a == b);System.out.println("int");}public static void compare(short c,short d){System.out.println(c == d);System.out.println("short");}public static void compare(byte e,byte f){System.out.println(e == f);System.out.println("byte");}public static void compare(long g,long h){System.out.println(g == h);System.out.println("long");}}

练习（方法）：拷贝数组

package www.demol;
public class text111 {public static void main(String[] args) {/*定义一个方法copyofrange(int[]arr,int form,int to)将数组arr中从索引from（包括from）到索引to（不包括to）结束的元素复制到新数组中，将新数组返回*/int[] arr= {1,2,3,4,5,6,7,8,9};//定义原始数组int[] copyArr= copyofrange(arr,3,7);//调用方法拷贝数组for (int i = 0; i < copyArr.length; i++)//遍历数组copyArr{System.out.println(copyArr[i]+" ");}}public static int[] copyofrange(int[] arr,int from,int to){int[] newArr = new int[to - from];//定义新数组，直接拷贝int index = 0;//伪造索引for (int i = from; i < to; i++) {newArr[index]=arr[i];//数组名[索引]=数据值index++;}return newArr;//返回新数组}
}

引用数据类型

变量中存储的是地址值

引用：使用了其他空间中的数据

基本数据类型：数据值是存储在自己空间中，赋值给其他变量，赋的真实值

引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值，赋值给其他变量，赋的地址值

int[] arr1 ={1,3,2};
int[] arr2 =arr1;

方法的值传递

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值

package www.demol;
public class text111 {public static void main(String[] args) {int num = 100;System.out.println("before change:"+num);//100change(num);System.out.println("after change:"+num);//100}public static void change(int num){num = 200;}
}

传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值

package www.demol;
public class text111 {public static void main(String[] args) {int [] arr={10,20,30};sout("调用change前:" + arr[1]);change(arr);sout("调用change后:" + arr[1];}public static void change(int []arr){arr[1] = 200;}
}

Java学习笔记（第6天）相关推荐

  1. java学习笔记11--Annotation

    java学习笔记11--Annotation Annotation:在JDK1.5之后增加的一个新特性,这种特性被称为元数据特性,在JDK1.5之后称为注释,即:使用注释的方式加入一些程序的信息. j ...

  2. java学习笔记13--反射机制与动态代理

    本文地址:http://www.cnblogs.com/archimedes/p/java-study-note13.html,转载请注明源地址. Java的反射机制 在Java运行时环境中,对于任意 ...

  3. 准备写java学习笔记

    准备写java学习笔记 java int 转载于:https://blog.51cto.com/cryingcloud/1975267

  4. Java学习笔记--StringTokenizer的使用

    2019独角兽企业重金招聘Python工程师标准>>> Java Tips: 使用Pattern.split替代String.split String.split方法很常用,用于切割 ...

  5. java学习笔记12--异常处理

    java学习笔记系列: java学习笔记11--集合总结 java学习笔记10--泛型总结 java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 j ...

  6. Java学习笔记（十）--控制台输入输出

    输入输出 一.控制台输入 在程序运行中要获取用户的输入数据来控制程序,我们要使用到 java.util 包中的 Scanner 类.当然 Java 中还可以使用其他的输入方式,但这里主要讲解 Scan ...

  7. java学习笔记16--I/O流和文件

    本文地址:http://www.cnblogs.com/archimedes/p/java-study-note16.html,转载请注明源地址. IO(Input  Output)流 IO流用来处理 ...

  8. java学习笔记15--多线程编程基础2

    本文地址:http://www.cnblogs.com/archimedes/p/java-study-note15.html,转载请注明源地址. 线程的生命周期 1.线程的生命周期 线程从产生到消亡 ...

  9. java学习笔记14--多线程编程基础1

    本文地址:http://www.cnblogs.com/archimedes/p/java-study-note14.html,转载请注明源地址. 多线程编程基础 多进程 一个独立程序的每一次运行称为 ...

  10. java学习笔记11--集合总结

    java学习笔记系列: java学习笔记10--泛型总结 java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承.Ob ...

最新文章

  1. CSS样式中伪类和伪类元素的区别（css中一个冒号和两个冒号的区别）
  2. Linux 上的高可用中间件
  3. 硬RAID可以为NVMe SSD数据可靠性保驾护航吗?
  4. vba执行linux命令,从VBA中的shell命令捕获输出值？
  5. 5gnr帧结构特点有哪些_真空离子束刻蚀设备的结构特点有哪些
  6. 前端学习（2786）：完成推荐商品结构之头部标签栏
  7. jeecg自定义结果集t:dictSelect
  8. 【Elasticsearch】Elasticsearch查询参数batched_reduce_size的解释
  9. 鸿蒙一号指纹锁,【诉说实情】火车头战狼一号家用防盗门指纹锁怎么样?新手必看内情...
  10. JavaScript模块化开发（一）基础知识
  11. 《Node.js实战（双色）》作者之一——吴中骅访谈录
  12. UEFI 文件类型 .efi (二)
  13. ubuntu linux qq闪退
  14. 移动支付走入线下商家
  15. ASP.NET MVC 实现 IOC基础上添加AOP实现时候遇到的坑
  16. 第二届全球区块链峰会随记
  17. python手游自动化测试流程_基于Python+appium的ios自动化测试demo（更新中）
  18. 手写实现一个HashMap
  19. const char*, char const*, char*const的区别
  20. hdfs - balancer学习

热门文章

  1. Camtasia Studio CamStudio如何导出为手机视频
  2. 自创小说《彩虹雨》连载（三）
  3. 软件项目管理 第12讲 软件项目跟踪
  4. 【四 zedboard】 VGA显示彩条
  5. 【概率论与数理统计02】那些年，正态分布、指数分布、伽马分布、卡方分布之间的发生的那些事儿（下）
  6. YouTube如何生成双语字幕？
  7. jQuery框架开发一个最简单的幻灯效果
  8. 初识EMC元器件（二）——TVS管选型及应用
  9. 优秀开源产品推荐：Tpflow工作流引擎
  10. linux下cc命令,Linux cc 命令 command not found cc 命令详解 cc 命令未找到 cc 命令安装 - CommandNotFound ⚡️ 坑否...