重拾Java (四)类和对象（面向对象）

重拾Java第四篇-类和对象

• Java是面向对象的一门语言，类作为面向对象的第一公民，有必要学习一下啦~

---

• 类的建立

  • 类使用class关键字标识，同样也支持访问修饰符
  • static标识这个是一个静态类
  • public表示该类是公开的

public class Person {

}

• 类的字段
  • 字段则是类的成员变量，也可以说是类的属性

public class Person {
    //人类的2个属性
    private String name;
    private int age;
}

* static关键字修饰则是类的静态变量

public class Person {
    private static int sex = 1;

    private String name;
    private int age;
}

• 类是单继承，接口是可以多继承的，类可以实现多个接口，但是只能有一个直接父类，间接父类是可以多个的

  • 间接父类指的是：孙类对于爷类来讲，例如WoMan是Female的子类，WoMan的父类是Female，Female的父类是Person。Person对于Woman来说就是一个间接父类
  • 这个关系是可以多重的，例如Java默认父类都是Object，那么Object也是WoMan的间接父类。

• 类的方法

  • 方法则是类的行为，也有类方法和静态方法之分

public class Person {
    private static int sex = 1;

    private String name;
    private int age;

    //类方法，需要实例化才能调用
    public void sayHello() {
        System.out.println("sex: " + sex + " name: " + this.name + " age: " + this.age);
    }

    //static关键字修饰，则为静态方法，直接通过类名.方法名()即可调用
    public void sayHello() {
        System.out.println("sex:" + sex);
    }
}

面向对象

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

  • 封装，封装指的是类的属性私有化，对外开放Get\Set方法进行访问，保证类的数据改变是有道可循的。
  • 继承，通过派生子类，继承父类，进行类拓展和方法复写，进行复用。
  • 多态，子类对象以父类类型接收，复写父类方法，虽然类型是父类类型，但调用被子类复写的父类方法时，会调用子类的复写逻辑。能将类进一步进行抽象，具体行为有定义抽象类和定义接口。

• 封装，如果是类中内部使用，成员变量和方法使用private访问修饰符修饰，如需要开放给外部调用赋值，一般会保持成员变量为private，对外提供一对get\set方法进行赋值。

  • 不单只是成员变量，对外提供设置方法，改变多个成员变量也是很常见的。

public class Person {
    private String name;
    private int age;

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

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

• 继承，当公用逻辑是公用时，抽取到父类，不同子类的行为不同时，再提供抽象方法或空实现方法让子类进行复写。
  • 继承使用extend关键字

public class Person {
    private String name;
    private int age;

    //...省略属性get\set方法

    public void eat() {
        System.out.println("吃米饭");
    }
}

public class Male extend Person {
    @Override
    public void eat() {
        System.out.println("吃汉堡包");
    }
}

public class Female extend Person {
    @Override
    public void eat() {
        //哈哈，这里开个玩笑，只是演示复写
        System.out.println("吃钱");
    }
}

* 私有方法不可被复写，如果访问修饰符为private则不能被子类复写

public class Person {
    private String name;
    private int age;

    //...省略属性get\set方法

    public void eat() {
        System.out.println("吃米饭");
    }

    private void showInfo() {
        System.out.println("name: " + this.name + " age: " + this.age);
    }
}

public class Female extend Person {
    //私有方法会报错，编译是不通过的
    @Override
    private void showInfo() {
    }
}

* final关键字修饰的方法，不可被重写

public class Person {
    private String name;
    private int age;

    //...省略属性get\set方法

    public final void pay() {
        System.out.println("独自去偷欢~");
    }
}

public class Female extend Person {
    //final修饰的方法不可重写，编译是不通过的
    @Override
    public final void play() {
    }
}

* 上面eat方法是public的，就是说外部也可以调用，那如果只想内部调用，并且能被复写，外部不能调用呢？
* 这样我们只需要将public修饰符改为protected就可以啦~

public class Person {
    private String name;
    private int age;

    //...省略属性get\set方法

    protected final void play() {
        System.out.println("独自去偷欢~");
    }
}

public class Female extend Person {
    @Override
    protected void play() {
        System.out.println("让你玩，回来打断你的狗腿!");
    }
}

* 抽象类，当父类需要调用一个公用行为的方法，但每个子类的行为不一致时，可以使用abstract关键字，成为抽象类，提供抽象方法，调用即可

//声明为抽象类
public abstract class Person {
    private String name;
    private int age;

    //...省略属性get\set方法

    //抽象方法必须使用abstract关键字修饰
    //存在abstract抽象方法的类必须为抽象了！
    protected abstract void makeMoney();
}

public class Male extend Person {
    //子类必须重写抽象方法
    @Override
    protected void makeMoney() {
        System.out.println("我去公司敲代码赚钱...");
    }
}

public class Female extend Person {
    @Override
    protected void makeMoney() {
        System.out.println("我去银行上班赚钱...");
    }
}

• 多态
  • 子类复写父类方法，子类实例赋值给父类类型，调用父类方法，会调用子类复写后的方法

public class Person {
    private String name;
    private int age;

    //...省略属性get\set方法

    //提供一个默认实现
    protected void work() {
        System.out.println("我不会赚钱");
    }
}

public class Male extend Person {
    //复写方法
    @Override
    protected void work() {
        System.out.println("我去公司敲代码赚钱...");
    }
}

//创建子类实例，父类类型接收
Person p = new Female();
//我去公司敲代码赚钱...
p.makeMoney();

* 接口方式实现。接口使用inteface关键字。
* 接口和抽象类的区别是，接口中的方法都是抽象方法，而抽象类中可以有普通方法也可以有抽象方法，但是接口只有抽象方法。
* 补充一下
    - 接口中的方法，都是public的。所以接口的方法没法做到不被外部调用，要想被复写又不能外部调用，只能选择抽象类中定义了。
    - 接口中的变量，都是public static final的，所以接口中定义的成员，都是空开不可被复写，并且是类共享的成员。

public inteface IShopping {
    void shopping();
}

public class Person implements IShopping {
    private String name;
    private int age;

    //...省略属性get\set方法

    //这里如果不去实现IShopping接口的方法，则子类会强制复写
}

public class Female extend Person {
    //子类复写方法
    @Override
    protected void shopping() {
        System.out.println("我要去逛街街，买包包啦~");
    }
}

//子类实例，父类类型接受
Person p = new Female();
//会输出：我要去逛街街，买包包啦~
p.shopping();

* 接口方式实现多态，常用就是定义行为接口，隐藏实现，例如依赖注入进行解耦，测试时替换实现等。
* 由于类的直接父类只能有一个，所以父类的位置很宝贵，我们在做设计时，应优先考虑接口实现而非继承，多用组合少用继承，效果更佳喔~

• 关于接口要补充的，上面其实有讲接口，这里再说一遍~
  • 接口中的方法，都是public的。所以接口的方法没法做到不被外部调用，要想被复写又不能外部调用，只能选择抽象类中定义了。
  • 接口中的变量，都是public static final的，所以接口中定义的成员，都是空开不可被复写，并且是类共享的成员。
  • 在Java8一下，接口是不能有实现的，但是Java8开始，接口可以有默认实现了

public inteface IShopping {
    void shopping();

    //Java8开始支持在接口中写实现了
    void pay() {
        //...do something
    }
}