2021-09-12

封装

封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。这些对象通过一个受保护的接口访问其他对象。一个对象所封装的就是自己的属性和方法，所以它不需要依赖其他对象就可以完成自己的操作。

封装的优点如下：良好的封装能够减少耦合。类内部的结构可以自由修改。可以对成员变量进行更精确的控制。隐藏信息，实现细节。

class Person{
    //将name、age、weight 3个属性设置为private，这样其他类就不能访问这3个属性。
    private String name;
    private int age;
    private float weight;

    //为每个属性写了两个方法getXxx()和setXxx()，将这两个方法设置为public，其他类可以通过setXxx()方法来设置对应的属性，通过getXxx()来获得对应的属性。
    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;
    }

    public float getWeight() {
        return weight;
    }

    public void setWeight(float weight) {
        this.weight = weight;
    }
}


public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("Yu");
        p1.setAge(20);
        p1.setWeight(80);

        System.out.println(p1.getName());
        System.out.println(p1.getAge());
        System.out.println(p1.getWeight());
    }
}

封装隐藏了类的内部机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而言，它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承

继承是Java面向对象编程技术的一块基石。继承能以已有的类为基础，派生出新的类，可以简化类的定义，扩展类的功能。

支持类的单继承和多层继承，但是不支持多继承。即：一个类只能继承一个类而不能继承多个类，就是说一个类只能有一个父类，不能有多个父类。但是一个类可以被多个类继承，也就是说一个类可以拥有多个子类。

子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。在继承关系中，父类更通用，子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

所有类都直接或者间接地继承了 java.lang.Object 类，Object 类中定义了所有的 Java 对象都具有的相同行为，是所有类的祖先。

使用关键字 extends可以实现继承。

class 子类名 extends 父类名

1. 子类继承父类的成员变量

   1. 可以继承父类的 public 和 protected 成员变量，不可以继承父类的 private 成员变量。
   2. 对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承，否则不能继承。
   3. 对于子类可以继承的成员变量，如果在子类中出现了同名的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽父类的同名的成员变量。如果要在子类中访问父类中的同名的成员变量，需要使用 super 关键字来进行引用。

2. 子类继承父类的方法

   1. 子类能够继承父类的 public 和 protected 成员方法，不能继承父类的 private 成员方法。
   2. 对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承，否则不能继承。
   3. 对于子类可以继承的父类成员方法，如果在子类中出现了同名的成员方法，则称为覆盖，即子类的成员方法会覆盖父类的同名成员方法。如果要在子类中访问父类中的同名成员方法，需要使用 super 关键字来进行引用。

3. 构造方法

   1. 子类不能继承父类的构造方法。
   2. 如果父类的构造方法都是带有参数的，则必须在子类的构造方法中显式地通过super关键字调用父类的构造方法并配以适当的参数列表。
   3. 如果父类有无参构造方法，则在子类的构造方法中调用父类构造方法则不是必须使用super关键字。
   4. 如果没有使用super关键字，系统会自动调用父类的无参构造方法。
   5. 由于父类没有无参构造方法，所以子类的构造方法必须先使用super方法调用父类的有参构造方法，这样确实比较麻烦，因此父类在设计构造方法时应该含有一个无参构造方法。

重载

在Java中，同一个类中的多个方法可以有相同的名字，只要它们的参数列表不同即可，这被称为方法重载。重载是面向对象的一个基本特性。

参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。

public class First {
    // 一个普通的方法，不带参数
    void test(){
        System.out.println("No parameters");
    }
    //重载上面的方法，并且带了一个整型参数
    void test(int a){
        System.out.println("a :" + a);
    }
    //重载上面的方法，并且带了两个参数
    void test(int a,int b){
        System.out.println("a and b" + a + " " + b);
    }
    //重载上面的方法，并且带了一个双精度参数
    double test(double a){
        System.out.println("double a: " + a);
        return a * a;
    }
    public static void main(String[] args) {
        First d = new First();
        d.test();
        d.test(2);
        d.test(2,3);
        d.test(2.0);
    }
}

重载就是在一个类中有相同的函数名称但形参不同的函数。重载可以让一个程序段尽量减少代码和方法的种类。

• 方法的重载有以下几点要特别注意：
  • 方法名称必须相同。方法的参数列表（参数类型、参数个数、参数顺序）至少有一项不同，仅仅参数变量名称不同是不可以的。
  • 方法的返回值类型和修饰符不做要求，可以相同，也可以不同。

多态

多态是面向对象程序设计中实现代码重用的一种机制。重载就是多态的一种体现，属于静态多态，这种多态是在代码编译阶段就确定下来的。还有一种多态形式，在程序运行阶段结束才能体现出来，称为动态多态。

1. 多态的存在要有3个前提：
   1. 要有继承关系。
   2. 子类要重写父类的方法。
   3. 父类引用指向子类。
2. 两个重要的概念：
   1. 向上转型：父类对象通过子类对象实例化。
   2. 向下转型：父类对象可以转换为子类对象，但必须强制转换。

class Animal{
    int age = 10;

    public void eat(){
        System.out.println("动物吃东西");
    }

    public void shout(){
        System.out.println("动物在叫");
    }

    public static void run(){
        System.out.println("动物在奔跑");
    }
}

class Dog extends Animal{
    String name="黑子";

    public void eat(){
        System.out.println("Dog eat");
    }
    public static void run(){
        System.out.println("Dog run");
    }
    public void watchDoor(){
        System.out.println("Dog watchDoor");
    }
    //子类重写了父类中的某些方法，在调用这些方法的时候，必定是使用子类中定义的这些方法。
}

public class First {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 父类通过子类实例化，多态的表现，向上转型
        animal.eat();
        animal.shout();
        animal.run();
        //指向子类的父类引用只能访问父类中拥有的方法和属性。对于子类中存在而父类中不存在的方法，该引用是不能使用的。
//        animal.watchDoor();
        System.out.println(animal.age);

//        使例子中的animal可以访问子类独有的方法和属性呢？
        Dog d = (Dog) animal;   //向下转型，必须强制类型转换
        d.watchDoor();
        System.out.println(d.name);
    }
}