javaSE（1）

一、基础语法

1、IDEA官网：www.jetbrains.com

2、安装jdk

卸载原来的环境jdk

1，主包删除

2，环境变量删除

3，删除Java_home

4，java-version查看版本

安装jdk

1，百度搜索jdk8，找到下载地址

2，同意协议

3，下载电脑对应版本

4，双击安装jdk

5，记住安装的路径

6，配置环境变量（JAVA_HOME为变量名）

7，配置path变量（1，%JAVA_HOME%\bin

%JAVA_HOME%\jre\bin

）

3、包机制

package com.baidu.www

一般公司用到域名进行创建包

导入包

import java.util.Scanner;

4、变量和常量

变量

变量定义：可以变化的量

Java是一种强类型语言 ，每个变量都必须声明其类型

Java变量是程序最基本的存储单元，其要素包括变量名，变量类型和作用域

type varName [=value] [{,varName[=varlue]}];
//数据类型  变量名=值；    可以使用逗号隔开来声明多个同类型变量。

注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
• 变量名必须是合法的标识符。
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

public class demo08{
//类变量 static
   static double salary =2500;//定义一个工资变量 
----------------------分割线-----------------------
    //属性：变量
    //实例变量：从属于对象 如果不自行初始化，这个类型的默认值
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null；
    String name;
    int age;
---------------------分割线------------------------
//mian方法
public static main(String[] args){
    //局部变量，必须声明和初始化
}；

//其他方法
    public void add(){
    
}
}

常量

• 常量：初始化后不能再改变值！不会变动的值。

• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

  final 常量名=值；
  final double PI=3.14;
  

• 常量名一般使用大写字符。

变量命名规则

• 所有变量、方法、类名：见名知意
• 类成岩变量：首字母小写和驼峰规则：monthSalary
• 局部变量：首字母小写和驼峰规则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run(),runRun()

5、DOS命令

打开cmd方式

1，开始+系统+命令提示符

2，win+r 输入cmd（推荐使用）

3，在任意文件夹下面，按住shift剑+鼠标右键，在此处打开命令行窗口

4，资源管理器的地址栏前面加上cmd路径

管理员方式运行：选择管理员方式运行

常用DOS命令

#切换盘符  盘符:
#查看当前目录下的所有文件 dir
#切换目录  cd /d 盘符:（/d跨盘符切换）
#回当前盘符  cd...
#清理屏幕 cls （clear screem）
#退出终端 exit
#查看IP ipconfig

打开应用
#计算器 calc
#画图工具 mspaint
#记事本 notepad

ping命令

#文件命令
创建文件夹 md 文件名
创建文件 cd>文件名.后缀名
删除文件 del 文件名.后缀名
删除文件夹 rd 文件名

6、关键字标识符注意事项

所有标识符都应该以字母，美元符号，或者下划线开始

首字母之后可以是字母，美元符号，下划线或数字的任何字符组合

不能使用关键字作为变量名或方法名

标识符是大小写敏感的

可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很low

7、数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才使用

弱类型语言

Java的数据类型分为两大类

基本类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I63T5yDX-1623495816662)(E:\桌面\学习笔记\java\数据类型.png)]

引用类型

整数拓展

int i=10;//十进制
int i2=010；//八进制
int i3=0x10;//十六进制0x

浮点数拓展

float;//有限 离散 舍入误差  大约  接近但不等于
double;
//最好不要使用浮点数进行比较
//bigdecimal进行比较

字符拓展

char c1='a';
char c2='中'；
//强制转换可以把字符转换为数字
//所有字符本质还是数字
//编码 Unicode 2字节 0——65536 excel 2 16 = 65536
//U0000 UFFFF

转义字符

// \t  制表位
// \n  换行

布尔值扩展

//if（）括号中判断语句实质是布尔类型

8、 数据类型转换

byte,short,char->int->long->float->double
//低-------------------------------------高
//整数优先级-----------------------------小数优先级

强制转换

int i = 128;
byte a = (byte)i;//内存溢出，精度丢失
//强制转换  （类型） 变量名 =（类型）变量名；  高-------低

自动转换

低----高

注意点：1，不能对布尔值进行转换；

2，不能把对象类型转换为不相干的类型；

3，在把高容量转换到低容量的时候，强制转换；

4，转换的时候可能存在精度问题；

9、运算符

• 算术运算符：+，-，*，/，%，++
• 赋值运算符=
• 关系运算符：>,<,>=,<=,=,=!=
• 逻辑运算符 &&，||，！
• 位运算符：&，|，^,~,>>,<<,>>>
• 条件运算符？，：
• 扩展赋值运算符：+=，-=，*=，、=

9.1、自增自减运算符

i++;//i=i+1  先赋值再加一
++i;//先加一再赋值
i--;
--i;

幂运算

math.

很多运算我们用工具去做

9.2、逻辑运算符

与 或 非

短发运算

&& 右边true左边不执行

9.3、位运算符

A = 0011 1100
B = 0000 1101
    A&B = 0000 1100//与
    A|B = 0011 1101//或
    A^B = 0011 0001//亦或（如果上下位置相同为零否则为一）
     ~B = 1111 0010//非 相反
    
    
    2*8=16
    2*2*2*2
    <<   >>   //  左移  右移
    （2<<3）
    0000 0000 0
    0000 0001 1
    0000 0010 2
    0000 0011 3
    0000 0100 4
    0000 1000 8
    0001 0000 16

9.4、扩展赋值运算符

a+=b; //a= a+b
a-=b; //a=a-b

9.5、字符串连接符

+，String

int a=10;
int b=20;
//有区别
System.out.println(""+a+b);//1020

System.out.println(a+b+"");//30

9.6、三元运算符

// x ? y : z
//如果x==true，则结果为y，否则结果为z

优先级（）

10、注释

#单行注释 //
#多行注释 /* */
#文档注释 /**   */  //文档注释中*号后有功能

文档doc

/**
*@author kuangshen
*parram name
*return
*throws Exception
*/
public class Doc{
    String name;
public String test(String name) throws Exception{
    return name;
}
}

生成dos文档
   javadoc -encoding UTF-8 -charset UTF-8//修改编码集(encoding)  修改字符集(charset)
    //通过命令行 Javadoc 参数  Java文件

作业

学会查找使用IDEA生产Javadoc文档！

二、控制语句

1.、顺序结构

• JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
• 顺序结构是最简单的算法结构。
• 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

2、选择结构

• if单选择结构
• if双选择结构
• if多选择结构
• 嵌套的if结构
• switch多选择结构

if选择结构

if单选择结构

语法

if(布尔表达式){
    //如果布尔表达式为true将执行语句
}

if双选择结构

语法

if(布尔表达式){
    
}else{
    
}

if多选择结构

语法

if(布尔表达式){
    
}else if{
    
}else{
    
}

if嵌套结构

语法

if(布尔表达式 1){
    //如果表达式1的值为true则执行代码
    if(布尔表达式2){
        //如果表达式2的值为true则执行代码
    }
}

switch多选择结构

• 多选择结构还有一个实现方式就是switch case 语句
• switch case 语句判断一个变量与一系列中某给值是否相等，每个值称为一个分支。

switch语句中的变量类型可以是：*

• byte，short，int或者char
• 从Java SE7 开始
• switch 支持字符串String类型了
• 同时case标签必须为字符串常量或字面量。

语法

switch(expression变量名){
    case value:
        //语句
        break;
    case value:
        //语句
        break;
    //可以输入任意数量的case语句
    default://可选
        //语句
}

3、循环结构

• while 语句
• do …while 循环
• for 循环
• 在Java5引入了一种主要用于数组的增强型for循环

while语句

while是最基本的循环，它的结构为：

while(布尔表达式){
    //循环内容
}

• 只要布尔表达式为true，循环就会一直执行下去。
• 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
• 少部分情况一直为true就会造成无线循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死崩溃！
• 思考：计算1+2+3+…+100=?

do…while循环

• 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do{
    //代码语句
}while(布尔表达式)；

while和do-while的区别：

• while先判断后执行。do while是先执行后判断！
• Do…while总是保证循环体会被至少执行一次！这是他们的主要差别。

for循环

• 虽然所有循环结构都可以用while或者do…while表示，但java提供了另一种语句——for循环，使一些循环结构变得更加简单。
• for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。
• for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化；布尔表达式；更新){
    //代码语句
}

• 练习1：计算0到100之间的奇数和偶数的和
• 练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
• 练习3：打印九九乘法表

增强for循环

• Java5引入了一种主要用于数组或集合的增强型for循环
• Java增强for循环语法格式如下：

for(声明语句 ：表达式)
{
    //代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

4、break continue

• break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在switch语句中使用）

• continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

  关于goto关键字

• goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有goto，然而，在break和continue这两个关键字的身上，我们任然能看出一些goto的影子…带标签的break和continue

• “标签”是指后面跟一个冒号的标识符，例如：label:

• 对Java来说唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

质数是指在大于1的自然数中，除了1和他本身以外不再有其他因数的自然数

5、交互Scanner

5.1、基本语法

Scanner 变量名 = new Scanner(System.in);

• 要导Scanner包

• 创建Scanner

new Scanner(System.in);

5.2、注意点

• 通过Scanner类的next()与nextline()方法获取输入的字符串，在读取前我们一般需要 使用hasNext()与hasNextLine()判断是否还有输入的数据

//判断用户有没有输入字符串
if (Scanner.hasNext()){
    //使用next方式接受
    String str = scanner.next();
    System.out.println("输出的内容："+str);
}
//凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
Scanner.close();
--------------------------------------------------
if(Scanner.hasNextLine()){
    String str = scanner.NextLine();
    System.out.println("输出的内容："+str);
}
Scanner.close();

• next():

1,一定要读取到有效字符后才可以结束输入。

2，对输入有效字符之前遇到的空白，next()方法会自动将其去掉。

3，只有输入有效字符后才将其后面输入的空白作为分割线或者结束符。

4，next()不能得到带有空格的字符串。

• nextline():

1,以enter为结束符，也就是说nextline()方法返回的是输入回车之前的所有字符。

2，可以获得空白。

• nextint():

if(scanner.hasNextint()){
    i=scanner.nextint();
}

• nextdouble():

查看源码：按住ctrl 鼠标点击类

5.3、实际运用

//通过循环判断是否还有输入，并在里面对每一次进行求和和统计
while (scanner.hasNextDouble()){
    double x = scanner.nextdouble();
    
    m++;
    sum=sum+x;
}

scanner.close();

三、方法

1、方法的定义

• Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：*

• 方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

  **修饰符：**修饰符，这是可选的，告诉编译器如何调用该方法，定义了该方法的访问类型。

  **返回值类型：**方法可能会返回值。returnValueType是方法返回值。在这种情况下，returnValueType是关键字void。

  **方法名：**是方法的实际名称，方法名和参数表共同构成方法签名。

  **参数类型：**参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

  ? 形式参数：在方法被调用时用于接受外界输入的数据。

  实参：调用方法时实际传给方法的数据。

  方法体：方法体包含具体的语句，定义该方法的功能。

return可以终止方法

1.1、方法调用

调用方法：对象名.方法名(实参列表)

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值，例如：

int larger = max(30,40);

如果方法返回值是void，方法调用一定是一条语句。

System.out.println("hello,kuangshen!");

课后拓展了解：（Java）值传递和引用传递

2、何谓方法

System.out.println(),那么它是什么呢？

System:系统的类 out：System下的标准输出对象 println():方法 void：没有返回值 return：返回值

Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合

方法包含于类或对象中

方法在程序中被创建，在其他地方被引用

设计方法的原则：

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

回顾：方法的命名规则？

驼峰规则

调用方法

方法名();

加static 为类变量

3、方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载的规则：

方法名称必须相同。

参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。

方法的返回类型可以相同也可以不相同。

仅仅返回类型不同不足以成为方法的重载。

实现理论：

方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

4、递归(能不用就不用，基数较小)

A方法调用B方法，我们很容易理解！

**递归就是：**A方法调用A方法！就是自己调用自己

利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来解决，递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。

递归体：什么时候需要调用自身方法。

//阶乘    2!    2*1       3!   3*2*1     5!    5*4*3*2*1
//递归思想
public static void main(String[] args){
    System.out.println(f(n:4));
}

public static int f(int n){
    if(n==1){
        return 1;
    }else{
        return n*f(n:n-1);
    }
}

5、可变参数

JDK1.5开始，java支持传递同类型的可变参数给一个方法。

在方法声明中，在指定参数类型后加一个省略号（…）。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void printMax(double...numbers){
    if(numbers.length == 0){
        System.out.println("NO argument passed");
        teturn;
    }
    double result = numbers[0];
    //排序
    
    for(int i=1;i<numbers.lenth;i++){
        if(numbers[i]>result){
            result = numbers[i];
        }
    }
    System.out.println("The max value is"+result);
}

public class Demo04{
    public static void main(String[] args){
        Demo04 demo04 = new Demo04();
        Demo04.test(x:1,...i:2,3,4,5)
    }
public void test(int x,int...i){
    
}
}

6、命令行传参

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main（）函数实现

piblic class Demo03{
    public static void main(String[] args){
        //args.length 数组长度
       for(int i =0;i<args.length;i++){
           System.out.println("args["+i+"]:"+args[i])
       }
    }
}

../  返回上一级

四、数组

1、数组的概念[]

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据，按照一定的先后次序排序组合而成。

其中，每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问它们。（数组下标从0开始）

2、数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型，不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

int [] aggs = new int[2];   基本类型
man []  mans ={new Man(1,1),new Man(2,3)};  引用类型

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的。

数组边界

下标的合法区间：[0,length-1],如果越界就会报错；

public static void main(String[] args){
    int[] a=new int[2];
    System.out.println(a[2]);
}

ArrayindexOutOfBoundsException:数组下标越界异常！

小结：

数组是相同数据类型(数据类型可以为任意类型)的有序集合

数组也是对象。数组元素相当于对象的成员变量

数组长度的确定的，不可变的。如果越界，则报：arraylndexoutobounds

public static void main(String[] args){
    //静态初始化：创建+赋值
    int[] a = {1,2,3,4,5,6,7,8};
    System.out.println(a[0]);
    
    
    for(int i = 0;i<a.length;i++){
        System.out.println(a[i]);
    }
}

3、数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语句：

dataType(数据类型)[] arrayRefVar;   //首选的方法
或
dataType  arrayRefVar[]; //效果相同，但不是首选方法

Java语言new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始。

获取数组长度：

arrays.length

	//变量的类型  变量的名字  =  变量的值；
	//数组类型
public static void main(String[] args){
    int[] nums; //1.定义声明一个数组
    nums = new int[10];//2.这里面可以存放10个int类型的数字
    
    //3.给数组元素中赋值
    num[0]=1;
    num[1]=2;
    
}


//计算所有元素的和
	int sum = 0;
//获取数组长度： arrays.length

for (int i=0;i<nums.length;i++){
    sum=sum + nums[i];
}
System.out.println("总和为："+sum)；

4、数组使用

For-Each循环

普通for循环

public static void main(String[] args){
    int[] arrays = {1,2,3,4,5};
    
    //打印全部的数组元素
    for(i=0;i<arrays.length;i++){
        System.out.println(arrays[i]);
    }
}


	//计算所有元素的和
	int sum = 0;
	for (int i = 0;i<arrays.length;i++){
        sum+=arrays[i];
    }
	System.out.println("sum"+sum);
	System.out.println("===========");

	//查找最大元素
	int_max = arrays[0];

	for(int i=0;i<arrays.length;i++){
        if(arrays[i]>max){
            max=arrays[i];
        }
    }
	System.out.println("max"+max);

增强for循环

int[] arrays = {1,2,3,4,5};
	//arrays.for   省去下标  jdk1.5
	for(int array: arrays){   //int array 代表数组中每一个元素    arrays  表示数组
        System.out.println(array);
    }

数组作方法入参

//打印数组元素
public static void printArray(int[] arrays){
 for(int i =0);i< arrays.length;i++){
     System.out.print(arrays[i]+" ");
 }   
}
printarray(arrays);


//反转数组
	public static int[] reserve(int[] arrays){
        int[] result = new int[arrays.length];//保证返回值和原数组值相同
        //反转的操作
        for (int i = 0,j=result.length-1;i<arrays.length;i++,j--){
            //result[] = arrays[i];
            result[j] = arrays[i];
        }       
        
        
        return result;
        
    }

数组作返回值

5、Arrays类

数组的工具类java.util.Arrays

由于数组对象本身并没有什么方法可以供我们调用，但API提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：“是不用”而不是“不能”）

具有一下常用功能;

给数组赋值：通过fill方法。

对数组排序：通过sort方法，按升序。

比较数组：通过equals方法比较数组中元素值是否相等。

查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

6、多维数组(数组嵌套)

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组

int a[][] = new int[2][5];

解析：以上二维数组a可以看成一个两行五列的数组。

思考：多维数组的使用？

num[1][0]

int[][] array = {{1,2},{2,3},{3,4},{4,5}}
//[4][2]
/*1,2
2,3
3,4
4,5
*/


System.out.println(array[0]);
//1,2
System.out.println(array[2][0]);
//3

7、稀疏数组介绍

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存数组。

稀疏数组的处理方式是：

记录数组一共有几行几列，有多少个不同值

把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

如下图：左边是原始数组，右边是稀疏数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DHL3K4Jq-1623495816664)(E:\桌面\学习笔记\java狂神\java\稀疏数组.png)]

8、冒泡排序

冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！

冒泡的代码还是相当简单的，***两层循环，外层冒泡轮数，里层依次比较，***江湖中人人尽皆知。

我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0（n2）。

思考：如何优化？

//冒泡排序
//1,比较数组中，两个相邻的元素，如果是一个数比第二个数大，我们就交换他们的位置；
//2,每一次比较，都会产生出一个最大，或者最小的数字；
//3,下一轮可以少一次排序；
//4，依次循环，直到结束！
	public static void sort(int[] array){
        //外层循环，判断我们这个要走多少次；
        for(int i = 0;i< array.length-1;i++){
            
            boolean flag = false;//通过flog标识符减少没有意义的比较
            
            //内层循环，比较判断两个数，如果一个数，比第二给数大，则交换位置（要有个中间变量）
            for(int j = 0;j<array.length-1-i;j++){
                if(array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return array;
    }

9、内存分析

Java内存分析：

堆

存放new的对象和数组

可以被所有的线程共享，不会存放别的对象引用

栈

存放基本变量类型（会包含这个基本类型的具体数值）

引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

可以被所有的线程共享

包含了所有的class和static变量

写代码画图分析内存!

数组三种初始化

静态初始化

int[] a = (1,2,3); //静态初始化：创建+赋值
Man[] mans = {new Man(1,1),new Man(2,3)};

动态初始化

int[] a = new int[2];  //动态初始化：包含默认初始化
a[0]=1;
a[1]=2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

五、面向对象oop

六、原创声明

未经作者允许，禁止转载。有问题请联系作者QQ邮箱1273623403@qq.com

or(int i = 0;i< array.length-1;i++){

        boolean flag = false;//通过flog标识符减少没有意义的比较
        
        //内层循环，比较判断两个数，如果一个数，比第二给数大，则交换位置（要有个中间变量）
        for(int j = 0;j<array.length-1-i;j++){
            if(array[j+1]>array[j]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if (flag==false){
            break;
        }
    }
    return array;
}

## 9、内存分析

**Java内存分析：**

### 堆

存放new的对象和数组

可以被所有的线程共享，不会存放别的对象引用

### 栈

存放基本变量类型（会包含这个基本类型的具体数值）

引用对象的变量（会存放这个引用在堆里面的具体地址）

### 方法区

可以被所有的线程共享

包含了所有的class和static变量

### 写代码画图分析内存!



### 数组三种初始化

**静态初始化**

```java
int[] a = (1,2,3); //静态初始化：创建+赋值
Man[] mans = {new Man(1,1),new Man(2,3)};

动态初始化

int[] a = new int[2];  //动态初始化：包含默认初始化
a[0]=1;
a[1]=2;

数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

五、面向对象oop

六、原创声明

未经作者允许，禁止转载。