深度了解 Java中的 封装、继承

前言

本篇博客在看完我上一篇类和对象的基础上 增加新的语法知识 。

封装

封装的概念

什么叫做封装呢 就是类似生活中有很多东西我们并不想让别人知道，比如自己的身份证、学生证、银行卡号等等 包括一台电脑里面是一个复杂的结构 产家那边会对电脑内部的零件进行包装。而在我们Java语言中，就有Java面对对象的三大特性之一——封装。
封装就是隐藏对象的属性和实现的一些细节，仅提供公共访问方式让外界访问。
该如何进行封装呢 ? 这就用到Java中的访问限定符（修饰符）。在Java中，访问限定符有四类：
private、default、protected、public。

上面那张图片描述了这四类访问限定符的使用范围。
下面我们来用代码图片描述一下private修饰符：

在这里我们可以看到 private修饰的成员变量只能在定义他的类中使用，且只能由我们控制外界是否可以访问他。想要外界访问他，只能提供公开的方法让外界可以去访问 我们可以通过setName和getName来对私有属性进行修改和获取。
具体实现看代码

class Person{
    private int a;

    public Person(int a) {
        this.a = a;
    }

   //可以修改属性a的值的setA方法
    public void setA(int a) {
        this.a = a;
    }
   // 可以获取属性a的值的getA方法
    public int getA() {
        return a;
    }

}


public class Text {
    public static void main(String[] args) {
        //看看封装的效果
        Person person = new Person(10);
        //System.out.println(person.a);
        person.setA(20);
        System.out.println(person.getA());
    }
}

运行结果：

接下来要讲到包的概念了
在Java中为了更好的管理类，把多个类合在一起称为一组，称为包。
在Java中 已经提供了很多现成的类给我们使用。

在Java中我们可以使用import语句导入包
如：

mport java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

我们也可以自定义包：

命名一般来说都是公司域名的倒置

接下来我们来讲default（默认）的访问限定符
default：可以在同一包中的不同类中访问
不同包的就是隐私了。
具体看代码实现：

class Person{
     int a;

    public Person(int a) {
        this.a = a;
    }

   //可以修改属性a的值的setA方法
    public void setA(int a) {
        this.a = a;
    }
   // 可以获取属性a的值的getA方法
    public int getA() {
        return a;
    }

}


public class Text {
    public static void main(String[] args) {
        //看看封装的效果
        Person person = new Person(10);
        System.out.println(person.a);
        //System.out.println(person.a);
        //person.setA(20);
        //System.out.println(person.getA());
    }
}

成功运行并输出：

如果在不同包中的类访问呢 会有什么效果呢
下面我们来试试：

不能在不同包的类进行访问

自然public访问限定修饰符就像一个人的外貌 谁都可以看到 不管是不同类还是不同包都可以访问

继承

什么是继承呢？
在Java中使用类对现实中的实体进行描述，类可以通过实例化变成对象 事物之间存在一些关联
在我们定义很多类 的时候难免有一些类有共同的属性 比如说定义一些动物的类 猫和狗 它们都有名字和年龄 这样我们可以用一个类来写它们共同的属性和一些方法 这样我们就可以加快了写代码的速度 所谓的共性的抽取 也就是实现了继承。在Java中继承就是把某些（猫、狗、鸟……）l类中相同的属性抽取出来放入（动物）这个大类中。用extends关键字来实现继承。
文字描述可能有点难懂 下面我们通过代码的形式来实现继承

class Animal{
    public String name;//姓名
    public int age;//年龄
    public void eat(){
        System.out.println(this.name+"正在吃…………");
    }

}
//子类Dog
class Dog extends Animal{
    public String dog_tag;//狗牌
    public void run(){
        System.out.println(this.name+"正在拼命跑！");
    }
}
//子类Bird
class Bird extends Animal{
    public String bird_call;
    public void fly(){
        System.out.println(this.name+"正在尽情地飞翔");
    }
}
public class Text {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.age = 2;
        dog.run();
        dog.eat();

        Bird bird = new Bird();
        bird.name = "布谷";
        bird.age = 2 ;
        bird.eat();
        bird.fly();
    }
}

mian方法中运行结果为：

在这里可以看出，我们已经使用子类继承了父类（共性的抽取）的方式去实现了代码的复用

如果某一变量变成private私人的，子类还会继承该变量吗

在父类中用private修饰的成员变量是会被子类继承的，但是不能直接访问，只能通过公共访问的成员方法对其进行访问。
具体代码如下：

class Animal{
    //public String name;//姓名
    private String name;
    public int age;//年龄
    public void eat(){
        System.out.println(this.name+"正在吃…………");
    }

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

    public String getName() {
        return name;
    }
}
//子类Dog
class Dog extends Animal{
    public String dog_tag;//狗牌
    public void run(){
        System.out.println(this.getName()+"正在拼命跑！");
    }
}
//子类Bird
class Bird extends Animal{
    public String bird_call;
    public void fly(){
        System.out.println(this.getName()+"正在尽情地飞翔");
    }
}
public class Text {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.run();
        dog.eat();

        Bird bird = new Bird();
        bird.setName("布谷");
        bird.age = 2 ;
        bird.eat();
        bird.fly();
    }
}

运行结果：

还有一个疑问 如果父类中的成员属性或方法名和子类中的一样，那访问的会是子类的还是会父类的呢
一切我们可以从代码说起 写代码更容易理解


看看运行的结果：

由这三张图片我们可以得知：当父类成员与子类的成员变量名字相同时，优先访问子类的成员变量
这个好理解吧 就是假如你和父亲拥有同一个东西肯定是先用自己的吧 用别人的还要开口借 是不是 友友们！！！

那现在就又有人问了 他说我就是要拿我爸爸的 那怎么办 可以吗 答案肯定是可以的了 毕竟是你自己的父亲 放在Java中当然也是可以实现的 要想实现就要用到一个关键字 super，使用super.成员变量名访问父类中同名的成员变量，**super.成员方法名（）**访问父类中同名的成员方法。
代码如下：



下面让我们见证奇迹 看看运行结果：

下面还有一个重要的知识 就是说我想在创建父类的时候就对name进行初始化 给他写上一个构造方法，但是子类在编译器报错了 给大家看看为什么报错。


大家可以看看上面这个报错提示
为什么我们没写构造方法没帮父类初始化没报错呢 也就是说编译器会默认生成一份无参的构造方法
但如果我们提供了带参数的构造方法 编译器就不会帮我们生成无参构造方法了
在写构造方法前必须先通过子类构造方法帮父类进行初始化
super（……）调用父类的构造方法帮父类初始化成员变量。

如上这种就帮父类初始化了，就不会报错了
但大家还要注意一个点：子类帮父类进行构造初始化只能在子类的第一行！因为大家知道this调用子类其他构造方法也要放在第一行既然它们都想要在第一行 那怎么办呢 答案就是不能同时使用！ 可以通过代码给大家看看效果

是不是报错了 只能在第一行吧 不是胡说八道吧 ！！！
大家感兴趣也可以行动起来试试看。

也不能同时和this调用另一种子类的构造方法吧
下面这种就可以了

通过以上这些 大家一定可以对继承有了更深入的了解了吧！

如果你不想某一个类被继承 该怎么办呢 Java可以实现吗 当然可以 只需在类的前面加上关键字final（该关键字修饰时变量就不能被更改 ，修饰方法时，方法不能被重写）。


还有就是最后一个继承的知识点了 就是在Java中继承不能继承多个类 支持多层继承
也就是说一个类只能继承一个类 不能继承多个 就是你只能有一个父亲 不能有多个父亲 这个好理解吧

这篇博客 内容就这么多 后面还有多态 组合 接口 内部类 等内容 后面鄙人会持续更新的 谢谢大家的支持 有帮助的希望多多支持 三连起来 谢谢大家 一起加油！！！