7.类与对象（面向对象）

第二部分面向对象

7.1 面向对象和面向对象思想

一、面向过程编程思想

个人理解：
通俗地讲，我们在编写代码时，我们看到是一步一步执行的过程——即面向过程。 最典型的就是c语言，其实就是通过函数体现，并不断的调用函数，执行完成过程即可。
当我们解决一个问题时，最简单的解决思路是面向过程解决：

1、关注过程，将大问题拆解为小问题，实现每个小问题的解决方法
2、通过控制代码，控制模块执行，问题解决。

虽然面向过程编程思想可能看起来比较笨拙，可能会造成代码臃肿，但是它却是最贴近硬件的，CPU在执行指令的时候就是按照一条一条指令执行下去的。

二、面向对象编程思想

要了解面向对象，我们首先需要知道什么是对象？

1、对象和类

万事万物都是对象，对象是自然界的任一个体，比如一本书、一支笔，一片叶子等，而对象和对象间是有相似之处的，比如书（每本书都是一个对象）都是由纸做成的，都印着内容（性质上的相似点），都是用来看的（行为上的相似点），将这些相似之处抽象出来就是类（抽象这个词很难懂，那么说成是分类、提取出事物的共同要素更易理解），类的实例就是对象。

2、面向对象编程思想

当遇到一些简单的程序或者逻辑时，我们可以使用面向过程的编程思想，当问题的规模稍大时，我们就需要用到面向对象的编程思想了

三、面向过程和面向对象编程的区别

（1）面向过程的思维方式是分析综合。面向对象的思维方式是构造
（2）对面向过程而言，数据是独立的。而在面向对象中，对象本身就提供了存储数据的空间（类的数据成员），这样就是函数的参数传递简单多了，而且提供了数据封装后，数据的访问也变可靠了。
（3）面向过程就是将编程当成是做一件事，要按步骤完成，每一步就是一个过程。面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。
（4）面向过程是一种自顶向下的编程。面向对象是自下先建立抽象模型然后再使用模型。

7.2类与对象关系

类是对象的定义，对象从类创建

对象

对象的状态（也称为属性是由具有当前值的数据域来表示的。例如：圆对象具有一个数据域 radius, 它是标识圆的属性。
一个矩形对象具有数据域 width 和 height, 它们都是描述矩形的属性。

对象的行为（behavior, 也称为动作（action))是由方法定义的。调用对象的一个方法就是要求对象完成一个动作。
例如：可以为圆对象定义一个名为 getAreaO和 getPerimeter() 的 方 法。
圆 对 象 可 以 调 用 getArea() 返 回 圆 的 面 积，调用getPerimeter() 返回它的周长。还可以定义setRadius(radius) 方法。圆对象可以调用这个方法来修改它的半径。

类

类是一个模板、蓝本或者说是合约，用来定义对象的数据域是什么以及方法是做什么的；一个对象是类的一个实例

不可变对象和类

要点提示：可以定义不可变类来产生不可变对象。不可变对象的内容不能被改变

通常，创建一个对象后，它的内容是允许之后改变的。有时候也需要创建一个一旦创建其内容就不能再改变的对象。我们称这种对象为一个不可变对象（ immutable object), 而它的类就称为不可变类（immutable class).

7.3 封装与private关键字

为了避免对数据域的直接修改，应该使用 Private 修饰符将数据域声明为私有的，这称为数据域封装
封装的对象：
1.函数
2.类

封装有什么好处？
提高了安全性
向外界隐藏了一些不需要被外界获知的内容
提高了代码的复用性
封装也是面向对象的三大特点之一

private关键字

private关键字，属于权限关键字

还有权限关键字有：
public
protected
默认不写
private

private用于修饰成员变量和成员方法.
私有是针对类,而不是针对对象,也就是说,同一个类的所有的不同的对象之间,可以互相访问别的对象的的私有的成员.
被私有化的成员只在本类中有效.

private可以作用在对象属性和行为上，外界在创建对象后，则不能访问被private修饰的内容

7.4 局部变量与成员变量

局部变量和成员变量有什么区别？

生命周期
成员变量随着对象的创建而创建，随着对象的消亡而消失

局部变量随着函数的进栈而创建，随着函数的出栈而消失

存储位置
成员变量在堆内存中对象所属空间里

局部变量在栈内存中函数所属空间里

定义位置
成员函数在类中，函数外定义

局部变量在函数中定义

初始化
成员变量有默认初始化

局部变量必须初始化之后再调用

public class Sample {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.setName("小强");
		p1.setAge(10);
		p1.speak();
	}
}
class Person {
	private String name;
	private int age;
	public void speak() {
		System.out.println("我是" + name + ",我今年" + age + "岁");
	}
	public void setName(String name) {
		if (name.equals("旺财")) {
			this.name = "哈士奇";
		} else {
			this.name = name;
		}
	}
	public void setAge(int age) {
		if (age < 0) {
			this.age = 0;
		} else {
			this.age = age;
		}
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
}

代码执行流程：

1.javac 编译Sample.java源代码 生成Sample.class和Person.class两个字节码文件
2.如果java Person ，运行Person字节码文件，则报错，没有主函数不是主类
3.只能java Sample 运行Sample程序
4.将相关的字节码（Sample.class Person.class）文件加载进JVM中内存下的方法区
5.在方法区中Sample字节码所在的区域里，找主函数，将主函数的栈帧加载进栈内存开始运行
6.开始执行主函数的第一句代码，创建Person对象
7.在堆内存中开辟一个空间并分配地址，在该空间中创建成员变量并默认初始化
8.在主函数空间中创建局部变量p1，并将该对象的地址传给p1
9.接着执行主函数第二句代码，调用p1对象的setName方法
10.从方法区中的Person里，将setName函数栈帧加载进栈，主函数暂停运行
11.setName进栈后，创建局部变量name（形参），并将实参“小强”这个字符串在字符串常量池中的地址赋予name
12.因为setName成员函数只有一份在方法区中Person所属区间里，之后可以被多个同类对象调用，为了区分到底是哪个对象调用的该方法，所以在每一个成员函数中，都会有一个隐藏的关键字数据 this ,this相当于一个变量来存储当前对象的地址。（当前对象的引用）
13.执行setName中的内容，如果数据没有问题的话，就将局部变量的值赋值个当前对象的成员
变量
14.setName函数执行最后一行隐藏的return，表示函数结束并弹栈
15主函数成为当前栈顶，继续执行
16执行p1调用setAge函数，从方法区中Person所属空间里找setAge这一段代码，将该函数栈帧加载进栈内存成为新的栈顶，则主函数暂停，该函数运行。先创建形参age的局部变量，接收实
参传来的值10，为了区分对象的调用关系，自带this关键字数据，this存的还是p1的地址，如果age没有问题，则将10传给this所指向的对象中age这个成员变量。setAge执行最后一行隐藏的return，表示函数结束并弹栈
17主函数称为新的栈顶继续执行，调用p1的speak函数进栈
18在方法区中Person字节码所属空间里读取speak代码，将该栈帧加载进栈内存中，主函数暂停，该函数执行，无形参只能表示没有形参的局部变量，但是在函数内部也可以创建其他的局部变量，并且有this关键数据存的是p1的地址，然后去打印name和age，由于speak空间中已经没有其他名为name或age的局部变量，所以找不到，接着找this对象中的数据，找到了则打印。直至函数结束并弹栈
19主函数又称为栈顶，也没有代码了，执行隐藏的return，主函数弹栈，表示程序结束。

7.5 构造函数

构造函数：构造函数主要是在创建对象的时候执行的函数，在该函数中也可对成员变量进行一些操作。
构造方法必须具备和所在类相同的名字。
• 构造方法没有返回值类型，甚至连 void 也没有。
• 构造方法是在创建一个对象使用 new 操作符时调用的。构造方法的作用是初始化对象。
• 构造方法具有和定义它的类完全相同的名字。和所有其他方法一样，构造方法也可以重
载（也就是说，可以有多个同名的构造方法，但它们要有不同的签名），这样更易于用不同
的初始数据值来构造对象

构造函数的格式

权限修饰符 类名(参数列表) {
	构造函数的代码块
}

构造函数没有返回值
构造函数的名称必须是类名
参数列表可选的，构造函数是可以重载的
虽然构造函数没有返回值，还是存在return关键字的
当我们的类中没有定义任何构造函数时，会有一个默认隐藏的无参构造函数存在
构造函数和成员函数一样，为了区分对象的调用，构造函数自带this关键字数据

构造函数需要注意的问题

如果一旦定义其他参数列表的构造函数的话，这个隐藏的无参构造函数就会消失，所建议手写出来

构造函数只有在创建对象的时候执行，当对象创建完毕之后，该对象的构造函数则不能执行

成员函数只有在对象创建之后才能执行

成员函数能否直接调用构造函数？不能够的，报找不到符号错误 会误认为是同名的成员函数

构造函数能否直接调用成员函数呢？能够，但是 这些成员函数一般是构造函数的部分代码片段被切割出来了而已，从语意上而言，不属于对象的特有行为（也有特例），所以这些函数长得样子就是
成员函数的样子，但没有必要向外界提供访问，所以加上private

构造函数能否直接调用构造函数呢？可以，但是必须通过 this(参数列表) ，需要注意的是，构造函数可以单向调用其他构造函数，但坚决不能出现回调。

构造函数是在创建对象的时候执行的，可以在期间对成员变量进行初始化，问：setXXX还需要不？看需求，如果后期成员变量需要修改，则提供setXXX修改器

关于成员变量初始化的问题

成员变量的初始化经历了三个步骤：默认初始化（大家默认都是0值），显式初始化（大家的值都一样），针对性初始化（大家的值可选）

7.6 对象的创建流程及内存图解

示例：定义一个栈

public class Sample{
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.pop();
        System.out.println(stack);
        for(int i=1; i<=10;i++){
            stack.push(i);
        }
        System.out.println(stack);
        stack.pop();
        System.out.println(stack);
        System.out.println(stack.peek());
        stack.clear();
        System.out.println(stack);
        System.out.println(stack.peek());
    }
}
class Stack{
    private int[] data;
    private int top = -1;
    private static int capacity = 10;

    public Stack() {
        this(capacity);
    }

    public Stack(int capacity) {
        data = new int[capacity];
    }

    public void push(int e){
        if(size() == data.length) {
            reSize(data.length);
        }
        data[++top] = e;
    }


    public void reSize(int length){
        int[] arr = new int[length * 2];
        for(int i=0; i<= top; i++) {
            arr[i] = data[i];
        }
        data = arr;
    }
    public int pop(){
        if(isEmpty()){
            System.out.println(">>>栈为空，弹不出元素了！");
            return -1;
        }
        int e = data[top];
        top--;
        if(data.length > capacity && size() == data.length / 4) {
            reSize(data.length / 2);
        }
        return e;
    }

    public void clear(){
        top = -1;
        data = new int[10];
    }
    public int peek(){
        if(isEmpty()){
            System.out.println(">>>栈为空，无栈顶元素！");
            return -1;
        }
        return data[top];
    }




    public boolean isEmpty(){
        return top == -1;
    }

    public int size() {
        return top + 1;
    }

    public String toString() {
        if(isEmpty()){
            return "[]";
        }
        String s = "[";
        for(int i=0; i <= top; i++) {
            if(i == top){
                s += data[i] + "]";
            }else{
                s += data[i] + ", ";
            }
        }
        return s;
    }

}

7.7 static关键字

主要用于：修饰成员变量（对象的特有属性）和成员函数，变为静态变量和静态函数

静态变量的特点：同类下多个对象之间的共有属性
被static修饰的变量、被static修饰的方法统一属于类的静态资源，是类实例之间共享的

静态变量的定义时机：在同一类下，多个对象之间有相同的属性和值，那么就可以将该属性和值从成员变量变为静态变量，目的就是为了节省空间。

静态函数的定义时机：当一个成员函数不访问成员时，即可定义为静态函数！

静态函数一旦定义出来，可以直接用类名去调用,当然也可以通过创建对象来去调用静态函数！
静态优先于对象存在，且在同一类中，静态无法访问非静态（成员），非静态是可以访问静态
静态函数中不存在this()
1.当通过对象去调用一个属性时，先找成员，再找静态，最后找父类
2.如果从成员函数中去调用一个属性时，先找局部，再找成员，再找静态，最后找父类

好处：

1.节省堆内存中的空间
2.可以不用费力气去创建对象来调用功能
3.可以对类进行一些初始操作（结合代码块来做）

7.8 静态变量与成员变量

一个类的实例变量和静态变量称为类变量（class’s variables)或教据域（ data field)。
在方法内部定义的变量称为局部变量。
无论在何处声明，类变量的作用域都是整个类。类的变量和方法可以在类中以任意顺序出现

如果一个局部变量和一个静态变量具有相同的名字，那么局部变量优先. 而同名的类变量将被隐藏

为避免混淆和错误，除了方法中的参數，不要将实例变量或静态变量的名字作为局
部变量名。

静态变量与成员变量区别

存储位置

成员变量存储在堆内存中对象所属空间里
静态变量存储在静态方法区中对应的字节码空间里
生命周期

成员变量随着对象的创建而创建，随着对象的消亡而消亡
静态变量随着类的加载而存在，随着程序的结束而消失
所属不同

成员变量属于对象的，称之为是对象的特有属性
静态变量属于类的，称之为是类的属性，或者叫对象的共有属性
调用方式不同

成员变量在外界必须通过创建对象来调用，内部的话成员函数可以直接调用成员变量，但是静态函数不能直接调用成员变量，如果非要在静态函数中调用成员的话，只能创建对象，通过对象来调用

静态变量在外界可以通过对象调用，也可以通过类来调用，内部的话静态函数/成员函数可以调用静态变量