一、面向对象

面向对象与面向过程的区别？

    面向过程的思想：代表语言 C语言 功能开发中的每一步都是自己参与的
    面向对象的思想：代表语言 java语言 指的是不断地创建对象，指挥对象事情过程

面向对象的思想：

        1、都有那些事物？
            判断事物的方式：
                1）UML课程知识
                2）名词提取法
                    大象，冰箱，测试类

        2、事物中都有些什么？
                大象：
                    属性：身高，体重，性别....
                    行为：跳进冰箱，吃饭，睡觉....
                冰箱：
                    属性：颜色，容量，大小...
                    行为：打开冰箱门，关闭冰箱门...
                测试类：
                    main方法

面向对象的三大特征：

    封装
    继承
    多态

如何通过一个类创建一个对象

    语法格式：类名 对象名 = new 类名();

public class Student {
    //成员变量，定义在类中方法外
    String name;
    int age;
    String gender;

    //成员方法
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

class Demo1 {
    public static void main(String[] args) {
        //创建一个学生对象
        //如何通过一个类创建一个对象
        // 语法格式：类名 对象名 = new 类名();
        Student s1 = new Student();
        //获取对象中的成员变量
        //对象名.成员变量名
        String n1 = s1.name;
        System.out.println("姓名：" + n1);
        s1.name = "wll";
        System.out.println("姓名：" + s1.name);

        //如何使用对象中的成员方法
//        eat();
        //对象名.成员方法名()
        s1.eat();
        s1.sleep();
    }
}

//定义一个教师类
class Teacher {
    public void fun2(){
        System.out.println("好好学习，天天向上！");
    }
}

class Demo2{
    //当一个类作为方法的参数的时候，将来调用时需要传入该类的对象【或者该类的子类对象】
    public void method(Teacher t){ //Teacher t = new Teacher()
        t.fun2();
    }
}

public class TeacherDemo1 {
    public static void main(String[] args) {
        Demo2 d1 = new Demo2();
//        Teacher t1 = new Teacher();
        d1.method(new Teacher()); // new Teacher()

        //匿名对象，指的是没有名字的对象，只能用一次，后续无法继续使用该对象
//        d1.method(new Teacher());
    }
}

二、private

    我们按照今天说的类和对象的知识，创建了一个Person对象，并且也成功赋值了姓名和年龄
    但是我们可以赋值一些不合实际的数值，这是不应该出现，所以我们应该在赋值之前，要先判断一下要赋的值是否合理
    既然是加判断，就不是一句话可以搞定的，我们可以定义一个方法，使用方法对成员变量赋值
    我们确实可以通过加一个方法来对成员变量进行赋值，但是谁规定了我必须要用这个方法呢？我们依旧可以使用原来的方式进行赋值
    我们如果可以通过一些手段，让外界无法直接获取成员变量，这样就不得不使用方法进行赋值了。
    java提供一个关键字给我们使用：private 私有的

    private关键字：
        可以修饰成员变量，成员方法，构造方法
        在同一个类中，private关键字不起作用，相当于透明的，同一个类中被private关键字修饰的成员可以随意访问


    说到现在，其实说的就是面向对象编程三大特征之一：封装
    封装： 使用private关键字将类中细节进行隐藏，只对外提供公共的访问方式。

    一个标准类的写法：最终是4.0版本
        1.0版本的写法：使用private关键字修饰成员变量
        类：
            成员变量：使用private关键字修饰
            成员方法：针对每一个成员变量提供对应公共的setXxx()和getXxx()

class Person {
    private String name;
    private int age;

    public String getName(){
        return name;
    }

    public void setName(String n){
        name = n;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int i) {
        if (i > 0 && i <= 130) {
            age = i;
        }else {
            System.out.println("输入的年龄不合实际！");
        }
    }

    private void fun1(){
        System.out.println("好好学习，天天向上！");
    }

    public void show1(){
        fun1();
    }
}

public class PersonDemo {
    public static void main(String[] args) {
        //创建一个Person类的对象
        Person p1 = new Person();
//        System.out.println("姓名：" + p1.name);
//        System.out.println("年龄：" + p1.age);
        System.out.println("姓名：" + p1.getName());
        System.out.println("年龄：" + p1.getAge());
        System.out.println("-------------------------");
//        p1.name = "江川";
//        p1.age = 1800;
        p1.setAge(1800);
        p1.setName("wll");
//        System.out.println("姓名：" + p1.name);
//        System.out.println("年龄：" + p1.age);
        System.out.println("姓名：" + p1.getName());
        System.out.println("年龄：" + p1.getAge());
        System.out.println("------------------------");
//        p1.fun1();
        p1.show1();
    }
}