封装、继承、重写

封装、继承、重写

我们设计程序的时候需要追求高聚合和低耦合，类的内部操作细节理应在类里完成，不允许外部干涉，仅暴露少量的方法给外部使用。

封装的本质就是数据的隐藏，也就是禁止直接访问一个对象中数据的实际表示，而应该通过结构操作来访问。

对于代码来说就是属性私有：get/set

 

封装

类示例代码：

public class Student {
​
    //属性私有
    private String name;
    private int id;
    private int age;
    private char gender;
​
    //get/set方法
    public String getName() {
        return name;
    }
​
    //get/set方法
    public int getId() {
        return id;
    }
​
    //get/set方法
    public int getAge() {
        return age;
    }
​
    //get/set方法
    public char getGender() {
        return gender;
    }
​
    //get/set方法
    public void setName(String name) {
        this.name = name;
    }
​
    //get/set方法
    public void setId(int id) {
        this.id = id;
    }
​
    //get/set方法
    public void setAge(int age) {
        this.age = age;
    }
​
    //get/set方法
    public void setGender(char gender) {
        this.gender = gender;
    }
​
    //普通方法
    public void say() {
        System.out.println("我的名字叫" + name + "，我的学号是" + id + "，我今年" + age + "岁了，是一个" + gender + "孩。");
    }
​
​
}

以上代码指示了一个最简单的封装方法，即通过private修饰属性，使其私有，然后使用公共的get方法和set方法让对象可以设置和调用属性。

 

主程序示例代码：

public class Application {
    public static void main(String[] args) {
        Student crow = new Student();
        crow.setName("乌鸦");
        crow.setId(520);
        crow.setAge(18);
        crow.setGender('男');
​
        System.out.println("我的名字叫" + crow.getName() + "，我的ID是：" + crow.getId() + "。");
        //我的名字叫乌鸦，我的ID是：520。
        crow.say();
        //打印结果：我的名字叫乌鸦，我今年18岁了，是一个男孩。
    }
}

以上代码演示了一个主程序分别使用get和set获取和读取信息的方法。

 

继承

继承就是对类的再抽象，通过提取共同点在上级统括一个类。

拓展是用extends关键字，意为扩展。子类继承父类，也可以理解成父类包含子类。

Java中的类都是单继承类，即一个子类只能有一个父类。但是一个父类可以有多个子类。

继承是类和类之间的关系，除了继承外，类与类的关系还有依赖、组合、聚合等等。

 

父类示例：

public class Person {
    //父类私有属性
    private int money;
    private String name;
​
    //父类方法
    public double getMoney() {
        return money;
    }
​
    //父类方法
    public String getName() {
        return name;
    }
​
    //父类方法
    public void setMoney(int money) {
        this.money = money;
    }
​
    //父类方法
    public void setName(String name) {
        this.name = name;
    }
​
    //父类方法
    public void sayHello() {
        System.out.println("你好，我是" + name + "，很高兴认识你。");
    }
​
    //父类方法
    public void sleep() {
        System.out.println("做了一个梦，梦里我有" + money + "的钱。");
    }
}

 

子类示例：

public class Teacher extends Person {
​
}

 

主程序示例：

public class Application {
    public static void main(String[] args) {
        Teacher wang = new Teacher();
        wang.setName("王老师");
        wang.setMoney(1_0000_0000);
​
        wang.sayHello();
        //打印结果：你好，我是王老师，很高兴认识你。
        wang.sleep();
        //打印结果：做了一个梦，梦里我有100000000的钱。
    }
}

通过以上例子可以发现，子类里面即使什么都没有写，但是有了继承关系之后，依然可以使用父类中公共的方法。

需要注意的是，子类无法使用父类私有的方法或者属性。

 

Object类

在Java中所有的类都直接或间接继承于Object类。

Object类是所有类的父类。

 

重写

重写，针对方法。就是指当子类的方法名和父类一样时，可以重写父类的方法。

通过之前的学习，我们知道子类对象可以使用父类的方法，如果当子类和父类中有同名方法时，则子类会重写父类的方法。

注意：

1. 如果子类和父类的方法同名，必须重写。否者提示方法名冲突。

2. 子类和父类的访问修饰符最好是public，返回值类型一致。

 

静态方法的情况

父类示例代码：

public class Father {
    public static void say() {
        System.out.println("我是Father类的say方法");
    }
}

 

子类示例代码：

public class Son extends Father {
    public static void say() {
        System.out.println("我是Son类的say方法");
    }
}

 

主程序示例代码：

public class Application {
    public static void main(String[] args) {
        //声明一个Son的对象
        Son son = new Son();
        //声明一个Father对象，引用到子类地址。
        Father father = new Son();
​
        son.say();
        //打印结果：我是Son类的say方法
        father.say();
        //打印结果：我是Father类的say方法
    }
}

可以看到，当重写静态方法时，子类使用自己的方法，因为在以上示例中，虽然生成的是父类对象，但实际指向子类地址。

 

普通方法的情况

父类示例代码：

public class Father {
    public void say() {
        System.out.println("我是Father类的say方法");
    }
}

 

子类示例代码：

public class Son extends Father {
    public void say() {
        System.out.println("我是Son类的say方法");
    }
}

 

主程序代码：

public class Application {
    public static void main(String[] args) {
        //声明一个Son的对象
        Son son = new Son();
        //父类指向子类对象
        Father father = new Son();
​
        son.say();
        //打印结果：我是Son类的say方法
        father.say();
        //打印结果：我是Son类的say方法
    }
}

可以看到，当重写非静态方法时子类，子类重写父类的方法，即父类的方法被子类重写。

 

学习总结

this和super

1. super

   • 调用父类的构造函数或属性，必须在构造函数的第一个。

   • super必须且只能出现在子类的方法或者构造函数中

   • 不能和this同时调用构造函数。

   • 必须有继承关系才能使用。

2. this

   • 调用当前类的属性。

   • 不能和super同时调用构造函数。

   • 没有继承也可以使用。

 

重写

需要有继承关系，子类重写父类的方法。

1. 方法名必须相同。

2. 参数列表必须相同。

3. 父类的功能，子类不一定需要，或者不一定满足。

4. 修饰符尽量使用public

5. 重写也是会抛出异常的，比如：ClassNotFoundException。

 

修饰符

修饰符范围：

• Public>Protected>Default>Private

• 修饰符的范围可以扩大，不能缩小。