JAVA_06

何为面向过程？
面向过程的实质是注重实现功能及步骤流程，一步步解决问题。

面向对象开发

面向对象的实质是从结果出发，即站在管理者的角度去解决问题
把每个功能板块交给有能力的人去做 学会 分配任务，最后自己收取成果即可；

			输出一个数组
常规操作是
 for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j] > a[j + 1]) {      //这是升序排序
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;

                }
            }
        }
但是我只要调用Arrays.toString(数组名称)即可完成数组的输出；

类是抽象的；用于描述一个一类事物；
对象： 是一个具体表现，对类进行属性的赋值与定义 //属性 和方法
成员属性 ： 是什么？？？几岁？叫什么？性别是？？
成员方法： 能做什么？动作 可以访问成员属性；

类与对象的关系：
                                    类是对象的抽象概念；      //理想的蓝图
                                    对象是类的具体表现；  //现实的残酷；

类的定义：
class 类名—大写{
成员属性 //在方法外面； 类变量也叫实例变量
public void//或者int等等其他数据类型 eat(){}; //普通方法；（成员方法）
成员方法不要用静态 static；

                                  导包的操作：import java.util(包名).Scanner(类名) 包名+类名
                                  在同一个包下面不用导入；


                                  实例化对象：
                                        类名  对象名 = new 类名（）； 实际就是调用构造函数；
                                        Student stu  = new Student(); 实例化一个学生对象；

                                        //堆里面含有类的属性和方法
                                                类的属性就一直在堆里面   （属性都含有默认值！！！）
                                                不是指向方法区里面属性的属性地址；

                                        //堆里面的方法记录的是方法区的地址
                                         //方法的具体实现是是在方法区里面
                                         即比如求和方法  具体的过程是在方法区
                                         方法就没有默认值

                                    方法区里面都是一些类的基本信息！！！
                                      堆也可以叫回收垃圾的堆
                                      堆里面属性跟
                                      方法是独立的一个地址


               创建对象的两个方法
              1.在主程序直接new对象；
              2.较复杂  需要调用main外类里的静态方法    通过方法构建对象
                            方法需要返回一个对象；
                            方法体内执行new对象的过程；
                            注意：！！只要是关于返回对象的数据类型 一定得定义一个变量给他储存；
                   内存地址用哈希值表示时 哈希值是随机产生的
                    当内存地址相同时  哈希值不一定相同；
                    new一个对象的（方法）： //在main类外的方法：
                    1.以引用数据类型作为返回值类型 public static int[] a(方法名){}
                    2.以引用数据类型作为方法的参数；public static
                  匿名对象：
                        1.它是不会在栈中有地址！！  但是在堆中有内存空间 所以运行不到 编译通过
                        2. 形式  new int（）；
                        3.匿名对象就只用一次 一般用于方法的参数,节省内存空间；
                        4.匿名对象给成员变量赋值没有意义；
                                例子 new Person().age  //只要你new一个对象 值都是重新变化的
                         5.匿名对象一般用于方法的调用或者是作为方法的参数；
                                    new Person().study   getPhone(new Person());





                        成员变量与局部变量的区别：
                         局部变量：方法里的变量，包含方法的参数
                         成员变量： 类里 方法外的变量
                         生命周期：
                                1.局部：随着方法的开始而开始，随着方法的结束而结束；
                                2.成员： 随着对象的创建而开始，随着对象的回收而结束；
                                        垃圾回收器
                           存在位置：
                               1.局部变量存在栈里面 没有默认值；
                               2.成员变量存在堆里面； 有默认值；

                               封装
                      成员变量属性的私有化@！
                                    属性只能在本类被访问，其他类不能访问该类的属性值；
                                优点：
                                        1.隐藏内部细节
                                        2.保护数据的安全，防止数据的错误；
                                        3.提供对外两个对外的方法。
                                                1.提供设置的方法  赋值  setXXX（）
                                                 将外界的值赋值给本类的属性，需要参数
                                                2.提供取值的方法  getXXX（）
                                                    将已赋值得属性通过get方法返回给外类  本类的属性
                                                    return name; 返回的值


                                            因为外界只能通过公共的方法入口进去
                                            然后将参数传给本类的setXX方法
                                            方法体为  =  赋值操作
                                            这样本类的属性就有初值

                                            但是这样外界只是将值赋给本类  但是他本身没有收到值！！
                                            就需要getXXX（）方法
                                            return 本类的属性值
                                            外界调用getXXX（）方法就能获取name的值；

                    私有化就是封装
                    this的用法
                        1.本类对象的引用  也就是谁调用这个方法 ，这个对象就是谁
                        2.this.变量就是成员变量
                        如 this.name = name;
                                1.第一个name是本类的成员变量
                                2.第二个name是方法的参数
                         3.this（）是成员方法
                         4.如果成员变量名和局部变量一样
                                        在方法里面 局部变量的作用域优先于成员变量；




            封装
                1.属性的封装：
                            setXXX和getXXX；//封装私有化属性
                2.方法的封装
                        如将实现冒泡排序功能的一堆执行语句代码块封装到方法中
                        只要在主函数内调用某类的方法（数据类型 变量名）即可实现功能；
                        调用某类的前提是创建了类 且 主函数实例化了对象 才能调用

总结

对象的声明和创建是不同的
声明是 Person p;只是栈中有这个Person类型的引用变量p；但是没有指向堆；
new Person（）是在堆里面储存类的属性 以及方法 注意 方法里面存的是方法区里面方法的地址！！！

Student student = null;
        System.out.println(student);

方法中reurn就是结束方法的语句；后面的程序执行
如

if（i = =3）{  return；} x+=34;

用对象名作方法参数时需要提前将实参new出来

 public static void main(String[] args) {

        Student stu = new Student();//	若是没有new的话 stu是空对象！！
        getStudent(stu);

    }
        //    以引用数据类型作为参数
        public static void getStudent (Student student){		//**以引用数据类型为参数一定得new！**
              System.out.println(student.name);
              System.out.println(student.age);

 Student stu ;
        getStudent(stu);			//报 stu 未初始化 即空对象的错误

可以把null赋值给对象引用变量；

Person p = null;
但是p.name 操作属性的时候就会报出空指针的错误

**.匿名对象给成员变量赋值没有意义；
例子 new Person().age //只要你new一个对象 值都是重新变化的
5.匿名对象一般用于方法的调用或者是作为方法的参数；
new Person().study

***getPhone(new Person());***不等于getPerson（Person p）！！！
两个有区别
Person p是已经在堆开辟了空间 一个是 new Person()匿名对象的使用