十、面向对象

编程语言有面向对象（Java，Python）和面向过程（C语言）之分，面向对象需要一些抽象的思维才行。

面向过程和面向对象有什么区别呢？

面向过程注重亲力亲为，意思也就是自己去干这件事；而面向对象更倾向于找个人给自己做事。

就拿那个老生常谈的例子来说吧——洗衣服：

1.面向过程

面向过程的洗衣服是「每次洗衣服都需要」：

1. 把衣服拿到洗衣机旁边
2. 放进去
3. 等待
4. 捞出来

等下一次洗衣服，你还得重复这些操作

2.面向对象

而面向对象则是：

1. 创造一个机器人

2. 教他如何洗衣服

   1. 把衣服拿到洗衣机旁边
   2. 放进去
   3. 等待
   4. 捞出来

3. 让他去干活

等下一次需要洗衣服，就让机器人去干，我们只需要歇着就行了

而面向对象绕不开的就是类和对象了，接着往下看吧

3.类

那么什么是类呢？类，分门别类的类，类别的类，人“类”就是我们现实生活中的一个类，而每一个人就是一个对象。

对象就是特殊个体，类就是一般个体，可能还是不那么好理解，我就再详细点

“我认识一个叫做丸子的女孩”——这句话中，丸子就是对象，代表一个真正的人，具体的人；而女孩就是类，代表一个抽象的东西，一个笼盖所有女孩的类别。

3.1自定义类

把具有相同特征的一些东西/事物分门别类，我们自己造一个名字

好，我们现在造一个火柴盒妹子类，用比较艺术化的话来说就是：只具其形，不具其神！

class Girl{
    
}

好了，这就是我们的女孩类，是不是感觉啥都没有，不对不对，Java类中有一个默认的东西，叫做「构造方法」，「构造方法」，「构造方法」，重要的事情说三遍！ 构造方法：实例化对象时，自动调用，默认会存在一个无参数的构造方法

1. 无参构造方法

默认构造方法，只用于创建实例化对象，无法接受参数

public class Ec4_19 {
    public static void main(String[] args) {
        Girl girl = new Girl();
        System.out.println(girl);  //Girl@4517d9a3，返回的是内存地址
    }
}
class Girl{

}

2. 有参构造方法

Java类中可以创建多个构造函数，但是参数和返回类型不能相同，这种情况叫做重载，意思就是你可以创建很多个构造函数

public class Ec4_19 {
    public static void main(String[] args) {
        Girl girl = new Girl();
        Girl girl1 = new Girl("Jecy");
    }
}
class Girl{
    Girl(String name){
        System.out.println("有参构造函数"+"  "+name);
    }
    Girl(){
        System.out.println("无参构造函数");
    }
}
/*
输出结果为：
无参构造函数
有参构造函数  Jecy
*/

应该已经了解构造函数了吧，啊，这个实在想不出来什么骚话来形容~~

3.2类的属性

类中有属性，分为成员变量，局部变量和类变量 在我们创建的女孩类中，属性就是女孩们的诸如身材，相貌等的东西，当然，像什么年龄名字的，也是必须有的，不过不同的属性有不同的作用，所以属性也分上面三种

1.成员变量

在类中，方法外定义，在实例化对象时创建，并可以被实例化对象拿去用(赋值，修改)，不多说，看代码

public class Ec4_19 {
    public static void main(String[] args) {
        Girl girl = new Girl(); //实例化对象
        girl.age = 10;  //调用 设置成员变量值
        girl.name = "Jeccy";  //调用 设置成员变量值
        System.out.printf("%s今年%d岁了",girl.name, girl.age);
    }
}
class Girl{
    public int age;
    public String name;
}
/*
输出结果为：
Jeccy今年10岁了
*/

2. 局部变量

在方法中定义，作用于在定义的方法中，也就是说只在该方法中能够使用，比如在构造方法中的变量，就无法通过实例化的对象调用

public class Ec4_19 {
    public static void main(String[] args) {
        Girl girl = new Girl(10,"Jeccy");  //用有参构造方法实例化对象
        System.out.printf("%s今年%d岁了",girl.name, girl.age);
    }
}
class Girl{
    public int age;  //成员变量
    public String name;  //成员变量
    Girl(int a, String n){
        age = a;  //局部变量，无法通过实例化对象直接调用
        name = n;  //局部变量
    }
}
/*
输出结果为：
Jeccy今年10岁了
*/

3. 类变量

需要通过static修饰符修饰，可以直接通过类名调用

public class Ec4_19 {
    public static void main(String[] args) {
        Girl.name = "西施";
        Girl.age = 10;
        System.out.printf("%s今年%d岁了",Girl.name, Girl.age);
    }
}
class Girl{
    public static int age;
    public static String name;
}
/*
运行结果：
西施今年10岁了
*/

4. 私有属性

无法被外界访问的属性，就是私有属性，就像女孩们有些东西不会被别人知道一样（比如三围之类的啦）

public class Ec4_19 {
    public static void main(String[] args) {
        Girl.name = "西施";
        Girl.age = 10;
        System.out.printf("%s今年%d岁了",Girl.name, Girl.age);
    }
}
class Girl{
    private static int age;
    private static String name;
}
/*
这样写，就算是定义的静态方法，但是因为是私有的，也无法被访问
运行会报错
*/

3.3类的动作/方法

行为就是方法，一般来说，Java类的规范写法是为每个属性设置一个setXxx方法，一个getXxx方法，并且将每个属性设为私有方法 就像这样：这是一般的规范写法

public class Ec4_19 {
    public static void main(String[] args) {
        Girl girl = new Girl();
        girl.setAge(10);
        girl.setName("Jerry");
        System.out.printf("%s今年%d岁了", girl.getName(), girl.getAge());
    }
}
class Girl{
    private int age;
    private String name;
    void setName(String name){
        this.name = name;
    }
    String getName(){
        return name;
    }
    void setAge(int age){
        this.age = age;
    }
    int getAge(){
        return age;
    }

}

当然，也有别的普通的方法，比如妹子会撒娇，会打游戏之类的

public class Ec4_19 {
    public static void main(String[] args) {
        Girl girl = new Girl();
        girl.setAge(10);
        girl.setName("Jerry");
        girl.playGame();
        System.out.println("");
        girl.coqutry();
        System.out.printf("%s今年%d岁了", girl.getName(), girl.getAge());
    }
}
class Girl{
    private int age;
    private String name;
    void setName(String name){
        this.name = name;
    }
    String getName(){
        return name;
    }
    void setAge(int age){
        this.age = age;
    }
    int getAge(){
        return age;
    }
    void playGame(){
        System.out.printf("%s打游戏很厉害", name);
    }
    void coqutry(){
        System.out.println("哥哥不要这样啦，人家害怕啦~~~");
    }

}
/*
运行结果：
Jerry打游戏很厉害
哥哥不要这样啦，人家害怕啦~~~
Jerry今年10岁了
*/

3.4继承

继承就是我们的孩子，有我们造的妹子的特性，比如说：孩子长得像他妈妈啦，性格像她妈妈啦之类的

虽然在Java中，被继承的类叫做父类，但是我们也是可以这么理解的~

后面我就叫做母类了，emmm原谅我，我只是觉得这样更好听一点

当然，Java中，类的继承只支持单继承

public class Ex4_22 {
    public static void main(String[] args) {
        Child ch = new Child();
        ch.setAge(10);
        int age = ch.getAge();
        System.out.println("孩子的年龄是："+age);
        System.out.println("孩子会撒娇");
        ch.coqutry();
    }
}
class Child extends Girl{
    /*
    孩子继承了妈妈的特性
    */
}
/*
运行结果：
孩子的年龄是：10
孩子会撒娇
哥哥不要这样啦，人家害怕啦~~~
*/

3.5重写与重载

1. 重写

就是我们的孩子虽然已经继承了妈妈的东西，但是有些东西总不能是完全一样的

这个时候就要重写操作，可以将母类的东西改变，延伸

当然，我们的重写必须是跟母类的形参和返回值是相同的、、、

public class Ex4_22 {
    public static void main(String[] args) {
        Child ch = new Child();
        ch.setAge(10);
        int age = ch.getAge();
        System.out.println("孩子的年龄是："+age);
        System.out.println("孩子会撒娇");
        ch.coqutry();
    }
}
class Child extends Girl{
    public void coqutry(){
        System.out.println("粑粑，我好爱你哦~~~");
    }
}
/*
运行结果：
孩子的年龄是：10
孩子会撒娇
粑粑，我好爱你哦~~~
*/

2. 重载

重载是构造方法的重载，之前说过就不说了

3.6封装

还记不记得我之前说过的规范

一般将属性设置为private，私有类型，无法被外界的访问

而对于这样的属性，我们一般需要对每个属性设置两个方法， 一个是getXxx()， 一个是setXxx()，用于对属性初始化和调用 这个过程就是「封装」

class Girl{
    private int age;  //这个是年龄属性
    private String name;  //这个是姓名属性
    public void setName(String name){
        /*
        设置名字
        参数：name 名字
         */
        this.name = name;
    }
    String getName(){
        /*
        获取名字
         */
        return name;
    }
    public void setAge(int age){
        /*
        设置年龄
         */
        this.age = age;
    }
    public int getAge(){
        /*
          获取年龄
         */
        return age;
    }
}

4.接口

接口使用「interface」关键词来定义

interface Text{
    //定义一个接口
}

接口是抽象方法的结合，被类继承 接口支持多继承（可以继承爸爸妈妈爷爷奶奶很多人的特性）

接口没有构造方法，因此无法进行实例化对象操作，只有在被类继承后，才可以继承用到接口中的方法

接口被类继承需要用到「implements」关键词

public class Ex4_22 {
    public static void main(String[] args) {
        Text_1 te1 = new Text_1();
        te1.eat();
    }
}

interface Text_0 {
    int a = 0;
    public void eat();
}
class Text_1 implements Text_0 {
    public void eat(){
        System.out.println("00");
    }

}
//运行结果：00

5.抽象类

抽象类并没有那么多属性可以去描绘一个完整的个体

public abstract class Ex4_22{
    //定义一个抽象类
}

抽象类的方法也是抽象的，就是不具体的，就比如

我会说话，但是你只知道我会说话，而不知道我会说什么话，而这个会说话的方法就是抽象方法。

public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

和接口不同的是，抽象类虽然无法实例化对象，但是抽象类是个类，有构造方法 所以抽象类一般在设计程序的时候就要考虑是否定义

而抽象类被继承后，继承抽象类的类需要将抽象类的抽象方法重写，使其具体化

public class Ex4_22 {
    public static void main(String[] args) {
        Text te = new Text();
        te.print();
    }
}
abstract class Ex4_2 {
    //定义一个抽象类
    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
}
class Text extends Ex4_2{
    public void print(){
        System.out.println("Hello");
    }
}
//运行结果：Hello

6.枚举

Java 枚举是一个特殊的类，一般表示一组常量

比如妹子的性别等

使用enum定义

enum Gender{
    MAN, WOMAN;
}
 
public class Test{
    // 执行输出结果
    public static void main(String[] args){
        Gender c1 = Gender.MAN;
        System.out.println(c1);
    }
}
//运行结果：MAN

可以使用switch语句来使用

enum Gender{
    MAN, WOMAN;
}
public class Ex4_22 {
  public static void main(String[] args) {
    Color myVar = Gender.MAN;

    switch(myVar) {
      case :
        System.out.println("男性");
        break;
      case WOMAN:
         System.out.println("女性");
        break;
    }
  }
}
//运行结果：男性

枚举可以在类内部定义