第八节（面向对象，面向过程）

1：面向过程与面向对象的区别：

为什么会出现面向对象分析方法？
   因为现实世界太复杂多变，面向过程的分析方法无法满足

   面向过程？

采用面向过程必须了解整个过程， 每个步骤都有因果关系， 每个因果关系都构成了一个步骤，多个步骤就构成了一个系统， 因为存在
因果关系每个步骤很难分离， 非常紧密， 当任何一步骤出现问题，将会影响到所有的系统。如：采用面向过程生产电脑，那么他不会
分 CPU 、主板和硬盘，它会按照电脑的工作流程一次成型。

   面向对象？
面向对象对会将现实世界分割成不同的单元（对象） ，实现各个对象，如果完成某个功能，
只需要将各个对象协作起来就可以

2：面向对象的三大特性：

万事万物皆对象 , 反映了现实世界中具体事物

封装 （电视机盒子）

继承 （老爸有钱，儿子就有钱）

多态 ( 同一个行为具有多个不同表现形式或形态的能力 )

java中的类

类是对具有共性事物的抽象描述，它描述一类对象的行为和状态（抽象的过程，实际不存在 引用数据类型）来看， 基于面向对象可以

一个类可以包含以下类型变量

局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁

成员变量：

成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

3：类与对象的概念

对象：

对象是类的一个实例，有状态和行为（例如，一条狗是一个对象，它的状态有：颜色、名字、品种）

行为有：摇尾巴、叫、吃等。（具体的实物）

类：类是对具有共性事物的抽象描述，它描述一类对象的行为和状态（抽象的过程，实际不存在 引用数据类型

类是对象的集合，对象是类的具体表现形式 

4：面向对象的封装性

封装其实就是封装属性， 让外界知道这个类的状态越少越好

5：构造函数

构造方法主要用来创建类的实例化对象， 可以完成创建实例化对象的初始化工作， 声明格式：

构造方法修饰词列表 类名（方法参数列表）

构造方法修饰词列表：public 、proteced、private

类的构造方法和普通方法一样可以进行重载

构造方法具有的特点：

  构造方法名称必须与类名一致

  构造方法不具有任何返回值类型，即没有返回值，关键字 void 也不能加入，加入后就不是构造方法了，就成了普通的方法了

  任何类都有构造方法， 如果没有显示的定义， 则系统会为该类定义一个默认的构造器， 这个构造器不含任何参数， 如果显示的定义

  了构造器， 系统就不会创建默认的不含参数的构造器了

/*
    定义一个现实生活中的 学生的类
    Student 是一个类，学生 ，一种引用类型
    Student 是在概念上是一个定义，现实生活中是不存在的    
    语法：
        类的修饰符 class 类名 extends 父对象的名称 implements 接口的名称{            
            类体：属性和方法组成                
        }
*/
public class Student{
    
    // 属性        
    // 学号
    int id; 
    
    // 成员变量，实例变量，非静态变量
    // id是对象的级别的，必须现有对象才能访问，不能使用类直接访问
    // 姓名
     public static String name = "ming";

    // 性别
    boolean sex;
    
    // 年龄
    int age;
    
    // 住址
    String address;
    // 方法
}
/*
    
    对象的创建和使用
*/
public class OOTest01{
    
    // java入口
    public static void main(String[] args){
        
        
        // 创建对象
        // Student 是一个学生类
        // stu 是一个局部变量，这个局部变量时Student类型，也就是一个引用类型
        // stu 这个局部变量称之为 引用，引用中保存了对象在堆中 的内存地址。
        // 通过“引用” 去间接访问堆中的对象
        Student stu = new Student();
        
        // 一个类还可以创建多个对象
        Student stu1 = new Student();
        // 获取属性
        // name 是成员变量，对象相关，必须的现有对象才能访问，必须使用“引用.”
        // 如果跟对象不想关，但是还需要访问：改变的权限 使用“静态变量” 声明static即可
        System.out.println(Student.name);
        String n = stu.name;
        
        System.out.println("学生姓名："+n);
        System.out.println("学生编号："+stu.id);
        System.out.println("学生年龄："+stu.age);
        System.out.println("学生性别："+stu.sex);        
        // 使用对象
        // 访问成员变量时，必须使用“引用.”        
        
    }

}

例2：
/*
    定义一个Ming类型
    类 = 属性 + 方法;
    
    面向对象的封装性指的是：
        
        1. 属性私有化；
        2. 对外提供公开的setter and getter
        
        set方法和get方法 我们的方法名应该遵循规范。

*/
public class Ming{

    
    // 属性
    // 成员变量，实例变量，非静态变量
    // private 修饰数据的 只能在本类中访问
    private int age;    
    // set 赋值
    public void setAge(int x){
        // 条件判断
        if(x < 0 || x > 150){
            System.out.println("年龄不合法 !");
            return;    
        }
        age = x;
    }
    
    // get 获取
    // 成员方法必须使用“引用.”的方式来访问
    public int getAge(){    // 成员方法，实例方法，非静态方法 
        return age;
    }
}


/*
    面向对象的封装性
*/

public class OOTest02{

    public static void main(String[] args){
            
        // 创建ming类型的对象
        Ming a = new Ming();
        
        // 读取ming的年龄
        //System.out.println(a.age); // Error，因为 age是私有属性
        
        // 赋值
        // a.age = 30; // Error，因为 age是私有属性
        
        // 利用set方法赋值
        a.setAge(10000);
        
        // 读取get 
        int age = a.getAge();
        
        System.out.println("ming的年龄："+age);     
    }
}

例题3：
/*
    构造函数
    
    1. 构造方法的语法：
    
        【构造方法的修饰词列表】 类名 (方法参数列表){
            方法体;    
        }
        
    2. 构造方法的方法名和类名一致
        
    3. 构造方法的作用是什么？
        <1> 创建对象
        <2> 给成员变量赋值（初始化成员变量）
    
    4. 构造方法如何调用
        new 构造方法名(实参);  在堆中开辟空间存储对象

    5. 如果一个类 没有提供任何的构造方法，系统默认提供无参构造方法
    如果一个类，已经手动的提供了构造方法，那么系统不会再提供任何的构造方法；
    
    6. 成员变量到底什么时候赋值？
        只有在调用方法的时候，才会给成员变量赋值
*/

public class User{

    // 属性
    // 成员变量，实例变量，非静态变量
    String name ;
    int age;
    
    
    // 定义一个构造方法（构造方法构成了 重载）
    User(){
        System.out.println("我是第一个构造方法");
        name = "ming";
        age = 30;
    }
    
    User(int a){
        age = a;
    }
    
    User(String n){
        name = n;
    }

    User(String n,int a){
        name = n;
        age = a;
    }
}
/*
    
    构造函数（构造方法，构造器，Constructor）
    
    语法：
        
        构造方法 和普通方法一样，都可以进行重载

*/

public class  ConstructorTest01{

    public static void main(String[] args){
        
        // 创建User类型对象
        
        User u = new User();
        
        User u1 = new User(30);
        
        User u2 = new User("ming哥");
        
        User u3 = new User("ming",40);        
        System.out.println(u.name);
        System.out.println(u.age);
            
        System.out.println(u1.name);        
        System.out.println(u1.age);
        
        System.out.println(u2.name);        
        System.out.println(u2.age);
        
        System.out.println(u3.name);        
        System.out.println(u3.age);
    }
}