Java面向对象（四）：OOP三大特性之封装与继承

一、封装

1.1 private成员变量的封装

其他类想要操作private成员变量可以通过对外提供getxx/setxx方法来访问。

1.2 封装的意义：

1、类 方法 private修饰的成员变量都是封装；

2、隐藏了功能模块的实现细节，提高了安全性；

3、提高了代码的复用性；

例程：Student.java

package fengzhuang;
/***
 * 类的私有成员封装
 * @author  Kanekiyi
 * */
public class Student {
    public String name;
    private int age;

    //对外提供获取private成员变量age的public方法
    public int getAge() {
        return this.age;    
    }
    
    //对外提供设置private成员变量age的public方法
    public void setAge(int a) {
        this.age = a;
    } 
    
}

TextStudent.java

package fengzhuang;

public class TextStudent {
    public static void main(String[] args) {
        Student stu = new Student();
        
        //public修饰的成员变量直接访问即可
        stu.name ="鲁班七号";
        String name = stu.name;
        
        //private修饰的成员变量通过封装方法访问
        stu.setAge(8);
        int age = stu.getAge();
        
        System.out.println(name+"今年"+age+"岁了");
        
    }
    
}

二、继承

面向对象中类与类之间的一种关系，若子类继承父类，则继承了父类的成员变量和成员方法。

2.1 关键字 extends

 A  extends B   A为子类，B为父类

 备注：Java中若没有标注extends继承，其实继承了Object类

2.2 继承注意事项：

1、父类的私有属性和私有方法不能被继承。

2、子类可以拥有自己的成员变量和方法。

例程：Father.java

package fengzhuang;
/***
 * @author  Kanekiyi
 * son父类
 * */

public class Father {
    
    public String name;
    public int age;
    private String IDCard ;    //私有变量不能被继承
    
    public String getIDCard() {
        return IDCard;
    }

    public void setIDCard(String iDCard) {
        IDCard = iDCard;
    }

    public Father() {
        System.out.println("我是无参构造函数");
    }

    public void show() {
        System.out.println(name+age);
    }


}

Son.java

package fengzhuang;
/****
 * @author  Kanekiyi
 * 子类可直接调用父类的pubilc成员变量与成员方法，
 * 不能直接调用private修饰的方法/变量。
 * 子类也可以有自己的方法和变量。
 * 
 */
public class Son extends Father {
    
    public String gender;
    
    public void love() {
        System.out.println("reading");
        
    }
    
    public static void main() {
    
        Son son = new Son();
    
        //继承父类的变量与方法
        son.name = "王大治";

        son.age = 3;
        son.show();
        //son.IDCard = "3454325";   不能继承私有成员变量，只能通过封装访问操作
        
        //本身的方法
        son.gender = "mate";
        son.love();
        //son.Father();
    }
    
}

GrandSon.java

package fengzhuang;
/****
 * 类的单继承：一个类只能继承自一个类，即只能有一个父类，但是一个类可以同时被多个类继承即可以有多个子类。
 * 类的多重继承：类可以继承自己父类的父类的属性和方法，也可以被自己的子类的子类继承方法和属性。
 * 
 * */
public class GrandSon extends Son{

    public static void main(String[] args) {
        GrandSon gs = new GrandSon();
    
        //多重继承继承自father类
        gs.name = "王小胖";
        gs.age = 3;
        gs.show();                
        
        //继承Son类
        gs.love();                
            
    }
    
}

3、在java中，只允许单继承，也就是说 一个类最多只能继承于一个父类。

       但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。

4、允许多重继承   B extends A

      C extends B    >>>>>  C extends A

　  例程：GrandSon.java

5、子类不能继承父类的构造函数但是能够通过super关键字调用父类的构造函数

注：super() 如果不写系统会默认添加；只要再继承关系中那么子类都会去调用父类的构造函数。

　　例程：Animal.java  Dog.java

6、如果子类中自己定义的成员变量和父类定义的成员变量名相同如何访问？

成员变量的访问顺序：先在自身找没有的话在从父类找，没有再报错。

所以若和父类的成员变量名相同则访问子类的同名成员变量；

        例程：Cat.java

思考题：this关键字与super关键字的区别

1、this代表本身，调用自身的成员变量方法，super调用父类的构造函数

2、this（调用构造函数时）和super都必须在第一行，所以不能同时添加（添加this，super系统会默认调用）。

2.3 方法的重写

1、对象对成员方法的调用执行过程，先看自身类有没有方法有则执行，没有则父类中查找，还没有则报错。

2、方法的重写：

子类的成员方法名和父类的成员方法名同名，只有方法体不同，调用子类的方法，只发生在继承关系中。

 

思考题：overLoad 与overWrite区别？overLoad返回值可以相同吗？

1、语法上：重载的方法名相同，但是形参不能相同（个数和数据类型）。   重写的方法名，形参可以完全相同。

2、作用范围：重载任意类中都可以，  重写只能发生在继承关系的类中。

思考题：为什么要有继承？它的好处和坏处？

简化重复代码

继承优点：

1、提高了代码的复用性；

2、提高了代码的维护性；

3、建立类与类的关系，为多态提供了前提条件；

继承的弊端：

1、增加了类与类的耦合性，违背了软件工程的理念：低耦合，高内聚；

2、破坏了封装的特性。