JAVA面向对象02——封装与继承

封装

封装（Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装可以看作是类的防护罩，保护类的代码和数据被随意的访问。想要访问类的代码和数据，可以通过方法来实现。

封装的优点

1. 减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

实现Java封装

1. 通过修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Father {
    private String name;
    private int age;
}

可以看到，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2. 对每个属性创建一种赋值与取指的对外的公共方法，用于外界对私有属性的访问。

//Father类
public class Father {
    private String name;
    private int age;

    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 class Test {
    public static void main(String[] args) {
        Father father = new Father();
        father.setName("WAN");
        System.out.println(father.getName());
    }
}
//输出结果：
//			WAN

类的封装，就是使用public方法为外部类提供访问和修改成员变量的入口。一般情况下，这些方法被称为get/set发放。所以外界都需要同过这些方法来访问私有的成员变量。

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

为什么要继承

继承是一种代码快速复用的机制，为了更好更方便的进行扩展。
比如：有一个Father类，有名字和年龄属性，有一个会说我是爸爸的方法。还有一个Son类，也有名字和年龄属性，有一个会说我是儿子的方法。
名字和年龄是重复的，因此可以进行复用这部分代码。

继承的优缺点

优点：面向修改是封闭的，面向扩展是开放的

弱点：继承是一种强依赖（紧耦合）关系，改父类的会影响下面的子类

类的继承格式

class Father {
}
 
class Son extends Father {
}

实例

Father

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

    public Father() {
    }

    public Father(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    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 void introduction(){
        System.out.println("我是："+name+","+age+"岁");
    }

    public void sayFather(){
        System.out.println("我是Father");
    }
}

Son

public class Son extends Father{
    public void saySon(){
        System.out.println("我是Son");
    }   
}

Test

public class Test {
    public static void main(String[] args) {
        Son son1 = new Son();
        son1.saySon(); //输出：我是Son
        son1.setName("Son"); 
        son1.setAge(10);
        son1.introduction();//输出：我是：Son,10岁
    }
}

继承与权限修饰符

权限修饰符控制表

修饰符	同一类内	同包[子类]	同包非子类	异包子类	异包非子类
private	√	×	×	×	×
无(默认)	√	√	√	×	×
protected	√	√	√	√	×
public	√	√	√	√	√

实例

Home/Father

public class Father {
    private final int PRIVEATE = 0;
    final int DEFAULT = 1;
    protected final int PROTECTED = 2;
    public final int PUBLIC = 3;

    public void fatherTest(){//同一类内
        System.out.println(PRIVEATE);//ok
        System.out.println(DEFAULT);//ok
        System.out.println(PROTECTED);//ok
        System.out.println(PUBLIC);//ok
    }
}

Home/Son

public class Son extends Father{
    public void SonTest(){//同包子类
        System.out.println(PRIVEATE);//no
        System.out.println(DEFAULT);//ok
        System.out.println(PROTECTED);//ok
        System.out.println(PUBLIC);//ok
    }
}

Home/Test

public class Test {
    public static void main(String[] args) {

        Son son = new Son();//同包非子类
        System.out.println(son.PRIVEATE);//no
        System.out.println(son.DEFAULT);//ok
        System.out.println(son.PROTECTED);//ok
        System.out.println(son.PUBLIC);//ok

        Father father = new Father();//同包非子类
        System.out.println(father.PRIVEATE);//no
        System.out.println(father.DEFAULT);//ok
        System.out.println(father.PROTECTED);//ok
        System.out.println(father.PUBLIC);//ok
    }
}

OutHome/SonOut

public class SonOut extends Father {
    public void SonOutTest(){//异包子类
        System.out.println(PRIVEATE);//no
        System.out.println(DEFAULT);//no
        System.out.println(PROTECTED);//ok
        System.out.println(PUBLIC);//ok
    }
}

OutHome/TestOut

public class TestOut {
    public static void main(String[] args) {
   		SonOut sonOut = new SonOut();//异包非子类
        System.out.println(sonOut.PRIVEATE);//no
        System.out.println(sonOut.DEFAULT);//no
        System.out.println(sonOut.PROTECTED);//no
        System.out.println(sonOut.PUBLIC);//ok
   
        Father father = new Father();//异包非子类
        System.out.println(father.PRIVEATE);//no
        System.out.println(father.DEFAULT);//no
        System.out.println(father.PROTECTED);//no
        System.out.println(father.PUBLIC);//ok
    }
}

总结：公用都能用(public)，爹分享的东西(除private)，在家里的人都能用，在外面的儿子需要爹的保护(protected)，陌生人啥都用不了。