技术贴

===========================================================

JAVA的内存需要划分成为5个部分：

1.栈（Stack）：存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。

       局部变量：方法的参数，或者是方法{}内部的变量。

       作用域：一旦超过作用域，立刻从栈内存当中消失。

2.堆（Heap）；凡是new出来的东西，都在堆当中。

       堆内存里面的东西都有一个地址值：16进制

       堆内存里面的数据都有默认值。规则如下：

       整数       0

       浮点数   0.0

       字符       ’\u0000‘

       布尔       false

       引用类型       null

3.方法区（Method Area）:存储.class相关信息，包含方法的信息。

4.本地方法栈（NativeMethod Stack）:与操作系统相关。

5.寄存器（PC Register）:与CPU相关。

===========================================================

方法定义格式：

public static void 方法名称（）{

    方法体

}

调用格式：

方法名称（）;

注意事项：

1.方法定义的先后顺序无所谓。

2.方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法。

3.方法定义之后，自己不会执行，如果希望执行，一定要进行方法的调用。

定义方法的完整格式：

修饰符 返回值类型 方法名称（参数类型 参数名称......）{

    方法体

   return 返回值；

}

修饰符：现阶段的固定写法，public static

返回值类型：也就是方法最终产生的数据结果是什么类型。

方法名称：方法的名字，规则和变量一样，小驼峰

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

ps：参数如果有多个，使用逗号进行分隔

方法体：方法需要做的事情，若干行代码

return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处。

返回值：也就是方法执行后最终产生的数据结果。

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”保持一致。

定义一个两个int数字相加的方法，三要素：

返回值类型：int

方法名称：sum

参数列表：int a,int b

方法的三种调用格式：

1.单独调用：方法名称（参数）;

2.打印调用：System.out.println(方法名称（参数）);

3.赋值调用：数据类型 变量名称=方法名称（参数）;

注意：此前学习的方法，返回值固定类型写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。

对于有返回值的方法，可以使用单独调用、打印调用、或者赋值调用。

对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

有参数：小括号当中有内容，当一个方法需要一些数据条件才能完成任务的时候，就是有参数。

例如：两个数字相加，必须知道两个数字是多少。

无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务。

例如：定义一个方法，

方法的注意事项：

1.方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。

2.方法定义的前后顺序无所谓。

3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。

4.如果方法有返回值，那么必须写上“return返回值；”，不能没有。

5.return后面的返回值数据，必须和方法的返回值类型对应起来。

6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。

7.对于void方法当中最后一行的return可以省略不写。

8.一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到。两个不能连写。

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）:多个方法的名称一样，但是参数列表不一样。

好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：

1.参数个数不同

2.参数类型不同

3.参数的多类型顺序不同

方法重载与下列因素无关

1.与参数的名称无关

2.与方法的返回值类型无关

===========================================================

数组的概念：数组是一种容器，可以同时存放多个数据值。

数组的特点：

1.数组是一种引用数据类型。

2.数组当中的多个数据，类型必须统一。

3.数组的长度在程序运行期间不可改变。

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

1.动态初始化（指定长度）

2.静态初始化（指定内容）

动态初始化数组的格式：

数据类型[] 数组名称 = new 数据类型[数组长度];

解析：

左侧数据类型：就是数组当中保存的数据，全部都是统一的类型

左侧的中括号：代表一个数组

左侧数组名称：给数组取一个名字

右侧的new：代表创建数组的动作

右侧数据类型：必须和左侧的数据类型保持一致

右侧中括号的长度：就是数组当中到底可以保存多少个数据，是一个int数字

动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。

静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

静态初始化基本格式：

数据类型[] 数组名称 = new 数据类型[] { 元素1，元素2.....};

注意事项：

虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

使用静态初始化数组的时候，格式还可以省略一下。

标准格式：

数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，......};

省略格式：

数据类型[] 数组名称 = {元素1，元素2，......};

注意事项：

1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

2.静态初始化标准格式可以拆分成为两个步骤。

3.动态初始化也可以拆分成为两个步骤。

4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议：

如果不确定数组当中的具体内容，用动态初始化；否则已经确定了具体的内容，用静态初始化。

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

如果是整数类型，那么默认值为0；

如果是浮点类型，那么默认值为0.0；

如果是字符类型，那么默认值为‘\u0000’;

如果是布尔类型，那么默认值为false;

如果是引用类型，那么默认值为null。

注意事项：

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

package cn.itcast.day05.demo03;

/*

数组元素的反转：

本来的样子：[1,2,3,4,5,]

之后的样子：[5,4,3,2,1]

要求不能使用新数组，就用原来唯一的一个数组

*/

public class Demo07ArrayReverse {

   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);

       }

       System.out.println("===========");

       /*

       初始化语句：int min=0, max=array.length-1,

       条件判断：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);

       }

    }

}

/*

数组可以作为方法的参数。

当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

*/

/*

一个方法可以有0、1、2、3......多个参数，但是只能有0或者1个返回值，不能有多个返回值。

如果希望一个方法当中产生多个结果数据进行返回，怎么办？

解决方案：使用一个数组作为返回值类型即可。

任何数据类型都能作为方法的参数类型或者返回值类型。

数组作为方法的参数，传递进去的其实是数组的地址哈希值。

数组作为方法的返回值，返回的其实也是数组的地址哈希值.

*/

===========================================================

/*

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

面向对象：当需要实现一个功能的时候，不关心具体步骤，而是找一个已经具有该功能的人，来帮助。

三大基本特征：封装、继承、多态。

*/

/*

成员变量（属性）：String name;//姓名

                   int age;//年龄

成员方法（行为）：public void eat(){}//吃饭

                  public void sleep(){}//睡觉

                  public void study(){}//学习

注意事项：

1.成员变量是直接定义在类当中的，在方法外边。

2.成员方法不要写static关键字。

*/

/*

通常情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用。

1.导包：就是指出需要使用的类在什么位置。

import 包名称.类名称;

import cn.itcast.day06.Demo01.Student;

对于和当前类属于同一个包的情况，可以省略导包语句不写。

2.创建。格式：

类名称 对象名 = new 类名称（）;

Student stu = new Student();

3.使用。分为两种情况：

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）

注意事项：

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

*/

/*

局部变量和成员变量

1.定义的位置不一样【重点】

局部变量：在方法的内部。

成员变量：在方法的外部，直接写在类当中。

2.作用范围不一样【重点】

局部变量：只有方法当中才可以使用，出了方法就不能再用.

成员变量：整个类全都可以通用。

3.默认值不一样【重点】

局部变量：没有默认值，如果想要，必须手动进行赋值。

成员变量：如果没有赋值，会有默认值，规则和数组一样。

4.内存的位置不一样（了解）

局部变量：位于栈内存。

成员变量：位于堆内存。

5.生命周期不一样（了解）

局部变量：随着方法进栈而诞生，随着方法出栈而消失。

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。

*/

/*

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。

解决方案：用private关键字将需要保护的成员变量进行修饰。

一旦使用了private进行修饰，那么本类当中仍然可以随意访问。

但是超出了本类范围之外就不能再直接访问了。

间接访问private成员变量，就是定义一对Getter/Setter方法

命名规则：setXxx或者getXxx

对于Getter来说，不能有参数，返回值类型和成员变量对应。

对于Setter来说，不能有返回值，参数类型和成员变量对应。

*/

/*

面向对象三大特征：封装、继承、多态

封装性在Java当中的体现：

1.方法就是一种封装。

2.关键字private也是一种封装。

封装就是将一些细节信息隐藏起来，对于外界不可见。

*/

/*

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。

如果需要访问本类当中的成员变量，需要使用格式：

this.成员变量名

“通过谁调用的方法，谁就是this”

*/

/*

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

格式：

Public 类名称（参数类型 参数名称）{

    方法体

}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样。

2.构造方法不要写返回值类型，连void都不写。

3.构造方法不能return一个具体的返回值。

4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。

public Student(){}

5.一旦编写了至少一个构造方法，那么编译器将不再赠送。

6.构造方法也是可以进行重载的。

重载：在同一个类中,方法名称相同，参数列表不同。

*/

/*

一个标准的类通常要拥有下面四个组成部分：

1.所有的成员变量都要使用private关键字修饰。

2.为每一个成员变量编写一队Getter/Setter方法。

3.编写一个无参数的构造方法。

4.编写一个全参数的构造方法。

这样标准的类也叫做Java Bean

*/

===========================================================

技术贴

===========================================================

JAVA的内存需要划分成为5个部分：

1.栈（Stack）：存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。

       局部变量：方法的参数，或者是方法{}内部的变量。

       作用域：一旦超过作用域，立刻从栈内存当中消失。

2.堆（Heap）；凡是new出来的东西，都在堆当中。

       堆内存里面的东西都有一个地址值：16进制

       堆内存里面的数据都有默认值。规则如下：

       整数       0

       浮点数   0.0

       字符       ’\u0000‘

       布尔       false

       引用类型       null

3.方法区（Method Area）:存储.class相关信息，包含方法的信息。

4.本地方法栈（NativeMethod Stack）:与操作系统相关。

5.寄存器（PC Register）:与CPU相关。

===========================================================

方法定义格式：

public static void 方法名称（）{

    方法体

}

调用格式：

方法名称（）;

注意事项：

1.方法定义的先后顺序无所谓。

2.方法定义必须是挨着的，不能在一个方法的内部定义另外一个方法。

3.方法定义之后，自己不会执行，如果希望执行，一定要进行方法的调用。

定义方法的完整格式：

修饰符 返回值类型 方法名称（参数类型 参数名称......）{

    方法体

   return 返回值；

}

修饰符：现阶段的固定写法，public static

返回值类型：也就是方法最终产生的数据结果是什么类型。

方法名称：方法的名字，规则和变量一样，小驼峰

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

ps：参数如果有多个，使用逗号进行分隔

方法体：方法需要做的事情，若干行代码

return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处。

返回值：也就是方法执行后最终产生的数据结果。

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”保持一致。

定义一个两个int数字相加的方法，三要素：

返回值类型：int

方法名称：sum

参数列表：int a,int b

方法的三种调用格式：

1.单独调用：方法名称（参数）;

2.打印调用：System.out.println(方法名称（参数）);

3.赋值调用：数据类型 变量名称=方法名称（参数）;

注意：此前学习的方法，返回值固定类型写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。

对于有返回值的方法，可以使用单独调用、打印调用、或者赋值调用。

对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

有参数：小括号当中有内容，当一个方法需要一些数据条件才能完成任务的时候，就是有参数。

例如：两个数字相加，必须知道两个数字是多少。

无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务。

例如：定义一个方法，

方法的注意事项：

1.方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。

2.方法定义的前后顺序无所谓。

3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。

4.如果方法有返回值，那么必须写上“return返回值；”，不能没有。

5.return后面的返回值数据，必须和方法的返回值类型对应起来。

6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。

7.对于void方法当中最后一行的return可以省略不写。

8.一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到。两个不能连写。

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）:多个方法的名称一样，但是参数列表不一样。

好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：

1.参数个数不同

2.参数类型不同

3.参数的多类型顺序不同

方法重载与下列因素无关

1.与参数的名称无关

2.与方法的返回值类型无关

===========================================================

数组的概念：数组是一种容器，可以同时存放多个数据值。

数组的特点：

1.数组是一种引用数据类型。

2.数组当中的多个数据，类型必须统一。

3.数组的长度在程序运行期间不可改变。

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

1.动态初始化（指定长度）

2.静态初始化（指定内容）

动态初始化数组的格式：

数据类型[] 数组名称 = new 数据类型[数组长度];

解析：

左侧数据类型：就是数组当中保存的数据，全部都是统一的类型

左侧的中括号：代表一个数组

左侧数组名称：给数组取一个名字

右侧的new：代表创建数组的动作

右侧数据类型：必须和左侧的数据类型保持一致

右侧中括号的长度：就是数组当中到底可以保存多少个数据，是一个int数字

动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。

静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

静态初始化基本格式：

数据类型[] 数组名称 = new 数据类型[] { 元素1，元素2.....};

注意事项：

虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

使用静态初始化数组的时候，格式还可以省略一下。

标准格式：

数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，......};

省略格式：

数据类型[] 数组名称 = {元素1，元素2，......};

注意事项：

1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

2.静态初始化标准格式可以拆分成为两个步骤。

3.动态初始化也可以拆分成为两个步骤。

4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议：

如果不确定数组当中的具体内容，用动态初始化；否则已经确定了具体的内容，用静态初始化。

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

如果是整数类型，那么默认值为0；

如果是浮点类型，那么默认值为0.0；

如果是字符类型，那么默认值为‘\u0000’;

如果是布尔类型，那么默认值为false;

如果是引用类型，那么默认值为null。

注意事项：

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

package cn.itcast.day05.demo03;

/*

数组元素的反转：

本来的样子：[1,2,3,4,5,]

之后的样子：[5,4,3,2,1]

要求不能使用新数组，就用原来唯一的一个数组

*/

public class Demo07ArrayReverse {

   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);

       }

       System.out.println("===========");

       /*

       初始化语句：int min=0, max=array.length-1,

       条件判断：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);

       }

    }

}

/*

数组可以作为方法的参数。

当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

*/

/*

一个方法可以有0、1、2、3......多个参数，但是只能有0或者1个返回值，不能有多个返回值。

如果希望一个方法当中产生多个结果数据进行返回，怎么办？

解决方案：使用一个数组作为返回值类型即可。

任何数据类型都能作为方法的参数类型或者返回值类型。

数组作为方法的参数，传递进去的其实是数组的地址哈希值。

数组作为方法的返回值，返回的其实也是数组的地址哈希值.

*/

===========================================================

/*

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

面向对象：当需要实现一个功能的时候，不关心具体步骤，而是找一个已经具有该功能的人，来帮助。

三大基本特征：封装、继承、多态。

*/

/*

成员变量（属性）：String name;//姓名

                   int age;//年龄

成员方法（行为）：public void eat(){}//吃饭

                  public void sleep(){}//睡觉

                  public void study(){}//学习

注意事项：

1.成员变量是直接定义在类当中的，在方法外边。

2.成员方法不要写static关键字。

*/

/*

通常情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用。

1.导包：就是指出需要使用的类在什么位置。

import 包名称.类名称;

import cn.itcast.day06.Demo01.Student;

对于和当前类属于同一个包的情况，可以省略导包语句不写。

2.创建。格式：

类名称 对象名 = new 类名称（）;

Student stu = new Student();

3.使用。分为两种情况：

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）

注意事项：

如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

*/

/*

局部变量和成员变量

1.定义的位置不一样【重点】

局部变量：在方法的内部。

成员变量：在方法的外部，直接写在类当中。

2.作用范围不一样【重点】

局部变量：只有方法当中才可以使用，出了方法就不能再用.

成员变量：整个类全都可以通用。

3.默认值不一样【重点】

局部变量：没有默认值，如果想要，必须手动进行赋值。

成员变量：如果没有赋值，会有默认值，规则和数组一样。

4.内存的位置不一样（了解）

局部变量：位于栈内存。

成员变量：位于堆内存。

5.生命周期不一样（了解）

局部变量：随着方法进栈而诞生，随着方法出栈而消失。

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。

*/

/*

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。

解决方案：用private关键字将需要保护的成员变量进行修饰。

一旦使用了private进行修饰，那么本类当中仍然可以随意访问。

但是超出了本类范围之外就不能再直接访问了。

间接访问private成员变量，就是定义一对Getter/Setter方法

命名规则：setXxx或者getXxx

对于Getter来说，不能有参数，返回值类型和成员变量对应。

对于Setter来说，不能有返回值，参数类型和成员变量对应。

*/

/*

面向对象三大特征：封装、继承、多态

封装性在Java当中的体现：

1.方法就是一种封装。

2.关键字private也是一种封装。

封装就是将一些细节信息隐藏起来，对于外界不可见。

*/

/*

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。

如果需要访问本类当中的成员变量，需要使用格式：

this.成员变量名

“通过谁调用的方法，谁就是this”

*/

/*

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

格式：

Public 类名称（参数类型 参数名称）{

    方法体

}

注意事项：

1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样。

2.构造方法不要写返回值类型，连void都不写。

3.构造方法不能return一个具体的返回值。

4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。

public Student(){}

5.一旦编写了至少一个构造方法，那么编译器将不再赠送。

6.构造方法也是可以进行重载的。

重载：在同一个类中,方法名称相同，参数列表不同。

*/

/*

一个标准的类通常要拥有下面四个组成部分：

1.所有的成员变量都要使用private关键字修饰。

2.为每一个成员变量编写一队Getter/Setter方法。

3.编写一个无参数的构造方法。

4.编写一个全参数的构造方法。

这样标准的类也叫做Java Bean

*/

===========================================================