面向对象概述

软件开发方式

面向过程

一种较早的编程思想，顾名思义该思想是站在过程的角度思考问题，强调的是我该怎么去做。即功能的执行过程，即先干啥，后干啥。

面向过程思想中函数是一等公民，每个函数负责完成某一个功能，用以接受输入数据，函数对输入数据进行处理，然后输出结果数据。

编辑

而每一个功能我们都使用函数（类似于方法）把这些步骤一步一步实现，使用的时候依次调用函数就可以了。

编辑

面向过程的设计思想，系统软件适应性差，可拓展性差，维护性低。

面向对象

一种基于面向过程的新的编程思想，顾名思义该思想是站在对象的角度思考问题，我们把多个功能 合理的放到不同对象里，强调的是我该让谁来做。

面向对象最小的程序单元是类，必须先存在类的定义，再有对象，而具备某种功能的实体，称为对象。

编辑

举个例子，小明完成买菜，做菜，吃饭，洗完，写代码功能。大家一起来看看有对象和没对象的区别：

编辑

左图是没有对象的，右图是有对象的。区分面向过程的我该怎么做和面向对象的我该让谁来做的思

想。

面向过程和面向对象各有千秋，面向对象更符合我们常规的思维方式，稳定性好，可重用性强，易

于开发大型软件产品，有良好的可维护性，它拥有三大特征：

封装（Encapsulation）

继承（Inheritance）

多态（Polymorphism）

成员变量和局部变量

变量的定义语法:

数据类型 变量名 = 初始值;

变量的分类

根据变量定义位置的不同，分成两大类:

成员变量：直接定义在类中，方法外面。又称之为字段（Field），不要称之为属性（错误）;

局部变量：除了成员变量，其他都是局部变量，具体存在于三个地方

       (1)方法内

       (2)方法的形参

       (3)代码块中（一对花括号）

编辑

变量的初始值

变量的初始化表示在内存中开辟存储空间，只有初始化之后，才能使用。

(1)成员变量：默认是有初始值的，不同类型的初始值，如下图

编辑

(2)局部变量：没有初始值，所以必须手动先初始化才能使用

变量的作用域

变量根据定义的位置不同，也决定了各自的作用域是不同的，关键看变量所在的那对花括号。

成员变量：在所定义的类中都有效

局部变量：从开始定义的位置开始，只能在自己所在的花括号内有效

变量的生命周期

变量的生命周期，表示变量在内存在能存活多久。

成员变量：存储在堆内存中，随着对象的销毁而销毁

局部变量：存储在栈内存中，随着所定义方法的调用结束而销毁

局部变量存储在方法中，每次调用方法都会在栈空间开辟一块内存空间——栈帧，方法调用结束，栈帧就被销毁了，内存中的存储的变量数据也销毁了

class Person { 
    String name; 
    int age;
}
public class App {
    public static void main(String[] args) {
    App.doWork();//调用doWork方法
    Person p = new Person();    //每次new就表示在堆空间开辟一块空间
    }
    private static void doWork() { 
        int a = 10;
        int b = 20;
    }
}

编辑

当doWork方法被调用时，在栈顶位置分配doWork方法的内存空间，存储局部变量数据。当doWork方法调用结束，doWork方法的栈帧就被销毁，main方法重新回到栈顶位置。堆中存储的都是new出来的对象（数组其实也是对象）。

类的定义

类是拥有相同特性（状态）和行为（功能）的多个事物的抽象描述。类是用来描述群体的，是对群体的抽象描述。在程序中，类就可以作为一种新型的数据类型。可以使用类来声明变量。描述类或者说定义类，就从状态和行为上分析，那么怎么来表示状态和行为呢？

使用成员变量来表示状态

使用成员方法来表示行为

定义语法格式:

public class 类名{
    //可编写0到N个成员变量    
    [修饰符] 数据类型  变量名1; 
    [修饰符] 数据类型  变量名2;
    //可编写0到N个成员方法              
    [修饰符] 返回值类型 方法名称(参数){
        //方法体
    }
}

注意：

(1)成员变量和方法都不能使用static修饰，修饰符是可选用的，都先不使用任何修饰符；

(2)在面向对象设计中，描述对象的类和测试类分开来编写；

(3)在描述对象的类中，不需要定义main方法，专门在测试类中提供main方法。

public class Cat { 
    String name; 
    int age;
    void say() {
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
}

对象操作

对象：

对象是类的一个具体实例，它用于描述一个具体的个体；

对象一定属于某一类，具备该类的特征和行为；

对象是独立的，唯一的个体。

对象基本操作

创建对象

类名 对象变量名 = new  类名();

(1)直接打印对象的时候，打印的是类似于数组一样的hashCode值。

System.out.println(对象变量名);

(2)匿名对象：创建对象之后没有赋给某一个变量，只能使用一次。

new 类名();

对象操作字段（成员变量）

(1)给字段设置数据

对象变量名.字段名 = 值;

(2)获取字段数据

数据类型 变量 = 对象变量名.字段名;

对象调用方法

对象变量名.方法(参数);

测试代码如下：

public class CatDemo {
    public static void main(String[] args) {
        // 1：创建Cat对象,对象的变量名为c 
        Cat c = new Cat();
        // 2:获取字段的值,先看看字段的初始值
        String n = c.name;
        int a = c.age;
        System.out.println("名字=" + n); 
        System.out.println("年龄=" + a);
        // 3：给字段设置值
        c.name = "汤姆"; 
        c.age = 5;
        // 4:设置字段值后，再获取字段的值
        n = c.name;
        a = c.age;
        System.out.println("名字=" + n);
        System.out.println("年龄=" + a);
        // 5:调用对象的方法
        c.say();// 猫说话的功能
    }
}

对象实例化过程-内存分析

创建对象Cat c = new Cat();

编辑

此时通过c对象查看name和age，初始值分别是null和0。

通过对象给字段设置数据 c.name = “Tom”; c.age = 5;

编辑

此时通过c对象查看name和age的值，分别是汤姆和5。

通过对象调用方法 c.say(); System.out.println(name+", "+age);

编辑

say方法调用结束，也就是c.say();代码执行完成。say方法栈帧从栈内存销毁（出栈）后。

类和对象的关系

面向对象思想中有两个非常重要的概念，类和对象，其中:

类（class），是对某一类事务的抽象描述（状态和行为），如下图的抽象女人图。

对象（object），表示现实生活中该类事物的个体，也称之为实例，如下图的每一个具体的女人。类可以看作是对象的数据类型，就好比无论你是谁，只要是女人，那么类型就是女人。

编辑

上图，从左往右看是抽象的过程，从右往左看是实例化的过程，所谓实例化就表示根据类这个模板制造 出每一个对象。

任何事物存在就有一定的功能，在面向对象中，任何事物都可以看成对象，也就是万物皆对象的概念。

注意，在开发中，必须先有类，再使用new关键字根据类来创建出对象。

构造器/构造方法

创建猫对象的时候，代码如下:

Cat c1  = new Cat();

其实这段代码，是在通过调用Cat类的构造器，来创建对象。

构造器，也称之为构造方法（），作用是用来创建对象和给对象做初始化操作。

构造方法的语法和特点：

// 普通方法
[修饰符] 返回值 方法名(参数列表){
}
// 构造方法语法
[修饰符] 类名(参数列表){
}

Cat类的构造器：

public class Cat { 
    //构造器
    public Cat() {
    }
    //省略其他代码
}

注意：

(1)构造器名称和类名相同

(2)不能定义返回类型

(3)构造器中不能使用return语句

默认的构造器

但是我们发现在Cat类中，却找不到该构造器，而在创建对象时却没有报错，这是为什么？如果源文件中没有定义构造器，编译器在编译源文件的时候，会创建一个缺省的构造器。

public class Cat { 
    String name; 
    int age;
    public Cat() {
    }
    void say() {
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
}

默认构造器的特点：无参数、无方法体。

类是否使用public修饰：

使用，则编译器创建的构造器也使用修饰

没有，则编译器创建的构造器也不使用修饰

编辑

通过构造器设置初始值

之前，我们是先通过一个默认参数构造器，先创建出一个对象再初始化（给字段设置值）

Cat c1  = new Cat(); 
c.name = "汤姆";
c.age = 5;

有了构造器之后，可以直接通过构造器同时完成对象创建和初始化操作。

public class Cat { 
    String name; 
    int age;
    public Cat(String n, int a) { 
        name = n;
        age = a;
    }
    void say() {
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
}

注意：当显示定义出构造器之后，编译器不再创建默认的构造了。

Cat c2 = new Cat("加菲", 6); 
c2.say();

因为不再有无参数构造器，之前的创建对象的代码报错。

Cat c = new Cat();  //  此行报错

此时，我们可以在Cat类中同时存在带参数和不带参数的构造器，他们之间的关系就是重载关系。

public class Cat { String name; int age;
    //无参数构造器
    public Cat() {
    }
    //带参数构造器
    public Cat(String n, int a) { 
        name = n;
        age = a;
    }
    //其他代码
}

封装思想

封装是面向对象三大特征之一，其含义有两个：

(1)把对象的字段和方法存放在一个独立的模块中（类）

(2)信息隐藏，尽可能隐藏对象的数据和功能的实现细节

封装的好处:

(1)保证数据的安全性，防止调用者随意修改数据

(2)提高组件的重用性，把公用功能放到一个类中，谁需要该功能，直接调用即可

没有封装带来的困惑：

public class Student{ 
    String name;
    int age;
    void say() {
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
}

测试类：

public class StudentDemo {
    public static void main(String[] args) { 
        Student s = new Student();
        s.name = "张三";
        s.age  =   -12; 
        s.say();
    }
}

此时从代码语法上来看，是没有任何问题的，但是从逻辑上来分析人的年龄怎么能是负数呢？

造成该问题的根本原因就是：可以随意访问对象中的字段。

那么问题来了，怎么才能限制不能随意访问字段数据呢？ 此时，就该访问修饰符登场了！

访问修饰符

车库有一个车位，旁边写着”公共车位”，那么该车位就是公共的，谁都可以访问它。如果我在车位旁边写上“私家车位”，那么该车位就只能是我自己来访问。外界（除我之外）都访问不了，像“公共”、“私有”这种限制外界访问的标记符号，就称之为访问修饰符。

访问修饰符，决定了有没有权限访问某个资源。

封装其实就是要让有些类看不到另外一些类中定义的字段和方法。Java提供了不同的访问权限修饰符来限定类中的成员让谁可以访问到。

编辑

private：表示当前类私有的，类访问权限，只能在本类中操作，离开本类之后就不能直接访问；

不写（缺省）：表示当前包私有，包访问权限，定义和调用只能在同一个包中，才能访问；

protected：表示子类访问权限，同包中的可以访问，即使不同包但是有继承关系也可以访问；

public：表示公共的，可以在当前项目中任何地方访问。

封装使用

使用private修饰了Student类中的字段，此时在测试类中访问报错。

public class Student { 
    private String name;
    private int age;
}

测试类：

public class StudentDemo {
    public static void main(String[] args) { 
        Student s = new Student();
        s.name = "BanQ";    //  此行报错，访问权限不足
        s.age = -21;    //  此行报错，访问权限不足
    }
}

此时使用private修饰字段后，在测试类中不能再操作这些字段了，怎么办？我们可以使用JavaBean的 规范来解决。

JavaBean规范

JavaBean是一种某些符合条件的特殊类，但是必须遵循一定的规范：

(1)类必须使用public修饰

(2)必须保证有公共无参数构造器。即使手动提供了带参数的构造器，也得手动提供无参数构造器

(3)字段使用private修饰(私有化)，每个字段提供一对getter和setter方法

针对名为name的字段名来举例

getter方法：仅仅用于返回某一个字段的值

public String getName(){
    return  name;   //返回name字段存储的值
}

如果操作的字段是boolean类型的，此时是is方法，把 getName 变成 isName。

setter方法：仅仅用来给某一个字段设置值

public void setName(String  n){
    name = n;   //把传过来的参数n的值,存储到name字段中
}

注意：每一个字段都得使用private修饰，并提供一对getter/setter方法。

完整代码如下：

public class Student { 
    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 a) { 
        if(a < 0) {
        System.out.println("非法的年龄");
        return;
        }
        age = a;
    }
}

测试类：

public class StudentDemo {
    public static void main(String[] args) { 
        Student s = new Student();
        // 调用setter方法设置字段数据
        s.setName("BanQ"); 
        s.setAge(21);
        // 调用getter方法获取字段数据
        String n = s.getName(); 
        int a = s.getAge();
        System.out.println(n + "," + a);
    }
}

以上就是Java入门第六天的全部内容了。

资料文档地址：Java开发零基础篇：day06面向对象(一).pdf

相关文章：Java开发零基础篇：day08 面向对象(二)

                  Java开发零基础篇：day09 面向对象(三)

                  Java开发零基础篇：day10 面向对象(四)