类或者接口

首字母都大写

方法和变量

第一个小写，其余首字母全大写

class DiaoYong{

        public static void main(String[] agrs){

                int diaoYong = beiDiaoYong(10,20)

                System.out.println(diaoYong);

        }

        public static int beiDiaoYong(int a,int b){

                int sum = a + b;

                return sum;

        }

}

重载：方法名相同，参数列表不同，与返回值类型无关。

        ↑           ↑                          ↑

        ↑           ↑                只是方法体运算后的结果

        ↑           ↑                谁知道方法体里面变成了什么类型

        ↑           ↑

        ↑          不同才是匹配的标准

        因为都一样，根据参数列表进行判断选用哪个方法

说白了就是方法名取的一样，根据不同的参数类型进行判断，找到契合的参数类型，便选用该方法进行计算。在判断不同参数类型的时候，顺序不同也会进行不同选取，比如调用的时候，赋值一个调用为int,double,一个调用为double，int,方法一个为int,double,一个为double，int,那么顺序不同会进行不同匹配。但是实际上并不这么用，因为单纯的是一个int类型，一个double类型，只是改变顺序造成需要多打一个方法，会造成代码浪费。

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

静态初始化的格式：

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

        简化格式：数据类型 [] 数组名 = {元素1，元素2，....}；

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

数据类型 数组名 = 方法名();

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

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

测试类里方法全加 static（就是第一个类），就是跟主函数在一起的都加上静态，不然不加

匿名对象可以调用属性，但是没有意义，因为调用后就变成了垃圾，如果需要赋值，还是要用非匿名对象。

第二天

打印的时候\r\n  就是换行

int类型范围内的常量相运算的时候，不用考虑类型转换，直接赋值，比int类型小的变量在进行计算的时候，会自动提升为int类型再进行计算。

eclipse 是个比较高级的IDE(集成开发环境)

src文件夹下放的是.java文件

bin目录下放的是.class文件

eclipse的使用：

        打开的时候 需要选择工作空间（代码存放的地方）

        需要先建项目  eclipse以项目为基础

        项目下面接着建包（文件夹） 后续java文件很多，方便管理

        在包下创建类（java）

快捷键

        main + alt+/

        syso+alt+/

        注释

                单行 选中内容 ctrl+/

                多行 选中内容 ctrl+shift+/，取消注释ctrl+shift+\

        格式化

                ctrl+shift+f

                右键---source---format

        导包

                ctrl+shift+o

        段落缩进

                shift+tab

        段落退格

                tab

        向下复制

                ctrl+alt+↓

导入的时候比如在e盘，工作空间在f盘，有个勾选的内容，点了勾选，这时候删除导入的这个项目的这个项目所在的硬盘上的内容，即删除的e盘的。也就是删除

导入项目及其来源硬盘的内容。

int a = 10;

int b = (a++) + (++a) + (a);

        10        12        12

在括号里当前步骤还是他，等往后一个步骤，值就变了。

可以看作顺序执行，a，取值，自加，执行加，自加，赋值.......

a++这个整体不变，但是a的值增加了1.

当++  放在变量的前面，a自己+1，++a整体+1.

当++  放在变量的后面，a自己+1，a++整体不变.

byte b = 10;

b++;                //这句在底层会进行一个强制转换如 b = (byte)(b+1);

b = b + 1;        //这句就会报错了。隐式转换成int类型的数进行相加，又赋值给byte类型的b,就会报错。

字符串左右及其之后的加号都是字符串拼接符，单纯拼出来。

        如int a=1,b=2,c=3,d=4;

        （a+b+"sdsd"+c+d）

        1+2  sdsd  3  4

        输出为3sdsd34

        遇到字符串之前+还是相加的意思，遇到字符串之后就是拼接的符号了。

字符和int值相加：

        字符变成int值再和int值相加。结果是个int值。

int a = 10;//把10赋值给int类型的变量a

拿+=的左边和右边的数据做+，然后把结果赋值给左边。

扩展的赋值运算符，蕴含了强制类型转换。

有一个变量a，a+=10；相当于a=（a的数据类型）（a+10）；

异或    也就是取反，就是说，判断两边是不是相反的，即两边是不是不同的

        是不同的，那就true，不是不同的就false。  

键盘录入

        导包

                import java.util.Scanner;

                在一个类中顺序：package>import>class

        创建键盘录入对象

                Scanner sc = new Scanner(System.in);

        接收数据

                int i = sc.nextInt();

************************************************

                               

       

                                第三天

if else     

        if 的第一种格式

        if 的第二种格式

        if 的第三种格式

循环

        for循环

        while循环

        do while循环

        死循环

        控制循环的语句 break continue

导包

        手动导入

        点击鼠标自动生成（点击bug）

        快捷键  ctrl+shift+o

Scanner sc = new Scanner(System.in);                //一次就行，多次调用

System.out.println("请输入第一个数");

int a = sc.nextInt();

System.out.println("请输入第er个数");

int b = sc.nextInt();

System.out.println("请输入第san个数");

int c = sc.nextInt();

switch(表达式){

        case 值：

                语句；

                break；

        。。。

        default：

                语句；

                break；

}

表达式：byte，short，int，char

        jdk5以后可以是枚举

        jdk7以后可以是字符串

case后面的值：就是用来和表达式的值进行匹配的内容。

break：表示中断的意思

default：所有的值都不匹配的时候，执行default语句。

执行流程：

        首先计算表达式的值

        拿着这个计算出来的值，依次和case后面的值进行比较，一旦有匹配的，就执行对应的语句体，在执行过程中遇到break就结束循环。

        switch补充

                int a = 2;

                switch (a) {

                default:

                        System.out.println(a);

                case 3:

                        System.out.println(++a);

                        break;

               

                case 4:

                        System.out.println(a++);

如上这段伪代码，进来，一个一个匹配，顺序执行，default没有要求，轮到他直接进入。

如果像上面这样没有break则不再匹配，直接进入下一条语句，直到遇到break，如果到最后都没遇见，则全部执行了一遍。最后正常退出switch语句。

也就是说，在case这里走一遍，不进入case，有匹配的，正常进入，没有匹配到，则开始找default，没有，正常退出，这里一直都是不进入里面去执行语句。

如果在找的过程中，匹配到了，进入语句之后，如果没有及时break弹出，则发生击穿现象，就是不再进行匹配，余下语句全部执行，直到遇到break或者该switch语句结束。这里匹配成功没有break阻止的话，就疯狂执行，当然，case值可能没有相应匹配，但是default就像是没有门槛的case，遇到就直接进入。

有点像流水槽，上面是孔，下面是槽，匹配到了就流下去，break就像是隔板，遇到break然后流到我们手里，如果没有，则一直往右流去……--

----[ ]--[  ]--[  ]--[  ]--[  ]---→

   ↓   ↓   ↓     ↓ .....↓

  [  ]--[  ]---[  ]----[  ]---[  ]--→

还有一种情况，一直没有case匹配，遇到括号，再从头找一遍default。

for 循环语句的格式：

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

                循环体语句；

        }

while 循环语句

        while（判断条件语句）{

                循环体语句；

        }

        扩展格式

        初始化语句；

        while（判断条件语句）{

                循环体语句；

                控制条件语句；

        }

       

for循环和while循环的区别   在于初始化变量能否在循环结束后继续使用。

continue        结束一次循环，继续下一次的循环。

if 选择结构

switch  选择结构

for  循环结构

***********************************************************

                                第四天

数组的定义：

                三个容器：

                        变量 只能存一个

                        数组是一个容器，存很多，但是固定长度

                        集合是一个容器，存很多，长度不固定。

                        int[] arr;

                        char[] arr1;

                        boolean[] arr2;

                        boolean arr3[];

        初始化：

                动态初始化：

                        int[] arr = new int[3];  // 0 0 0

                        byte[] arr1 = new byte[4];  // 0 0 0 0

                        boolean[] arr2 = new boolean[5]; // false false false false false

                        初始化：

                                整型的： 0

                                浮点型：0.0

                                布尔型：false

                                字符型：空字符 '\u0000'  

                       

                        System.out.println(arr2[2]);

                静态初始化：

                        boolean[] arr1 = {true,true,true};

                        boolean[] arr2 = new boolean[]{true,true,true};

boolean 类型的数组

boolean[] b = new boolean[3];//布尔类型的数组，里面初始化给的是                                                  false，这里长度为3，

                                即false，false，false

每个元素都是有编号的，从0开始，最大编号为数组长度-1。

通过数组名和编号的配合使用就可以获取指定编号的元素值，这个编号的专业叫法：索引

访问格式： 数组名[索引

初始化：

        整型：0

        浮点型：0.0

        布尔型：false

        字符型(char):空字符 '\u0000'

数组赋值：

        把一个数组赋值给另一个数组

        int[] arr = new int[5];

        int[] arr1 = arr;

        这时，把arr的地址给了arr1，即两个数组在堆里共用同一个数组。

        再对一个数组进行赋值改值，另一个也会发生相应变化。

float f[][]=new float[6][];

这样定义对的，定义了6个空数组。

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

int arr[] = {11,2};

这俩特么到底是啥   

答：是个数组，因为中括号不是合法的标识符

    读到左括号的时候就报错，再读到右括号，系统就判定为这不是在定义变量，是在定义数组。

二维数组.length  获取的是二维数组中有几个一维数组

二维数组[x].length  获取的是二维数组中第x-1个一维数组的长度

二维数组动态初始化定义的时候，每个一维数组的长度都是一样的

        静态初始化定义的时候，每个一维数组的长度可以随便改变。

***************************************************                       

                                第五天

方法的调用：(有明确返回值的方法定义)

        单独调用 没有意义

        sum(10,20);

        输出调用 有意义，但是不够好，因为我可能需要拿结果进行进一步的操作

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

        赋值调用 推荐方式 可以拿结果进行进一步的操作。

        int result = sum(10,20);

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

方法的参数如果是基本数据类型，形式参数的改变不影响实际参数。

实参 实际参与计算的变量

形参 用于接收实际参数的变量

内存

        栈  执行方法用的       

        堆  存储一些引用数据类型的 如数组

        方法区  存储一些class文件的

       

        本地方法区  存储一些本地方法的

        寄存器  cpu

        （下面这两个java涉及不到）

方法的形参是引用数据类型的时候, 传递的是地址,形参的改变影响实参的值

方法的形参是基本数据类型的时候, 传递的是值,形参的改变不影响实参的值

方法的格式

        修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2....){

                方法体语句；

                return 返回值；

        }

方法的格式说明

        修饰符：目前就用 public static 。其他后面讲。

        返回值类型：就是功能结果的数据类型。

        方法名：符合命名规则即可。

        参数：

            实际参数：实际参与运算的。

            形式参数：方法定义上的，用于接收实际参数。

        参数类型：就是参数的数据类型。

→      参数名：就是变量名         

        方法体语句：就是完成功能的代码。

        return：结束方法的。

        返回值：功能的结果数值，由return带给调用者。

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

        方法体语句；

        return 返回值；

}

*********************************************************

                                第六天

加断点

        代码区域左边双击

代码区域--右键--debug as --java application

断点的删除

代码区域左边加断点的动作重复一遍。

在debug试图中，找到break points，选中要删除的断点，点击双×即可。

例题

有一对兔子，从出生后第3个月起，每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

规律：

                第一个月：1

                  第二个月：1

                  第三个月：2

                  第四个月：3

                  第五个月：5

public class Tset01 {

        public static void main(String[] args) {

        /*        int a = 0;

                int y1 = 1;

                int y2 = 1;

                int x = 0;

                for (int i = 3; i <= 20; i++) {

                        a = y1+y2;

                        y1 = y2;

                        y2 = a;

                       

                }

                System.out.println(a);

        }

        */

               

        int[] arr = new int[20];

        arr[0] = 1;

        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {

                arr = arr[i-1] + arr[i-2];

        }

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

        }       

               

}

两种方式均可。

*************************************

       

                        第七天

类和对象：

        为了方便我们的日常的调用执行。

        类：一类事物

        对象：一类事物中的一个

如何表示现实世界的事物

        属性  就是事物的描述信息

        行为  就是事物能够干什么

java语言最基本的单位是类。

类：是一组相关的属性和行为的集合。

对象：就是该事物的具体体现。

        例：

                类    学生

                对象  班长

类是如何和事物进行对应的

        类：

                成员变量

                成员方法

使用一个类，其实就是使用该类的成员  (成员变量和成员方法)

而我们想使用一个类的成员，就必须首先拥有该类的对象

格式        类名 对象名 = new 类名（）；

引用类型的默认值为null

基本数据类型的默认值为0

字符串是引用数据类型

使用成员变量的时候，点表示“的”的意思。s.name  s的名字

成员变量和局部变量的区别

在类中的位置不同

成员变量 类中方法外

局部变量 方法内或者方法声明上

在内存中的位置不同

成员变量 堆内存

局部变量 栈内存

生命周期不同

成员变量 随着对象的存在而存在，随着对象的消失而消失

局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

成员变量 有默认的初始化值

局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

构造方法

        给对象的数据进行初始化

格式

        方法名和类名相同

        没有返回值类型，连void都不能写

        没有具体的返回值

通过new关键字调用

格式：类名 对象名 = new 构造方法（...）；

类：

        大概就是一类具有相同属性的个体聚在一起，然后他们都有各自的“特有属性”也可以叫做特征，java称之为成员变量。然后都有相似的行为，比如走，跑，跳这样的行为，用方法来形容。

        赋值

        对属性进行赋值，就有点像是从一群个体。。。。。拿兔子举例子。从一群兔子中抓出一只，这是new，然后。。。算了，直接拿例子来说

TuZi t1 = new TuZi();这里的t1就是抓出来的这只兔子，它有什么它特有的属性，用t1._ =  ;来说，t1就这只兔子，.后面的下划线处的单词是它的某一共有属性，赋值号右边是它的属性，比如 t1.color = "黑色的";翻译过来：“t1这只兔子的 毛色 是 黑色的”大概就是这样。

        方法（成员变量）

        还是上面那只兔子。。。。。如果color颜色被封装了，那么想去再给它黑色属性输进去，就要在类里面定义个方法，来获取输入的黑色属性，当然，这些都是在堆内存中进行的，因为在抓这只兔子的时候，在堆内存中开辟了一块空间，专门存放这只兔子，在new的时候就已经清空了所有属性值，然后再进行相应的赋值，才能让其进行活动。

        比如：private String color;要在下面写方法：

public String setColor(String color){

        this.colo = color;

}

public String getColor(){

        return color;

}

        这样是对兔子进行颜色的赋值、返回，返回到测试类里，实际上就是返回到堆里，也就是给抓出来的这只兔子颜色进行赋值。这只是实现对封装的color属性改值，还需要调用这个方法，进行赋值，取值，取值嘛，直观看到或者对其进行使用。大概这么写：

TuZi t1 = new TuZi();

t1.setColor = ("黑色的");

System.out.println(t1.getColor());

        赋值，并进行打印。

        这里方法名TuZi和类名要一致，然后没啥注意的了。

构造方法（写在类里面）

        有参构造

        无参构造

        如词面意思，一个有参数，一个没有参数，有参构造可以在创建对象的时候进行赋值，无参构造那就慢慢在之后在赋值了。

        这个创建对象指的是测试类里new一个对象的时候，比如上面“抓”出一只兔子的时候。

        注意：

        方法名与类名相同，没有返回值类型，连void都没有，没有具体的返回值。

        没有提供构造方法，系统会给出默认构造方法，如果提供了构造方法，系统将不再提供，构造方法也是可以重载的,重载条件和普通方法相同。这里主要体现在测试类里创建对象的时候，如果创建对象的时候例如Student s = new Student();这时候，没有明确给出参数，而类里面给出了有参构造，必须手动给出无参构造，所以尽量在构造方法的时候顺手给出无参构造。

        如：Student s = new Student();这是属于调用无参构造方法。

        如：public Student (){}这是构造方法的无参构造。

    给成员变量赋值，两种方法，一种为setXxx()方法，一种为有参构造

        有参构造

        Student s = new Student(17);

        public Student (int age){

                this.age = age;

        }

        利用了构造方法的重载。

       

类名作为形式参数，其实这里需要的是该类对象。

类或者接口

首字母都大写

方法和变量

第一个小写，其余首字母全大写

class DiaoYong{

        public static void main(String[] agrs){

                int diaoYong = beiDiaoYong(10,20)

                System.out.println(diaoYong);

        }

        public static int beiDiaoYong(int a,int b){

                int sum = a + b;

                return sum;

        }

}

重载：方法名相同，参数列表不同，与返回值类型无关。

        ↑           ↑                          ↑

        ↑           ↑                只是方法体运算后的结果

        ↑           ↑                谁知道方法体里面变成了什么类型

        ↑           ↑

        ↑          不同才是匹配的标准

        因为都一样，根据参数列表进行判断选用哪个方法

说白了就是方法名取的一样，根据不同的参数类型进行判断，找到契合的参数类型，便选用该方法进行计算。在判断不同参数类型的时候，顺序不同也会进行不同选取，比如调用的时候，赋值一个调用为int,double,一个调用为double，int,方法一个为int,double,一个为double，int,那么顺序不同会进行不同匹配。但是实际上并不这么用，因为单纯的是一个int类型，一个double类型，只是改变顺序造成需要多打一个方法，会造成代码浪费。

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

静态初始化的格式：

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

        简化格式：数据类型 [] 数组名 = {元素1，元素2，....}；

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

数据类型 数组名 = 方法名();

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

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

测试类里方法全加 static（就是第一个类），就是跟主函数在一起的都加上静态，不然不加

匿名对象可以调用属性，但是没有意义，因为调用后就变成了垃圾，如果需要赋值，还是要用非匿名对象。

第二天

打印的时候\r\n  就是换行

int类型范围内的常量相运算的时候，不用考虑类型转换，直接赋值，比int类型小的变量在进行计算的时候，会自动提升为int类型再进行计算。

eclipse 是个比较高级的IDE(集成开发环境)

src文件夹下放的是.java文件

bin目录下放的是.class文件

eclipse的使用：

        打开的时候 需要选择工作空间（代码存放的地方）

        需要先建项目  eclipse以项目为基础

        项目下面接着建包（文件夹） 后续java文件很多，方便管理

        在包下创建类（java）

快捷键

        main + alt+/

        syso+alt+/

        注释

                单行 选中内容 ctrl+/

                多行 选中内容 ctrl+shift+/，取消注释ctrl+shift+\

        格式化

                ctrl+shift+f

                右键---source---format

        导包

                ctrl+shift+o

        段落缩进

                shift+tab

        段落退格

                tab

        向下复制

                ctrl+alt+↓

导入的时候比如在e盘，工作空间在f盘，有个勾选的内容，点了勾选，这时候删除导入的这个项目的这个项目所在的硬盘上的内容，即删除的e盘的。也就是删除

导入项目及其来源硬盘的内容。

int a = 10;

int b = (a++) + (++a) + (a);

        10        12        12

在括号里当前步骤还是他，等往后一个步骤，值就变了。

可以看作顺序执行，a，取值，自加，执行加，自加，赋值.......

a++这个整体不变，但是a的值增加了1.

当++  放在变量的前面，a自己+1，++a整体+1.

当++  放在变量的后面，a自己+1，a++整体不变.

byte b = 10;

b++;                //这句在底层会进行一个强制转换如 b = (byte)(b+1);

b = b + 1;        //这句就会报错了。隐式转换成int类型的数进行相加，又赋值给byte类型的b,就会报错。

字符串左右及其之后的加号都是字符串拼接符，单纯拼出来。

        如int a=1,b=2,c=3,d=4;

        （a+b+"sdsd"+c+d）

        1+2  sdsd  3  4

        输出为3sdsd34

        遇到字符串之前+还是相加的意思，遇到字符串之后就是拼接的符号了。

字符和int值相加：

        字符变成int值再和int值相加。结果是个int值。

int a = 10;//把10赋值给int类型的变量a

拿+=的左边和右边的数据做+，然后把结果赋值给左边。

扩展的赋值运算符，蕴含了强制类型转换。

有一个变量a，a+=10；相当于a=（a的数据类型）（a+10）；

异或    也就是取反，就是说，判断两边是不是相反的，即两边是不是不同的

        是不同的，那就true，不是不同的就false。  

键盘录入

        导包

                import java.util.Scanner;

                在一个类中顺序：package>import>class

        创建键盘录入对象

                Scanner sc = new Scanner(System.in);

        接收数据

                int i = sc.nextInt();

************************************************

                               

       

                                第三天

if else     

        if 的第一种格式

        if 的第二种格式

        if 的第三种格式

循环

        for循环

        while循环

        do while循环

        死循环

        控制循环的语句 break continue

导包

        手动导入

        点击鼠标自动生成（点击bug）

        快捷键  ctrl+shift+o

Scanner sc = new Scanner(System.in);                //一次就行，多次调用

System.out.println("请输入第一个数");

int a = sc.nextInt();

System.out.println("请输入第er个数");

int b = sc.nextInt();

System.out.println("请输入第san个数");

int c = sc.nextInt();

switch(表达式){

        case 值：

                语句；

                break；

        。。。

        default：

                语句；

                break；

}

表达式：byte，short，int，char

        jdk5以后可以是枚举

        jdk7以后可以是字符串

case后面的值：就是用来和表达式的值进行匹配的内容。

break：表示中断的意思

default：所有的值都不匹配的时候，执行default语句。

执行流程：

        首先计算表达式的值

        拿着这个计算出来的值，依次和case后面的值进行比较，一旦有匹配的，就执行对应的语句体，在执行过程中遇到break就结束循环。

        switch补充

                int a = 2;

                switch (a) {

                default:

                        System.out.println(a);

                case 3:

                        System.out.println(++a);

                        break;

               

                case 4:

                        System.out.println(a++);

如上这段伪代码，进来，一个一个匹配，顺序执行，default没有要求，轮到他直接进入。

如果像上面这样没有break则不再匹配，直接进入下一条语句，直到遇到break，如果到最后都没遇见，则全部执行了一遍。最后正常退出switch语句。

也就是说，在case这里走一遍，不进入case，有匹配的，正常进入，没有匹配到，则开始找default，没有，正常退出，这里一直都是不进入里面去执行语句。

如果在找的过程中，匹配到了，进入语句之后，如果没有及时break弹出，则发生击穿现象，就是不再进行匹配，余下语句全部执行，直到遇到break或者该switch语句结束。这里匹配成功没有break阻止的话，就疯狂执行，当然，case值可能没有相应匹配，但是default就像是没有门槛的case，遇到就直接进入。

有点像流水槽，上面是孔，下面是槽，匹配到了就流下去，break就像是隔板，遇到break然后流到我们手里，如果没有，则一直往右流去……--

----[ ]--[  ]--[  ]--[  ]--[  ]---→

   ↓   ↓   ↓     ↓ .....↓

  [  ]--[  ]---[  ]----[  ]---[  ]--→

还有一种情况，一直没有case匹配，遇到括号，再从头找一遍default。

for 循环语句的格式：

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

                循环体语句；

        }

while 循环语句

        while（判断条件语句）{

                循环体语句；

        }

        扩展格式

        初始化语句；

        while（判断条件语句）{

                循环体语句；

                控制条件语句；

        }

       

for循环和while循环的区别   在于初始化变量能否在循环结束后继续使用。

continue        结束一次循环，继续下一次的循环。

if 选择结构

switch  选择结构

for  循环结构

***********************************************************

                                第四天

数组的定义：

                三个容器：

                        变量 只能存一个

                        数组是一个容器，存很多，但是固定长度

                        集合是一个容器，存很多，长度不固定。

                        int[] arr;

                        char[] arr1;

                        boolean[] arr2;

                        boolean arr3[];

        初始化：

                动态初始化：

                        int[] arr = new int[3];  // 0 0 0

                        byte[] arr1 = new byte[4];  // 0 0 0 0

                        boolean[] arr2 = new boolean[5]; // false false false false false

                        初始化：

                                整型的： 0

                                浮点型：0.0

                                布尔型：false

                                字符型：空字符 '\u0000'  

                       

                        System.out.println(arr2[2]);

                静态初始化：

                        boolean[] arr1 = {true,true,true};

                        boolean[] arr2 = new boolean[]{true,true,true};

boolean 类型的数组

boolean[] b = new boolean[3];//布尔类型的数组，里面初始化给的是                                                  false，这里长度为3，

                                即false，false，false

每个元素都是有编号的，从0开始，最大编号为数组长度-1。

通过数组名和编号的配合使用就可以获取指定编号的元素值，这个编号的专业叫法：索引

访问格式： 数组名[索引

初始化：

        整型：0

        浮点型：0.0

        布尔型：false

        字符型(char):空字符 '\u0000'

数组赋值：

        把一个数组赋值给另一个数组

        int[] arr = new int[5];

        int[] arr1 = arr;

        这时，把arr的地址给了arr1，即两个数组在堆里共用同一个数组。

        再对一个数组进行赋值改值，另一个也会发生相应变化。

float f[][]=new float[6][];

这样定义对的，定义了6个空数组。

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

int arr[] = {11,2};

这俩特么到底是啥   

答：是个数组，因为中括号不是合法的标识符

    读到左括号的时候就报错，再读到右括号，系统就判定为这不是在定义变量，是在定义数组。

二维数组.length  获取的是二维数组中有几个一维数组

二维数组[x].length  获取的是二维数组中第x-1个一维数组的长度

二维数组动态初始化定义的时候，每个一维数组的长度都是一样的

        静态初始化定义的时候，每个一维数组的长度可以随便改变。

***************************************************                       

                                第五天

方法的调用：(有明确返回值的方法定义)

        单独调用 没有意义

        sum(10,20);

        输出调用 有意义，但是不够好，因为我可能需要拿结果进行进一步的操作

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

        赋值调用 推荐方式 可以拿结果进行进一步的操作。

        int result = sum(10,20);

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

方法的参数如果是基本数据类型，形式参数的改变不影响实际参数。

实参 实际参与计算的变量

形参 用于接收实际参数的变量

内存

        栈  执行方法用的       

        堆  存储一些引用数据类型的 如数组

        方法区  存储一些class文件的

       

        本地方法区  存储一些本地方法的

        寄存器  cpu

        （下面这两个java涉及不到）

方法的形参是引用数据类型的时候, 传递的是地址,形参的改变影响实参的值

方法的形参是基本数据类型的时候, 传递的是值,形参的改变不影响实参的值

方法的格式

        修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2....){

                方法体语句；

                return 返回值；

        }

方法的格式说明

        修饰符：目前就用 public static 。其他后面讲。

        返回值类型：就是功能结果的数据类型。

        方法名：符合命名规则即可。

        参数：

            实际参数：实际参与运算的。

            形式参数：方法定义上的，用于接收实际参数。

        参数类型：就是参数的数据类型。

→      参数名：就是变量名         

        方法体语句：就是完成功能的代码。

        return：结束方法的。

        返回值：功能的结果数值，由return带给调用者。

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

        方法体语句；

        return 返回值；

}

*********************************************************

                                第六天

加断点

        代码区域左边双击

代码区域--右键--debug as --java application

断点的删除

代码区域左边加断点的动作重复一遍。

在debug试图中，找到break points，选中要删除的断点，点击双×即可。

例题

有一对兔子，从出生后第3个月起，每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

规律：

                第一个月：1

                  第二个月：1

                  第三个月：2

                  第四个月：3

                  第五个月：5

public class Tset01 {

        public static void main(String[] args) {

        /*        int a = 0;

                int y1 = 1;

                int y2 = 1;

                int x = 0;

                for (int i = 3; i <= 20; i++) {

                        a = y1+y2;

                        y1 = y2;

                        y2 = a;

                       

                }

                System.out.println(a);

        }

        */

               

        int[] arr = new int[20];

        arr[0] = 1;

        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {

                arr = arr[i-1] + arr[i-2];

        }

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

        }       

               

}

两种方式均可。

*************************************

       

                        第七天

类和对象：

        为了方便我们的日常的调用执行。

        类：一类事物

        对象：一类事物中的一个

如何表示现实世界的事物

        属性  就是事物的描述信息

        行为  就是事物能够干什么

java语言最基本的单位是类。

类：是一组相关的属性和行为的集合。

对象：就是该事物的具体体现。

        例：

                类    学生

                对象  班长

类是如何和事物进行对应的

        类：

                成员变量

                成员方法

使用一个类，其实就是使用该类的成员  (成员变量和成员方法)

而我们想使用一个类的成员，就必须首先拥有该类的对象

格式        类名 对象名 = new 类名（）；

引用类型的默认值为null

基本数据类型的默认值为0

字符串是引用数据类型

使用成员变量的时候，点表示“的”的意思。s.name  s的名字

成员变量和局部变量的区别

在类中的位置不同

成员变量 类中方法外

局部变量 方法内或者方法声明上

在内存中的位置不同

成员变量 堆内存

局部变量 栈内存

生命周期不同

成员变量 随着对象的存在而存在，随着对象的消失而消失

局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

成员变量 有默认的初始化值

局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

构造方法

        给对象的数据进行初始化

格式

        方法名和类名相同

        没有返回值类型，连void都不能写

        没有具体的返回值

通过new关键字调用

格式：类名 对象名 = new 构造方法（...）；

类：

        大概就是一类具有相同属性的个体聚在一起，然后他们都有各自的“特有属性”也可以叫做特征，java称之为成员变量。然后都有相似的行为，比如走，跑，跳这样的行为，用方法来形容。

        赋值

        对属性进行赋值，就有点像是从一群个体。。。。。拿兔子举例子。从一群兔子中抓出一只，这是new，然后。。。算了，直接拿例子来说

TuZi t1 = new TuZi();这里的t1就是抓出来的这只兔子，它有什么它特有的属性，用t1._ =  ;来说，t1就这只兔子，.后面的下划线处的单词是它的某一共有属性，赋值号右边是它的属性，比如 t1.color = "黑色的";翻译过来：“t1这只兔子的 毛色 是 黑色的”大概就是这样。

        方法（成员变量）

        还是上面那只兔子。。。。。如果color颜色被封装了，那么想去再给它黑色属性输进去，就要在类里面定义个方法，来获取输入的黑色属性，当然，这些都是在堆内存中进行的，因为在抓这只兔子的时候，在堆内存中开辟了一块空间，专门存放这只兔子，在new的时候就已经清空了所有属性值，然后再进行相应的赋值，才能让其进行活动。

        比如：private String color;要在下面写方法：

public String setColor(String color){

        this.colo = color;

}

public String getColor(){

        return color;

}

        这样是对兔子进行颜色的赋值、返回，返回到测试类里，实际上就是返回到堆里，也就是给抓出来的这只兔子颜色进行赋值。这只是实现对封装的color属性改值，还需要调用这个方法，进行赋值，取值，取值嘛，直观看到或者对其进行使用。大概这么写：

TuZi t1 = new TuZi();

t1.setColor = ("黑色的");

System.out.println(t1.getColor());

        赋值，并进行打印。

        这里方法名TuZi和类名要一致，然后没啥注意的了。

构造方法（写在类里面）

        有参构造

        无参构造

        如词面意思，一个有参数，一个没有参数，有参构造可以在创建对象的时候进行赋值，无参构造那就慢慢在之后在赋值了。

        这个创建对象指的是测试类里new一个对象的时候，比如上面“抓”出一只兔子的时候。

        注意：

        方法名与类名相同，没有返回值类型，连void都没有，没有具体的返回值。

        没有提供构造方法，系统会给出默认构造方法，如果提供了构造方法，系统将不再提供，构造方法也是可以重载的,重载条件和普通方法相同。这里主要体现在测试类里创建对象的时候，如果创建对象的时候例如Student s = new Student();这时候，没有明确给出参数，而类里面给出了有参构造，必须手动给出无参构造，所以尽量在构造方法的时候顺手给出无参构造。

        如：Student s = new Student();这是属于调用无参构造方法。

        如：public Student (){}这是构造方法的无参构造。

    给成员变量赋值，两种方法，一种为setXxx()方法，一种为有参构造

        有参构造

        Student s = new Student(17);

        public Student (int age){

                this.age = age;

        }

        利用了构造方法的重载。

       

类名作为形式参数，其实这里需要的是该类对象。