java_day5_面向对象、private关键字

一、面向对象

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

    面向过程的思想：代表语言 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();
    }
}