面向过程、面对对象。
        面向过程：每一步都需要我们自己去完成。都需要我们自己去实现。
                         举例：
                                追女孩子
                                        
                                面向过程的思想去追一个女孩子。
                                        到大马路上去务色
                                        舔着脸去要微信号
                                        尬聊
                                        继续尬聊
                                        约出来吃饭
                                        约出来看电影
                                        约出来压马路
                                        ...
                                        成为了你的女朋友。

        面向对象：对象又是一个什么角色？
                        在我们需要完成一件事情的时候，我们不是立马就开始干。
                        而是先去找，谁可以干这件事情，谁可以干，那么我就让谁去干这件事情。
                        我不关心过程，只关心结果。
                        所以，面向对象中的对象，指的是：真正可以做事情的那个人。


                                面向对象的思想去追一个女孩子：
                                        "忽略过程，找谁可以做，那么就让谁去做。"
                                        
                                        思考：谁可以帮我追一个女孩子。
                                                        家里的七姑八大姨。

                                        你要不要关心七姑八大姨是如何帮你找一个女朋友的？
                                        不要关心，只要关心她给你找的这个结果就可以了。

                                        在这个过程中：谁是面向对象中的对象：七姑八大姨
                                        



        举例：
                我要对数组进行遍历。遍历的格式 : [1, 2, 3, 4, 5]
                int [] arr = {1,2,3,4,5};
                面向过程：
                        System.out.print("[");
                        for (int i = 0; i < arr.length ;  i++){
                                if(i == arr.length - 1){
                                        System.out.print(i);
                                }else{
                                        System.out.print(i + ", ");
                                }
                        }
                        System.out.println("]");
                
                简单来说：
                        其中的每一步都需要我们自己去完成。
                        包括：打印，遍历，判断是否为最后一个...

                
                面向对象：
                        我要找谁可以干这件事情，谁可以干，我就让谁去干，我忽略过程，只关心结果。
                        在Java中提供了很多能帮我们做事情的类，比如：Scanner 可以帮我们进行键盘录入。
                        比如Random可以帮我们计算随机数。Arrays可以帮我们操作数组。


                        我要找谁可以做遍历数组的事情呢？Arrays可以做
                        所以我现在就懒得去做了，让Arrays去做，我只关心遍历的结果，而忽略了遍历的过程。
                        String result = Arrays.toString(arr);//就是把一个数组变成一个字符串。
                        System.out.println(result);


        比如：
                Random

                面向过程的思想特点写随机数：就需要使用到数学中很复杂的计算方法。

                面向对象的思想特点写随机数：谁可以干这件事情。 Random可以干
                                                                        那么我们自己就懒的去做干，直接让Random去干，我们只要得到最终的结果就可以了。



现实生活中的一个 懒人思想。




1.类和对象
        在面向对象的过程中，什么是类？什么是对象？

        类：是对一类事物的描述。
        对象：才是这类事物的真正的具体的体现。


                以学生群体为例
                

                //这些东西不是真正的一个学生。
                //而是对学生这类群体的一个描述
                //所以在Java中。是以类的形式体现的。
                        姓名
                        年龄
                        身高
                        学历
                        学习情况
                        可以吃饭
                        可以睡觉
                        可以学习
                        可以玩游戏
                        ....

                //通过这类描述来创建的真正的一个学生，那么才是对象。
                        比如：
                                根据这个描述找到一个 张三同学。
                        


2.类的定义
        属性：是什么。有什么？
                        
                                姓名
                                年龄
                                身高
                                学历
                                学习情况
                        在代码中，属性是以成员变量的形式体现。

        行为：能干什么？
                        可以吃饭
                        可以睡觉
                        可以学习
                        可以玩游戏
                        
                        在代码中，行为是以成员方法的形式体现。
                                
3.单个对象内存图
                int [] arr = new int[3];
                Student s = new Student();

                new:只要是new出来的，一定是在堆里面开辟了一个新的小空间。

4.多个对象内存图

        多个对象之间，互相是不影响的。

5.多个对象指向相同空间内存图
        结论：
                当其中一个对象对小空间中的值发生了改变，
                那么其他所有的对象再次访问这个小空间时，就是修改后的结果。

        

6，成员变量和局部变量的区别
        编故事记忆法：
                小明家养了一条狗，这条狗是母狗，有一天，母狗怀孕了。
                小红去问小明：你家的狗生了吗？
                小明回答："未生出"。

        
        未：
                位置
                        代码中的位置
                                局部变量：方法内/方法声明上。
                                成员变量：类中，方法外

                        内存中的位置
                                局部变量：栈
                                成员变量：堆

        生：
                生命周期(侧重于在内存中)
                                局部变量：方法被调用的时候出现。方法执行完毕就消失了。
                                成员变量: 随着对象的创建而存在，随着对象变成垃圾而消失。
                                                                                                                        

                作用范围(侧重于在代码中)
                                局部变量：只在方法中有效
                                成员变量: 在类中有效。
                                

        出：
                初始化值
                                局部变量：没有初始化值，如果没有赋值则不能使用。
                                成员变量: 有默认初始化值。整数 0 小数 0.0 引用 null                        


7.private关键字
        用来描述一类事物的类：Student类，Phone类，Teacher类.... 统称为 javabean类，实体类。
        用来创建的，带有main方法的类：测试类。


        a,private作用
                可以保证数据的安全性。
                一旦方法或者变量被private修饰，他只能在本类中被访问。


        b,格式
                直接写在变量或者方法的前面就可以了
                
                private String name;
                private void method(){...}


        c,好处
                保证数据的安全性。


        d,当private修饰变量时的完整格式：
                第一步：将变量使用private修饰
                第二步：针对于每一个私有化的成员变量，都要提供对应的get和set方法。



8.this关键字
        变量：就近原则
                当局部变量跟成员变量重名时，如果变量前面没有任何的前缀。会触发就近原则。
                
                就近原则的概念：
                        谁离我近，我就使用谁。
                        先到局部位置去找，如果能找到，就使用局部位置的。
                        如果找不到，就去本类的成员位置找，如果找到了就使用本类成员位置。
                        如果找不到就报错。
                        

        this关键字表示的是什么？
                        this关键字作用就是区分成员变量跟局部变量。
                        this.变量名//此时这个变量不会到本方法中找，而直接定位到本类的成员位置。



9，this的内存图
        this：谁来调用我，我就代表谁。
                那个对象来调用this所在的方法，那么此时this就代表这个对象的地址值。


10,封装
        面向对象三大特征之一。

        1.抽取方法。

        2.私有化成员变量。为了保证数据的安全性。


        简单理解：封装就是把一段代码或者成员变量，封起来，装起来。


11.构造方法
        格式:
                修饰符 类名(){
                        方法体;
                }
        案例：
                public Student(){
                        ...
                }

        注意点：
                1.构造方法没有返回值，连void都没有。
                2.构造方法不能使用对象直接调用。

                Student s = new Student();
                s.sleep();
                s.eat();
                s.Student();//错误的。不能直接调用。
        
        作用：
                就是在new对象的时候，给虚拟机调用的。

                Student s = new Student();//后面的小括号里面什么都没有，所以表示调用空参构造。

总结：
        在创建对象的时候，虚拟机会根据小括号中的内容去调用不同的构造方法。
        构造方法就是在创建对象的时候，由虚拟机调用的。
        


12.构造方法的注意事项：
        建议：
                1.空参构造
                2.带有全部参数的构造//全参构造


        Student s = new Student();
        s.setName("张三");
        s.setAge(23);


        Student s = new Student("张三",23);

使用规则：
        1.如果在创建对象的时候，知道了所有的属性值，那么建议使用第二种。
        2.如果在创建对象的时候，不知道所有的属性值，那么使用第一种，当知道了属性时，再set进去。




13.javabean类。
                标准javabean类的步骤：
                        1.类名。要见名知意
                        2.私有化成员变量。//保证数据的安全性
                        3.空参构造
                        4.全参构造
                        5.针对于每一个私有化的成员变量，都要提供其对应的get和set方法。
                        6.show


        
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show() {
        System.out.println(name + "---" + age);
    }
}


class Demo{
        public static void main(String [] args){
                Student s1 = new Student("张三1",21);
                Student s2 = new Student("张三2",22);
                Student s3 = new Student("张三3",23);
                Student s4 = new Student("张三4",24);
                Student s5 = new Student("张三5",25);
        }
}


疑问：
        1.空参构造此时就没用了？是的
                既然没有用，那么是不是可以不写？不是的
                        就算没有用，也必须要写。必须按照规则写。
                        
        
        2.set方法跟构造方法有什么区别？
                共同点：都可以给成员变量进行赋值。
                区别：set方法是已经有了对象时进行赋值（修改值）
                          构造方法"只能"在创建对象的时候进行赋值。


                          Student s = new Student();
                          s.setName("张三");//把张三赋值给name
                                                                //其实是把张三将默认初始化null给覆盖了。

        3.get方法跟show方法有什么区别？
                show方法只能展示。//我现在想要看一下对象里面的属性值时
                        Student s = new Student();
                        System.out.println(s);//打印的是地址值
        
                get方法可以展示，也可以获取单个属性值用作其他运算。

                //get方法和show方法的意义。
                Student s = new Student("zhangsan",23);
        s.show();

       //需求：
        //我要把学生的年龄加一岁
        int age = s.getAge();
        age = age + 1;
        s.setAge(age);

        s.show();