面向对象基础、类与对象、封装

一、面向过程、面向对象

面向过程与面向对象都是我们编程中，编写程序的一种思维方式。

面向过程的程序设计方式，是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。用mian方法，一步步实现

面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象，他要怎么做这件事是他自己的事，反正最后一群对象合力能把事就好就行了。用方法实现功能，建立对象调用。

二、类与对象

1、定义类的格式：

public class 类名 {
    //可编写0至n个属性
    数据类型 变量名1；
    数据类型 变量名2；
    
    //可编写0至n个方法
    修饰符 返回值类型 方法名(参数){
        执行语句;
}
}

例：

public class Car {//定义汽车类
    String color;
    int number;

    void run() {//给汽车类定义方法
        System.out.println(color + ":" + number);
    }
}

通过代码的描述，知道类的真正意义就是在描述事物。属性和功能统称为事物中的成员。

事物的成员分为两种：成员属性和成员功能。

成员属性在代码中的体现就是成员变量

成员功能在代码中的体现就是成员方法

2、创建对象的格式：

public class CarDemo {
    public static void main(String[] args) { 
        /*
         *  测试：Car类中的run方法。
         */
        // 1,创建Car的对象。给对象起个名字c。
        Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。
        // 2,通过已有的对象调用该对象的功能。格式：对象.对象成员;
        // 3,可以该对象的属性赋值。
        c.color = "red";
        c.number = 4;
        c.run();
    }
}

3、对象的内存图解

4、类和对象的区别

类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

5、局部变量和成员变量区别

• 区别一：定义的位置不同

定义在类中的变量是成员变量

定义在方法中或者{}语句里面的变量是局部变量

• 区别二：在内存中的位置不同

成员变量存储在堆内存的对象中

局部变量存储在栈内存的方法中

• 区别三：生命周期不同

成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失

局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失

• 区别四：初始化不同

成员变量因为在堆内存中，所有默认的初始化值

局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。

6、基本类型和引用类型作为参数传递

引用类型数据和基本类型数据作为参数传递有没有差别呢？我们用如下代码进行说明，并配合图解让大家更加清晰

class Demo { public static void main(String[] args) { int x = 4; show(x); System.out.println("x="+x); } public static void show(int x) { x = 5;   } }

基本类型作为参数传递时，其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show()，当在show()方法中x接受到了复制的值，再在show()方法中对x变量进行操作，这时只会影响到show中的x。当show方法执行完成，弹栈后，程序又回到main方法执行，main方法中的x值还是原来的值。

 

class Demo { int x ; public static void main(String[] args) {   Demo d = new Demo(); d.x = 5; show(d); System.out.println("x="+d.x); } public static void show(Demo d) { d.x = 6; } }

 

当引用变量作为参数传递时，这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的d.x=6时，会根据d所持有的引用找到堆中的对象，并将其x属性的值改为6.show方法弹栈。

由于是两个引用指向同一个对象，不管是哪一个引用改变了引用的所指向的对象的中的值，其他引用再次使用都是改变后的值。

三、封装

封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。接下来我们具体学习封装。

 封装表现：

1、方法就是一个最基本封装体。

2、类其实也是一个封装体。

从以上两点得出结论，封装的好处：

1、提高了代码的复用性。

2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3、提高了安全性。

 1、 私有private

把变量还有方法私有化，外界不能访问，只能在本类中访问；

 例：

class Person {
    int age;
    String name;

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

public class PersonDemo {
    public static void main(String[] args) {
        // 创建Person对象
        Person p = new Person();
        p.age = -20; // 给Person对象赋值
        p.name = "人妖";
        p.show(); // 调用Person的show方法
    }
}

通过上述代码发现，虽然我们用Java代码把Person描述清楚了，但有个严重的问题，就是Person中的属性的行为可以任意访问和使用。这明显不符合实际需求。

可是怎么才能不让访问呢？需要使用一个Java中的关键字也是一个修饰符 private(私有，权限修饰符)。只要将Person的属性和行为私有起来，这样就无法直接访问。

class Person {
    private int age;//定义私有变量
    private String name;//定义私有变量

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

年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，这样还是不行，那肿么办呢？按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。只要对外提供可以访问的方法，让其他程序访问这些方法。同时在方法中可以对数据进行验证。

一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。

class Person {
    // 私有成员变量
    private int age;
    private String name;

    // 对外提供设置成员变量的方法
    public void setAge(int a) {
        // 由于是设置成员变量的值，这里可以加入数据的验证
        if (a < 0 || a > 130) {
            System.out.println(a + "不符合年龄的数据范围");
            return;
        }
        age = a; 
    }

    // 对外提供访问成员变量的方法
    public void getAge() {
        return age;
    }

2、 this关键字

成员变量和局部变量同名问题

当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量

class Person {
    private int age;
    private String name;
    
    public void speak() {
        this.name = "小强";
        this.age = 18;
        System.out.println("name=" + this.name + ",age=" + this.age);
    }
}

class PersonDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.speak();
    }

 对象的内存解释

class Person {
    private int age;
    public int getAge() {
        return this.age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
public class PersonDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(30);
        System.out.println("大家好，今年我" + p.getAge() + "岁");
    }
}

图解：

程序执行流程说明：

1、 先执行main方法（压栈），执行其中的 Person p = new Person()；

2、 在堆内存中开辟空间，并为其分配内存地址0x1234，紧接着成员变量默认初始化(age = 0)；将内存地址0x1234赋值给栈内中的Person p 变量

3、 继续执行p.setAge(30)语句，这时会调用setAge(int age)方法，将30赋值为setAge方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；

4、 setAge()方法执行完毕后（弹栈），回到main()方法，执行输出语句System.out.println()，控制台打印p对象中的age年龄值。

注意：

 this到底代表什么呢？this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在的方法，this就代表哪个对象。

上述代码中的 p.setAge(30)语句中，setAge(int age)方法中的this代表的就是p对象。

 

例：需求：在Person类中定义功能，判断两个人是否是同龄人

class Person {
    private int age;
    private String name;
    
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public void speak() {
        System.out.println("name=" + this.name + ",age=" + this.age);
    }

    // 判断是否为同龄人
    public boolean equalsAge(Person p) {
        // 使用当前调用该equalsAge方法对象的age和传递进来p的age进行比较
        // 由于无法确定具体是哪一个对象调用equalsAge方法，这里就可以使用this来代替
        /*
         * if(this.age == p.age) { return true; } return false;
         */
        return this.age == p.age;
    }
}