JAVA之面向对象

数组几种情况的内存图

1、一个数组的内存图

2、两个数组的内存图

3、两个引用指向同一个数组的内存图

一、什么是面向对象？

面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲力亲为，详细处理每一个细节。
面向过程：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事。简单来说就是“偷懒”，功能已经有了找一个人帮我们做事。

举例：
洗衣服：

• 面向过程：把衣服脱下来–>找个盆–>放点洗衣粉–>加点水–>浸泡十分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
• 面向过程：把衣服脱下来–>打开洗衣机->扔衣服–>按钮–>晾起来

区别：

• 面向过程：强调步骤
• 面向对象：强调对象，三大特点 【封装性，继承性，多态性】

面向过程如下：

//要求打印出数组，格式为：[arr1,arr2,arr3]
        int[] array = { 10, 20, 30, 40, 50 };
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            }else {
                System.out.print(array[i] + ",");
            }
        }

面向对象如下：

System.out.println(Arrays.toString(array));

面向对象就是找一个JDK给我们提供的Arrays类，其中有一个toString类，直接就能把数组变成想要的格式的字符串。

二、成员变量和成员方法

1、成员变量和成员方法的定义

package test;


/**
 * 注意事项：
 * 1、成员变量直接定义在类当中，在方法外边
 * 2、成员方法不要写 static 关键字
 */

public class Student {
    //成员变量
    String name;
    int age;
    //成员方法
    public void eat() {
        System.out.println("吃饭饭！");
    }

    public void sleep() {
        System.out.println("睡觉觉！");
    }

    public void study() {
        System.out.println("学习！");
    }
}

2、成员变量和成员方法的调用

package test;
/**1、导包：也就是需要使用的类在什么位置
 * 格式：import 包名称.类名称
 * 对于和当前类在一个包的情况下，可以省略包不写
 *
 * 2、通常情况下，一个类不能直接使用，需要创建一个对象
 * 格式：类名称 对象名 = new 类名称()
 *
 * 3、使用，分为两种情况：
 * 使用成员变量：对象名.成员变量名
 * 使用成员方法：对象名.成员方法名(参数)
 * 也就是说想要使用谁，就【对象名.谁】
 *
 * 注意事项：
 * 如果成员变量没有进行赋值，那么会有一个默认值，规则和数组一样
 * 整型   默认值为 0
 * 浮点型  默认值为 0.0
 * 字符型  默认值为 '\n0000'
 * 引用型  默认值为 null
 */


public class Student01 {
    public static void main(String[] args) {
        //1、导包

        //2、创建一个对象名为 stu 对象
        Student stu = new Student();

        //3、使用成员变量，并赋值
        stu.name = "123";
        stu.age = 20;
        System.out.println("姓名为：" + stu.name);
        System.out.println("年龄为：" + stu.age);

        //4、使用成员方法
        stu.eat();
        stu.sleep();
        stu.study();
    }

}

栈（Stack）：运行的方法必须进栈（先进后出）
堆（Heap）：只要是 new 实例化的东西全保存在堆内存中
方法区（Method Area）：保存的是 .class

①、一个对象的内存图如下：

②、两个对象的内存图如下：

③、两个引用指向了同一个对象内存图如下：

④、使用对象类型作为方法的参数内存图如下：

⑤、使用对象类型作为方法的返回值内存图如下：

3、成员变量和局部变量的区别

①、定义的位置不同【重点】
局部变量：在方法的内部定义
成员变量：在方法的外部，直接写在类当中
②、作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法体就不能使用
成员变量：可以在这个类的任何位置使用
③、默认值不一样【重点】
局部变量：没有默认值，如果想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
④、内存的位置不一样【了解】
局部变量：位于栈内存当中
成员变量：位于堆内存当中
⑤、生命周期不一样【了解】
局部变量：随着方法进栈而诞生，出栈而消失
成员变量：随着对象创建二诞生，对象被垃圾回收而消失

三、封装性

面向对象的三大特征：封装、继承、多态

封装性在Java中的调体现：
①、方法就是一种封装
②、关键字 private 也是一种封装

1、封装就是把一些细节信息隐藏起来，对于外界不可见。

成员方法的定义：

package test;
/**
 * 问题定义：定义 person 的年龄时，限制年龄必须大于0
 * 解决方法：用 private 关键字将需要保护的成员变量修饰
 *
 * 一旦使用 private 进行修饰之后，name本类当中仍然可以随意访问
 *
 * 间接访问 private 成员变量，就是定义一对 Getter/Setter 方法。对于Getter来说，不能有参数，返回类型必须和成员变量对应。对于Setter来说，不能有返回值，参数类型和成员变量对应。
 */

public class Method {
    //定义成员变量
    String name;
    private int age;

    //定义成员方法
    public void show() {
        System.out.println("我叫：" + name + "，年龄：" + age);
    }

    //一旦被private修饰，必须使用 Setter/Getter 方法
    public void setAge(int num) {
        if (num > 100 || num < 0) {
            System.out.println("输入的年龄不合法！！");
        } else {
            age = num;
        }
    }

    public int getAge() {
        return age;
    }
}

成员方法的调用：

package test;

public class Method01 {

    public static void main(String[] args) {
        //实例化
        Method person = new Method();

        person.show();

        //给成员变量赋值
        person.name = "仓央";
        person.setAge(120);

        person.show();

    }
}

特例：对于基本类型中的 boolean 值，Getter方法一定要写成isXxx的形式，二setXxx不用变。

2、this关键字（在重名的情况下起到区别的作用）
当方法的局部变量和类的成员重名的时候，根据“ 就近原则 ”，有限使用局部变量。如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名“通过谁调用的方法，谁就是this”

3、构造方法
构造方法就是专门用来创建对象的方法。格式：
public 类名称(参数类型 参数名称){
方法体
}

注意事项：
①、构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
②、构造方法不要写返回类型，连 void 也不要写
③、构造方法不能 return 一个具体的返回值
④、如果没有编写任何构造方法，那么编译器就会默认创建一个空的构造方法
⑤、一旦编写了至少一个构造方法，那么编译器将不再创建
⑥、构造方法可以重载【方法名相同，参数不同】

package test;
/**
 * 1、构造方法的名称必须和类型称一样
 * 2、构造方法不要写返回类型，连 void 也不要写
 * 3、构造方法不能 return 一个具体的返回值
 * 4、如果没有编写任何构造方法，那么编译器就会默认创建一个空的构造方法
 * 5、一旦编写了至少一个构造方法，那么编译器将不再创建
 * 6、构造方法可以重载【方法名相同，参数不同】
 */

public class StructureMethod {

    private String name;
    private int age;

    //定义一个无参构造方法
    public StructureMethod () {
        System.out.println("无参构造方法的执行");
    }

    //定义一个全参构造方法
    public StructureMethod (String name, int age) {
        System.out.println("全参构造方法的执行");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

四、继承性

1、概述 ：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，兔子属于食草动物，食草动物属于动 物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。

2、好处 ：
①. 提高代码的复用性。
②. 类与类之间产生了关系，是多态的前提。

3、继承的格式
通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
	 ...     
}  
  
class 子类 extends 父类 {
	...
}

4、注意事项
java.lang.Object 是整个继承中的祖宗类
Java是单继承：一个类的直接父类只能有一个。
可以多级继承：父类还有一个父类。
多个子类可以共同继承一个父类。

如果父类当中的方法不确定如何进行方法体，那么这就是一个抽象方法。
抽象方法：加上 abstract 关键字，然后去掉大括号，直接分好结束。
抽象类：抽象方法所在的类，必须是抽象类，在class之前加上 abstract。

如何使用抽象类和抽象方法：
①、不能直接创建 new 抽象类对象。
②、必须用一个子类继承抽象类
③、子类必须覆盖重写父类所有的 abstract 抽象方法
④、创建子类对象进行使用

五、接口

接口：多个类公共的规范标准。
接口是一种引用数据类型，最重要的内容是抽象方法。

如果是JAVA 7，name接口中可以包含的内容有：
1、常量
2、抽象方法

如果是JAVA 8，还可以额外包含：
3、静态方法：被 static 修饰的方法
public static 返回值 方法名(参数列表) {
…
}
使用方式：接口名称.方法名

4、默认方法：为了解决接口升级的问题
public default 返回值 方法名(参数列表) {
…
}
注意事项：
接口的默认方法可以被接口实现类对象直接调用，或者被接口实现类覆盖重写

如果是JAVA 9，还可以额外包含：
5、私有方法：解决默认方法之间重复代码的问题
5.1、普通私有化，解决多个默认方法之间重复代码问题
格式：
private 返回值 方法名(参数列表) {
…
}
5.2、静态私有化：解决多个静态之间重复代码问题
private static 返回值 方法名(参数列表) {
…
}

接口使用步骤：
1、接口不能直接使用，必须有一个“实现类”来实现该接口
格式：
public class 实现类名称 implements 接口名称(参数列表) {
…
}
2、接口中的实现类必须覆盖重写所有的抽象方法
3、创建实现类的对象进行使用

注意事项：
如果没有将所有的抽象方法全部覆盖重写，那么这个类就必须是抽象类。

定义抽象方法的格式：
public abstract 返回值类型 方法名称(参数列表);

注意事项：
1、接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2、这两个关键字修饰符，可以选择性地省略。

接口中也可以定义常量，但是必须用 public static final 进行修饰

注意事项：
1、一旦使用final修饰之后不可变，public static final 可以默认不写
2、接口当中的常量必须赋值
3、接口中常量名称，使用完全大写的字母，用下划线进行分割

六、多态性

多态性：父类引用指向子类对象

格式：
父类名称 对象名 = new 子类名称();
接口名称 对象名 = new 实现类名称();

好处：
1、无论右边new的时候换成哪个子类对象，等号左边调用方法不变

多态中成员变量的访问规则：
1、直接通过对象名称访问成员变量：等号左边是谁就优先用谁，没有则向上找
2、间接通过成员方法访问成员变量：看该方法属于谁，就优先用谁，没有则向上找

多态中成员方法的访问规则：
看new的是谁就优先用谁，没有则向上找。
口诀：编译看左边，运行看右边。

1、对象的向上转型：就是父类引用指向子类对象，向上转型一定是安全的
一旦向上转型为父类，那么就无法使用子类原本特有的方法
相当于自动类型转换

2、对象的向下转型：其实就是一个【还原】的过程
格式：子类名称 对象名 = (子类名称) 父类对象;
含义：将父类对象，【还原】成原来的子类对象。
相当于强制类型转换

七、final关键字

1、当final修饰一个类的时候，这个类不能被继承
格式：
public final class 类名 {
// …
}

注意：一个类如果是final类，那么其中所有的成员都无法被覆盖重写；
但是其父类的成员可以被覆盖重写

2、当final修饰一个成员方法，这个方法不能被覆盖重写
格式：
public final void 方法名 {
// …
}

注意事项：
对于类、方法来说，abstract和final不能同时使用

3、当final修饰一个局部变量，这个变量不能进行更改【一次赋值，终身不变】
对于基本数据类型，不可变指的是变量当中的值
对于引用数据类型，不可变指的是变量当中的地址

4、当final修饰一个成员变量，这个变量不能进行更改

注意事项：
1、由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
2、对于final的成员变量，要么直接赋值，要么通过构造方法赋值
3、必须保证类当中的所有构造方法，都会最终被赋值