Day1:
Java:
使用java程序 必须要安装jdk
java为什么火：两个特性 开源  跨平台：
jdk和jre 和jvm
我们程序必须要有jvm才能运行
jre里面就有核心类库 也有jvm
jdk包含一些开发工具 也包含jre
开发人员  jdk
客户人员 jre

下如何打开DOS控制台？
a:开始--程序--附件--命令提示符
b:开始--运行--cmd--回车
c:win+r--cmd--回车

Dos命令:
d: 回车        盘符切换
dir(directory):列出当前目录下的文件以及文件夹
cd (change directory)改变指定目录(进入指定目录)
cd.. : 退回到上一级目录
cd\: 退回到根目录
cls : (clear screen)清屏
exit : 退出dos命令行(分割线上的需要掌握,下的了解)
md (make directory) : 创建目录
rd (remove directory): 删除目录
del (delete): 删除文件,删除一堆后缀名一样的文件*.txt
notepad 创建文件
删除带内容的文件夹
rd + /s        文件夹名称(询问是否删除)
rd + /q + /s 文件夹名称(直接删除)

HelloWorld的编写：
编写HelloWorld的程序
编译程序   javac.exe
运行程序   java.exe
把编写好的java文件放到jdk的安装bin目录中，为什么要放到这个目录呢，因为我们要编译这个java文件 就需要用到javac.exe ，也只有在bin目录中你才能够使用javac命令，包括java命令。

环境变量配置:
在JDK的bin目录下开发程序容易产生的问题
1.如果文件过多，不方便管理
2.删除自己写过的不需要的文件，可能不小心把JDK自带的工具给删除了
如何解决问题呢
3.notepad这样的命令为什么在任何路径下都能够执行,配置path环境变量
配置方式
xp系统
右键点击桌面计算机→选择属性→选择高级选项卡→点击环境变量→下方系统变量中查找path→双击path→将jdk安装目录下的bin目录添加到最左边并添加分号。
win7/win8系统
右键点击桌面计算机→选择属性→选择高级系统设置→选择高级选项卡→点击环境变量→下方系统变量中查找path→双击path→将jdk安装目录下的bin目录添加到最左边并添加分号。
path配置的是可执行的文件.exe,配置后可以在不同的盘符下访问path路径下的可执行文件

标识符：
标识符：起名字 / 除了关键字的单词 全部都是标识符；
标识符可以自己定义：
规则：
组成 数字 字母 _ $
注意：
不能以数字开头
不能是关键字
约定俗成的习惯：
类名，接口名： 首字母大写，如果包含多个单词的，后续的单词每个首字母都大写
            HelloWorld   Student   StudentTest
方法名，变量名：首字母小写，如果包含多个单词的，后续的单词每个首字母都大写
                get  getSum   price  applePrice
常量名： 所有字母都大写，如果包含多个单词的，单词之间用_隔开
                                        JAVA_HOME
                               
常量和变量：
常量：运行过程中 其值不会发生改变的量就是常量
变量：运行过程中 值可以发生改变的量
定义格式： 数据类型 变量名 = 初始化值;
                int a = 10;
注意事项：
1：局部变量使用之前必须先赋值；
2：变量作用范围 只在当前{}
3: 在同一个范围内 不能重复定义相同名字的变量
4：int a,b;  a=10;b=10;   int c=10,d=10;

        计算机中的存储：
最小的信息单元：bit
最小的存储单元：byte  = 8个bit位
数据类型
基本类型
整型
byte        1     -128 ~ 127
short        2
int        4
long        8
整型 默认类型是int
浮点型
float        4
double        8
浮点型默认类型是double
字符型
char        2
布尔型
boolean        1
有的人说 一个位就可以表示boolean类型 有的人说最小的存储单元应该是一个byte
这时候Java的官方文档就给出了明确的说法：  boolean类型的大小 没有定义

Day2:
eclipse：
        eclipse的安装：
                eclipse是用java开发的 所以他的打开是要有配置jdk的环境变量
       
运算符
        算数运算符
                表达式：用符号连接的式子（不能自成语句），除了复制运算符;
                       
                + - * /
                % ： 取余数
               
                字符和字符串参加运算符：
                        +：字符串连接符  （紧挨着字符串的那两个+号是字符串连接符

                ++ --
                        int a = 10;
                        // 当 ++ 放在变量的后面 ,a自己+1 ，a++整体不便
                        //int b = a++;
                        // 当++  放在变量的前面， a自己+1， ++a整体+1

        赋值运算符
                int a = 10;
                += -= *=
               
                关系运算符
                == != > <
                有关系运算符计算出来的结果 都是boolean类型的
                System.out.pritln(a=b); 打印的b的值
       
        逻辑运算符：
                & : 和                        真和假   有假则假
                | : 或                        真或假   有真则真
                ^ : 异（是否不同）        是不同 真， 是相同 假，
                ! : 非 取反                非真则假  非假则真
               
                &&：和&执行结果一样， && 效率高。 true && false ，当左侧是false的时候 右边不再看
                ||：

        三元运算符：
                int a = 10;
                int b = 11;
                        //   11      11
                boolean c = (b-- == ++a)? true : false; //true
        键盘录入:       
        1：第一步：导包
                在类的上面写 import java.util.Scanner;
        2：第二步： 创建Scanner对象
                Scanner sc = new Scanner(System.in);
        3: 第三步： 对象调nextInt()方法
                int a = sc.nextInt();
       




Day3:
顺序结构语句：
选择结构语句
if：
                if的第一种格式
                        if(关系表达式){
                                语句体;
                        }
                       
                if的第二种格式
                        if(关系表达式){
                                语句体一;
                        }else{
                                语句体二;
                        }

                if的第三种格式
                        if(关系表达式1){
                                语句体一;
                        }else if(关系表达式2){
                                语句体二;
                        }else if(关系表达式3){
                                语句体3;
                        }else{
                                语句体n;
                        }

                        注意：
                                如果if的第三种格式里面所有的条件表达式都满足， 从上往下，只执行第一个。

               
       
        switch：
                switch(表达式){ // byte short int char  jdk1.5之后枚举  jdk1.7版本String
                        case 值1:
                                语句;
                                break;
                        case 值2:
                                语句;
                                break;
                        case 值3:
                                语句;
                                break;
                        default:
                                语句;
                                break;
                }

               

循环结构语句：
        for循环：
                for(初始化语句;判断条件语句;控制条件语句){
                        循环体;
                }
               
                执行顺序：

                        for(A;B;C){
                                D;
                        }

                        A BDC BDC BDC BDC ... 直到B为false，则结束循环;
       
        while循环
                初始化语句;
                while(循环判断条件){
                        循环体；
                        控制条件语句;
                }

                        do while循环：
                初始化语句;
                do{
                        循环体;
                        控制条件语句;
                }while(循环条件);
       
        三种循环的区别：
                dowhile 和 for 和while的区别：
                        dowhile，先执行后判断的，所以肯定会执行一次循环体。
                        for和while 第一次判断是false话 不会再执行循环体
               
                for和while有什么区别：
                        for循环的初始化变量一般都定义在for循环的里面。所以for循环结束之后 变量释放了 就不能再用了
                        while循环的初始化变量都是定义在while循环的外面，所以while循环结束后 还是能继续使用。
               
                for循环的变形格式：
                        int x=1;
                        for(; x<=10; x++){
                                System.out.println("爱生活，爱Java");
                        }

                        int z=1;
                        for( ;z<=10;){
                                System.out.println("爱生活，爱Java");
                                 z++;
                        }
               
        死循环：
                long i = 0;
                for (;true;){
                        System.out.println(i++);
                }
               
                while(true){
                        System.out.println(i++);
                }
               
                do{
                        System.out.println(i++);
                }while(true);

        控制循环的语句break和continue：
                break：的作用就是强制中断循环。
                        注意事项：break只能写在循环中和switch结构中。
               
                continue：终止本次循环，继续下次循环。








Day4:
switch的注意事项：
        1：default无论放在switch的任何的位置， 都是先去看case 最后才去看default
        2：如果执行了一个case之后，里面没有遇到break， 直接case穿透（直接执行下一个case里面的内容，直到遇到break为止，或者到最后一个}）

Random 随机数
        导包：import java.util.Random;
        创建对象： Random r = new Random();
        获取随机数： int a = r.nextInt(10);
                int a1 = r.nextInt(100)+1;
                int a2 = r.nextInt(41)+40;// 40-80的随机数
       
数组
        数据类型：
                基本类型
                        整型
                                byte
                                short
                                int
                                long
                        浮点型
                                float
                                double
                        布尔型
                                boolean
                        字符型
                                char
                引用类型
                        类
                        接口
                        枚举
                        数组
        数组
               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};
        操作：
                数组的遍历：
                        for (int i = 0; i < arr.length; i++) {
                                System.out.println(arr[i]);
                        }

                求数组的最大值：
                        int max = arr[0];
                        for (int i = 0; i < arr.length; i++) {
                                if(max<arr[i]){
                                        max=arr[i];
                                }
                        }
二维数组：
        int[] arr = new int[]{1,2,3};
        有没有这样的数组， 数组里面继续存数组
        int[][] arr1 = new int[3][4]; //这样的定义 二维数组 里面的每个一维数组 长度都一样

        int[][] arr2 = {{4},{5,6},{7,8,9}};// 这样的定义 是可以做到每个一维数组的长度 相互不一样
        syso(arr2[2][2]);
        syso(arr2[1][1]);









Day5:
方法（函数）：
        方法的定义格式
                修饰符 返回值类型 方法名 (参数类型 参数名, 参数类型 参数名2,....){
                        方法体;
                        return 返回值;
               
        方法的调用：
                有返回值的方法，可以输出调用，也可以赋值调用， 虽然可以单独调用，但是单独调用没
        void方法的使用：
                当一个方法执行之后，不需要让这个方法返回一个值。 这时候 就需要让方法的返回值类型 写void

                        public static void print(){
                                System.out.println("helloworld");
                                return;
                        }

                        void的方法 只能单独调用，不能赋值调用 也不能输出调用
       


        方法的重载
                当一个类中， 出现方法名相同，参数列表不同，返回值无关，我们称这两个方法之间相互重载。
                        方法名必须相同
                        参数列表必须不同
                        返回值无关
               
        基本类型的参数传递
                形式参数的改变不影响实际参数； 原因是因为 基本类型的数是存在栈内存中。
                内存：
                        栈： 执行方法用的
                        堆： 存储一些引用型数据的 数组
                        方法区：存储一些class文件的
                       
                        本地方法区： 存储一些本地方法的
                                引用类型的参数传递
                形式参数的改变会影响实际参数， 原因是因为，引用类型的数据存在堆内存中，可以有很多个引用执行的，很多个引用共享他。
       
        Day6:
                debug： 断点调试；
                f6 是下一步
                f5 （执行到调用方法的那一步的时候）是进入方法
                debug的操作， 以及操作窗口的用处
       
        自动生成方法
       
Day7:
        面向对象：
       
                基本类型
                引用类型
                        类：一类事物  ： 女人 老婆

面向对象和面向过程：
        面向过程：
                好比咱们之前做过的一道题：  把数组 按照[1, 2, 3, 4]
               
                自己做饭： 整个过程很费劲 但是都得自己亲自去做。亲力亲为

        面向对象：
        找个人帮您做饭
        类和对象：
                为了方便我们的日常的调用执行。
                类： 一类事物  老婆
                对象：  你的老婆
               
                java描述一类事物的时候：定义为类
                我们所找的对象帮我们做事情， 这个对象 就是那一类事物中的一员

                事物：
                        属性：姓名 年龄 性别
                        行为：能做什么  买电脑  上厕所 学习  吃饭 思考

                        应该在类当中定义为：
                        成员变量：
                                类中 方法外面；
                                不需要初始化；
                        成员方法：
                                普通的方法 但是去掉static

       
        定义类：
                class Student{
                       
                        String name;
                        int age;
                        String sex;
                       
                        public void buyComputer(){
                                System.out.println("买电脑");
                        }
                }

        使用类：
                创建一个类的 对象，并去使用

                class StudentTest{
                        public static void main(String[] args){
                                // 类名 对象名 = new 类名();
                                Student s = new Student();

                                System.out.println(s.name);   //null  // 去看看这个学生的名字，  点表示“的”的意思 s.name  s的名字
                                System.out.println(s.age); //0
                               
                                s.name = "死奥迪";
                                s.age = 38;
                                s.sex = "女";

                                s.buyComputer();

                       
                        }
               
                }
       
       
       
        private： 修饰成员（一般修饰成员变量）
                被private修饰的成员， 只能在本类中访问 ，之外的任何地方不能直接访问

                所以一般被private修饰的成员变量， 我们都会提供给外界一个 set 和get方法（这两个方法都是public 外界直接能够访问的）

       
        Student的 比较安全的代码：标准代码：
               
        this:
                代表的是当前类的当前对象
                this说： 谁调用我  我就是谁

       
        构造方法：
                1：创建对象的时候 就肯定会调用构造方法；
                        顾名思义： 为了创建对象而存在的方法
                2：如果我们在一个类中没有给出任何构造方法， 系统会提供一个默认的 无参构造。
                3：如果我们提供了任何构造方法，系统就不会再听默认的无参构造方法了
                4：一个类中可以有多个构造方法，只要参数列表不同即可，也就是构造方法可以重载。

               
       

Day1:
Java:
使用java程序 必须要安装jdk
java为什么火：两个特性 开源  跨平台：
jdk和jre 和jvm
我们程序必须要有jvm才能运行
jre里面就有核心类库 也有jvm
jdk包含一些开发工具 也包含jre
开发人员  jdk
客户人员 jre

下如何打开DOS控制台？
a:开始--程序--附件--命令提示符
b:开始--运行--cmd--回车
c:win+r--cmd--回车

Dos命令:
d: 回车        盘符切换
dir(directory):列出当前目录下的文件以及文件夹
cd (change directory)改变指定目录(进入指定目录)
cd.. : 退回到上一级目录
cd\: 退回到根目录
cls : (clear screen)清屏
exit : 退出dos命令行(分割线上的需要掌握,下的了解)
md (make directory) : 创建目录
rd (remove directory): 删除目录
del (delete): 删除文件,删除一堆后缀名一样的文件*.txt
notepad 创建文件
删除带内容的文件夹
rd + /s        文件夹名称(询问是否删除)
rd + /q + /s 文件夹名称(直接删除)

HelloWorld的编写：
编写HelloWorld的程序
编译程序   javac.exe
运行程序   java.exe
把编写好的java文件放到jdk的安装bin目录中，为什么要放到这个目录呢，因为我们要编译这个java文件 就需要用到javac.exe ，也只有在bin目录中你才能够使用javac命令，包括java命令。

环境变量配置:
在JDK的bin目录下开发程序容易产生的问题
1.如果文件过多，不方便管理
2.删除自己写过的不需要的文件，可能不小心把JDK自带的工具给删除了
如何解决问题呢
3.notepad这样的命令为什么在任何路径下都能够执行,配置path环境变量
配置方式
xp系统
右键点击桌面计算机→选择属性→选择高级选项卡→点击环境变量→下方系统变量中查找path→双击path→将jdk安装目录下的bin目录添加到最左边并添加分号。
win7/win8系统
右键点击桌面计算机→选择属性→选择高级系统设置→选择高级选项卡→点击环境变量→下方系统变量中查找path→双击path→将jdk安装目录下的bin目录添加到最左边并添加分号。
path配置的是可执行的文件.exe,配置后可以在不同的盘符下访问path路径下的可执行文件

标识符：
标识符：起名字 / 除了关键字的单词 全部都是标识符；
标识符可以自己定义：
规则：
组成 数字 字母 _ $
注意：
不能以数字开头
不能是关键字
约定俗成的习惯：
类名，接口名： 首字母大写，如果包含多个单词的，后续的单词每个首字母都大写
            HelloWorld   Student   StudentTest
方法名，变量名：首字母小写，如果包含多个单词的，后续的单词每个首字母都大写
                get  getSum   price  applePrice
常量名： 所有字母都大写，如果包含多个单词的，单词之间用_隔开
                                        JAVA_HOME
                               
常量和变量：
常量：运行过程中 其值不会发生改变的量就是常量
变量：运行过程中 值可以发生改变的量
定义格式： 数据类型 变量名 = 初始化值;
                int a = 10;
注意事项：
1：局部变量使用之前必须先赋值；
2：变量作用范围 只在当前{}
3: 在同一个范围内 不能重复定义相同名字的变量
4：int a,b;  a=10;b=10;   int c=10,d=10;

        计算机中的存储：
最小的信息单元：bit
最小的存储单元：byte  = 8个bit位
数据类型
基本类型
整型
byte        1     -128 ~ 127
short        2
int        4
long        8
整型 默认类型是int
浮点型
float        4
double        8
浮点型默认类型是double
字符型
char        2
布尔型
boolean        1
有的人说 一个位就可以表示boolean类型 有的人说最小的存储单元应该是一个byte
这时候Java的官方文档就给出了明确的说法：  boolean类型的大小 没有定义

Day2:
eclipse：
        eclipse的安装：
                eclipse是用java开发的 所以他的打开是要有配置jdk的环境变量
       
运算符
        算数运算符
                表达式：用符号连接的式子（不能自成语句），除了复制运算符;
                       
                + - * /
                % ： 取余数
               
                字符和字符串参加运算符：
                        +：字符串连接符  （紧挨着字符串的那两个+号是字符串连接符

                ++ --
                        int a = 10;
                        // 当 ++ 放在变量的后面 ,a自己+1 ，a++整体不便
                        //int b = a++;
                        // 当++  放在变量的前面， a自己+1， ++a整体+1

        赋值运算符
                int a = 10;
                += -= *=
               
                关系运算符
                == != > <
                有关系运算符计算出来的结果 都是boolean类型的
                System.out.pritln(a=b); 打印的b的值
       
        逻辑运算符：
                & : 和                        真和假   有假则假
                | : 或                        真或假   有真则真
                ^ : 异（是否不同）        是不同 真， 是相同 假，
                ! : 非 取反                非真则假  非假则真
               
                &&：和&执行结果一样， && 效率高。 true && false ，当左侧是false的时候 右边不再看
                ||：

        三元运算符：
                int a = 10;
                int b = 11;
                        //   11      11
                boolean c = (b-- == ++a)? true : false; //true
        键盘录入:       
        1：第一步：导包
                在类的上面写 import java.util.Scanner;
        2：第二步： 创建Scanner对象
                Scanner sc = new Scanner(System.in);
        3: 第三步： 对象调nextInt()方法
                int a = sc.nextInt();
       




Day3:
顺序结构语句：
选择结构语句
if：
                if的第一种格式
                        if(关系表达式){
                                语句体;
                        }
                       
                if的第二种格式
                        if(关系表达式){
                                语句体一;
                        }else{
                                语句体二;
                        }

                if的第三种格式
                        if(关系表达式1){
                                语句体一;
                        }else if(关系表达式2){
                                语句体二;
                        }else if(关系表达式3){
                                语句体3;
                        }else{
                                语句体n;
                        }

                        注意：
                                如果if的第三种格式里面所有的条件表达式都满足， 从上往下，只执行第一个。

               
       
        switch：
                switch(表达式){ // byte short int char  jdk1.5之后枚举  jdk1.7版本String
                        case 值1:
                                语句;
                                break;
                        case 值2:
                                语句;
                                break;
                        case 值3:
                                语句;
                                break;
                        default:
                                语句;
                                break;
                }

               

循环结构语句：
        for循环：
                for(初始化语句;判断条件语句;控制条件语句){
                        循环体;
                }
               
                执行顺序：

                        for(A;B;C){
                                D;
                        }

                        A BDC BDC BDC BDC ... 直到B为false，则结束循环;
       
        while循环
                初始化语句;
                while(循环判断条件){
                        循环体；
                        控制条件语句;
                }

                        do while循环：
                初始化语句;
                do{
                        循环体;
                        控制条件语句;
                }while(循环条件);
       
        三种循环的区别：
                dowhile 和 for 和while的区别：
                        dowhile，先执行后判断的，所以肯定会执行一次循环体。
                        for和while 第一次判断是false话 不会再执行循环体
               
                for和while有什么区别：
                        for循环的初始化变量一般都定义在for循环的里面。所以for循环结束之后 变量释放了 就不能再用了
                        while循环的初始化变量都是定义在while循环的外面，所以while循环结束后 还是能继续使用。
               
                for循环的变形格式：
                        int x=1;
                        for(; x<=10; x++){
                                System.out.println("爱生活，爱Java");
                        }

                        int z=1;
                        for( ;z<=10;){
                                System.out.println("爱生活，爱Java");
                                 z++;
                        }
               
        死循环：
                long i = 0;
                for (;true;){
                        System.out.println(i++);
                }
               
                while(true){
                        System.out.println(i++);
                }
               
                do{
                        System.out.println(i++);
                }while(true);

        控制循环的语句break和continue：
                break：的作用就是强制中断循环。
                        注意事项：break只能写在循环中和switch结构中。
               
                continue：终止本次循环，继续下次循环。








Day4:
switch的注意事项：
        1：default无论放在switch的任何的位置， 都是先去看case 最后才去看default
        2：如果执行了一个case之后，里面没有遇到break， 直接case穿透（直接执行下一个case里面的内容，直到遇到break为止，或者到最后一个}）

Random 随机数
        导包：import java.util.Random;
        创建对象： Random r = new Random();
        获取随机数： int a = r.nextInt(10);
                int a1 = r.nextInt(100)+1;
                int a2 = r.nextInt(41)+40;// 40-80的随机数
       
数组
        数据类型：
                基本类型
                        整型
                                byte
                                short
                                int
                                long
                        浮点型
                                float
                                double
                        布尔型
                                boolean
                        字符型
                                char
                引用类型
                        类
                        接口
                        枚举
                        数组
        数组
               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};
        操作：
                数组的遍历：
                        for (int i = 0; i < arr.length; i++) {
                                System.out.println(arr[i]);
                        }

                求数组的最大值：
                        int max = arr[0];
                        for (int i = 0; i < arr.length; i++) {
                                if(max<arr[i]){
                                        max=arr[i];
                                }
                        }
二维数组：
        int[] arr = new int[]{1,2,3};
        有没有这样的数组， 数组里面继续存数组
        int[][] arr1 = new int[3][4]; //这样的定义 二维数组 里面的每个一维数组 长度都一样

        int[][] arr2 = {{4},{5,6},{7,8,9}};// 这样的定义 是可以做到每个一维数组的长度 相互不一样
        syso(arr2[2][2]);
        syso(arr2[1][1]);









Day5:
方法（函数）：
        方法的定义格式
                修饰符 返回值类型 方法名 (参数类型 参数名, 参数类型 参数名2,....){
                        方法体;
                        return 返回值;
               
        方法的调用：
                有返回值的方法，可以输出调用，也可以赋值调用， 虽然可以单独调用，但是单独调用没
        void方法的使用：
                当一个方法执行之后，不需要让这个方法返回一个值。 这时候 就需要让方法的返回值类型 写void

                        public static void print(){
                                System.out.println("helloworld");
                                return;
                        }

                        void的方法 只能单独调用，不能赋值调用 也不能输出调用
       


        方法的重载
                当一个类中， 出现方法名相同，参数列表不同，返回值无关，我们称这两个方法之间相互重载。
                        方法名必须相同
                        参数列表必须不同
                        返回值无关
               
        基本类型的参数传递
                形式参数的改变不影响实际参数； 原因是因为 基本类型的数是存在栈内存中。
                内存：
                        栈： 执行方法用的
                        堆： 存储一些引用型数据的 数组
                        方法区：存储一些class文件的
                       
                        本地方法区： 存储一些本地方法的
                                引用类型的参数传递
                形式参数的改变会影响实际参数， 原因是因为，引用类型的数据存在堆内存中，可以有很多个引用执行的，很多个引用共享他。
       
        Day6:
                debug： 断点调试；
                f6 是下一步
                f5 （执行到调用方法的那一步的时候）是进入方法
                debug的操作， 以及操作窗口的用处
       
        自动生成方法
       
Day7:
        面向对象：
       
                基本类型
                引用类型
                        类：一类事物  ： 女人 老婆

面向对象和面向过程：
        面向过程：
                好比咱们之前做过的一道题：  把数组 按照[1, 2, 3, 4]
               
                自己做饭： 整个过程很费劲 但是都得自己亲自去做。亲力亲为

        面向对象：
        找个人帮您做饭
        类和对象：
                为了方便我们的日常的调用执行。
                类： 一类事物  老婆
                对象：  你的老婆
               
                java描述一类事物的时候：定义为类
                我们所找的对象帮我们做事情， 这个对象 就是那一类事物中的一员

                事物：
                        属性：姓名 年龄 性别
                        行为：能做什么  买电脑  上厕所 学习  吃饭 思考

                        应该在类当中定义为：
                        成员变量：
                                类中 方法外面；
                                不需要初始化；
                        成员方法：
                                普通的方法 但是去掉static

       
        定义类：
                class Student{
                       
                        String name;
                        int age;
                        String sex;
                       
                        public void buyComputer(){
                                System.out.println("买电脑");
                        }
                }

        使用类：
                创建一个类的 对象，并去使用

                class StudentTest{
                        public static void main(String[] args){
                                // 类名 对象名 = new 类名();
                                Student s = new Student();

                                System.out.println(s.name);   //null  // 去看看这个学生的名字，  点表示“的”的意思 s.name  s的名字
                                System.out.println(s.age); //0
                               
                                s.name = "死奥迪";
                                s.age = 38;
                                s.sex = "女";

                                s.buyComputer();

                       
                        }
               
                }
       
       
       
        private： 修饰成员（一般修饰成员变量）
                被private修饰的成员， 只能在本类中访问 ，之外的任何地方不能直接访问

                所以一般被private修饰的成员变量， 我们都会提供给外界一个 set 和get方法（这两个方法都是public 外界直接能够访问的）

       
        Student的 比较安全的代码：标准代码：
               
        this:
                代表的是当前类的当前对象
                this说： 谁调用我  我就是谁

       
        构造方法：
                1：创建对象的时候 就肯定会调用构造方法；
                        顾名思义： 为了创建对象而存在的方法
                2：如果我们在一个类中没有给出任何构造方法， 系统会提供一个默认的 无参构造。
                3：如果我们提供了任何构造方法，系统就不会再听默认的无参构造方法了
                4：一个类中可以有多个构造方法，只要参数列表不同即可，也就是构造方法可以重载。