茫茫人海千千万万，感激这一秒你看到这里。心愿我的文章能对你的有所帮忙！共勉！

愿你在将来的日子，放弃酷爱，奔赴山海！

Java基础知识(封装和继承)

一. 封装

那封装是什么呢？

在面向对象程式设计办法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节局部包装、暗藏起来的办法。

1.1 封装的目标

• 间接通过操控类对象来达到目标，不须要对具体实现非常理解，使类属性和办法的具体实现对外不可见。岂但不便还起到了爱护作用。
• 封装最次要的性能在于咱们能批改本人的实现代码，而不必批改那些调用咱们代码的程序片段。
• 适当的封装能够让程式码更容易了解与保护，也增强了程式码的安全性。

1.2 封装的益处

• 良好的封装可能缩小耦合。
• 类外部的构造能够自在批改。
• 能够对成员变量进行更准确的管制。
• 暗藏信息，实现细节。

1.3 封装的步骤

1. 批改属性的可见性来限度对属性的拜访（个别限度为private），例如：

   public class Person {    private String name ; // 姓名    private String gender ; // 性别    private int age; // 年龄}

这段代码中，将 name 、sex和 age 属性设置为公有的，只能本类能力拜访，其余类都拜访不了，如此就对信息进行了暗藏。

2. 对每个值属性提供对外的公共办法拜访，也就是创立一对赋取值办法，用于对公有属性的拜访，例如：

   public class Person {    private String name ; // 姓名    private String gender ; // 性别    private int age; // 年龄    public void setName(String name) {          this.name = name;    }    public String getName() {          return name;    }    public void setGender(String gender) {        this.gender = gender;    }        public String gender(){        return gender;    }        public void setAge(int age) {        this.age = age;    }    public int getAge() {          return age;    }}

采纳 this 关键字调用本类中的属性，也就是类中的成员变量。次要为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间产生的同名的抵触。

1.4 封装的例子

• 创立一个用户类User:

  代码如下：

  package com.nz.pojo;public class User {    private String username; // 用户名    private String password; // 明码    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }}

• 编写测试User的demo：EncapsulationDemo

  代码如下：

  package com.nz;import com.nz.pojo.User;public class EncapsulationDemo {    public static void main(String[] args) {        User user = new User();        user.setUsername("太子爷哪吒");        user.setPassword("520");        System.out.println("username: " + user.getUsername() + "-----------"                            + "password: " + user.getPassword());    }}

执行后果如下：

username:太子爷哪吒-----------password520

1.5 小结

封装实际上是将类的某些信息暗藏在类的外部，不容许内部程序间接拜访，而是通过该类提供的办法来实现对暗藏信息的拜访和操作。就是把咱们想提供给外界的一些办法给裸露进去，以便外界能调用到咱们。

二. 继承

2.1 继承的介绍

继承是java面向对象编程技术的一块基石，因为它容许创立分等级档次的类。形容的是事物之间的所属关系，这种关系是：is-a 的关系。

继承：就是子类继承父类的属性和行为，使得子类对象（实例）能够间接具备与父类雷同的属性、雷同的行为。子类能够间接拜访父类中的非公有的属性和行为。

2.2 生存中的继承

兔子和长颈鹿属于食草动物类，老虎和狮子属于食肉动物类。而食草动物和食肉动物又是属于动物类。

那是不是兔子、长颈鹿、老虎、狮子都属于动物类呢？答案是没错滴！尽管食草动物和食肉动物都是属于动物，然而两者的属性和行为上有差异，所以子类会具备父类的个别个性也会具备本身的个性。咱们就能够再多个类中存在雷同属性和行为时，咱们能够将这些内容抽取到独自一个类中，那么多个类无需再定义这些属性和行为，只有继承那一个类即可。

2.3 继承的益处

1. 进步代码的复用性（缩小代码冗余，雷同代码反复利用）。
2. 使类与类之间产生了关系。
3. 子类领有父类非 private 的属性、办法。
4. 子类能够领有本人的属性和办法，即子类能够对父类进行扩大。
5. 子类能够用本人的形式实现父类的办法。
6. 进步了类之间的耦合性（继承的毛病，耦合度高就会造成代码之间的分割越严密，代码独立性越差）。
7. Java 的继承是单继承，然而能够多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以依照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个个性。

2.4 继承的格局

在Java当中会通过<font color=#ff1493>extends</font>关键字能够申明一个类是从另外一个类继承而来的，个别模式如下：

class 父类 {} class 子类 extends 父类 {}

须要留神一点： Java 不反对多继承，但反对多重继承。就如下：

class A {} class B extends A {   (对的)}class C extends A, B {  （错的）}class C extends B {   （对的）}

顶层父类是Object类。所有的类默认继承Object，作为父类。

2.5 继承的demo

• 编写一个父类极其对应的子类信息

  构造如下：

  代码如下：

  父类Person：

  package com.nz.pojo;public class Person {    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;    }}

子类Student没有额定的属性和办法：

package com.nz.pojo;/** * 继承了Person特有的name, age， * 没有额定的独有属性和办法 */public class Student extends Person{}

子类Teacher多了一个工资的属性和独有的教书办法：

package com.nz.pojo;/** * 继承了Person特有的name, age， * 多了本人独有的工资属性还有独有的教书办法 */public class Teacher extends Person{    // 工资    private double salary ;    // 特有办法    public void teach(){        System.out.println("老师在认真教书！");    }    public double getSalary() {        return salary;    }    public void setSalary(double salary) {        this.salary = salary;    }}

• 编写测试代码：

  package com.nz;import com.nz.pojo.Student;import com.nz.pojo.Teacher;public class InheritDemo {    public static void main(String[] args) {        Teacher teacher = new Teacher();        teacher.setName("太子爷哪吒");        teacher.setAge(18);        teacher.setSalary(1999.99);        System.out.println(teacher.getName());        System.out.println(teacher.getAge());        System.out.println(teacher.getSalary());        teacher.teach();        Student student = new Student();        student.setName("哪吒");        student.setAge(12);        //student.setSalary(1999.99); // student没有工资属性，报错！        System.out.println(student.getName());        System.out.println(student.getAge());    }}

后果如下：

太子爷哪吒181999.99老师在认真教书！哪吒12

从后果来看，子类继承父类，就能够间接失去父类的成员变量和办法。而子类能够编写一些特有的属性和办法，然而是否能够继承所有成分呢？

2.6 子类不能继承的内容

并不是父类的所有内容都能够给子类继承的：

2.6.1 super 与 this 关键字

这里先将这两个关键字，super和this在继承关系中，使用比拟频繁。

• super关键字：咱们能够通过super关键字来实现对父类成员的拜访，用来援用以后对象的父类。

• this关键字：指向本人本类的援用。

  super和this残缺的用法如下：

  this.成员变量        --    本类的super.成员变量        --    父类的this.成员办法名()      --    本类的    super.成员办法名()   --    父类的

• 具体演示，创立测试InheritDemo2：

  package com.nz;public class InheritDemo2 {    public static void main(String[] args) {        Animal a = new Animal();        a.eat();        Cat cat = new Cat();        cat.eatFish();    }}class Animal {    void eat() {        System.out.println("animal : eat");    }}class Cat extends Animal {    void eat() {        System.out.println("cat : eat");    }    void eatFish() {        this.eat();   // this 调用本人的办法        super.eat();  // super 调用父类办法    }}

调用后果如下：

animal : eatcat : eatanimal : eat

• 留神：

  子类的每个构造方法中均有默认的super()，调用父类的空参结构。手动调用父类结构会笼罩默认的super()。

  super() 和 this() 都必须是在构造方法的第一行，所以不能同时呈现。

2.6.2 结构器不能被继承

• 子类不能继承父类的结构器（构造方法或者构造函数），它只是调用（隐式或显式）。因为子类有本人的结构器。值得注意的是子类能够继承父类的公有成员（成员变量，办法），只是子类无奈间接拜访而已，能够通过<font color=#ff1493>getter/setter</font>办法拜访父类的private成员变量。
• 如果父类的结构器带有参数，则必须在子类的结构器中显式地通过<font color=#ff1493>super </font> 关键字调用父类的结构器并配以适当的参数列表。
• 如果父类结构器没有参数，则在子类的结构器中不须要应用 <font color=#ff1493>super </font> 关键字调用父类结构器，零碎会主动调用父类的无参结构器。

• 演示过程：

  package com.nz;public class InheritDemo3  {    public static void main(String[] args) {        System.out.println("------Teacher 类继承------");        Teacher teacher = new Teacher();        Teacher teacher2 = new Teacher("张三");        System.out.println("------Student 类继承------");        Student student = new Student();        Student student2 = new Student("张三三");    }}// 父类class Person {    private String name;    Person(){        System.out.println("调用了父类的无参结构器: Person()");    }    Person(String name) {        System.out.println("调用了父类的带参结构器: Person(String name)");        this.name = name;    }}// Teacher子类继承Personclass Teacher extends Person{    private String name;    Teacher(){        // 主动调用父类的无参数结构器 因为会有默认super();        System.out.println("Teacher");    }    public Teacher(String name){        super("太子爷哪吒");  // 调用父类中带有参数的结构器        System.out.println("Teacher(String name):"+name);        this.name = name;    }}// Student子类继承Personclass Student extends Person{    private String name;    Student(){        super("heihei");  // 调用父类中带有参数的结构器        System.out.println("SubClass2");    }    public Student(String name){ // 主动调用父类的无参数结构器        System.out.println("Student(String name):"+name);        this.name = name;    }}

后果如下：

------Teacher 类继承------调用了父类的无参结构器: Person()Teacher调用了父类的带参结构器: Person(String name)Teacher(String name):张三------Student 类继承------调用了父类的带参结构器: Person(String name)SubClass2调用了父类的无参结构器: Person()Student(String name):张三三

2.6.3 final润饰的类不能被继承

final 关键字次要用在三个中央：变量、办法、类。

1. 润饰类：示意该类不能被继承；
2. 润饰办法：示意办法不能被重写；
3. 润饰变量：示意变量只能一次赋值当前值不能被批改（常量）。

final 的特点：

• 对于一个 final 变量，如果是根本数据类型的变量，则其数值一旦在初始 化之后便不能更改；如果是援用类型的变量，则在对其初始化之后便不 能再让其指向另一个对象。
• 当用 final 润饰一个类时，表明这个类不能被继承。final 类中的所有成员 办法都会被隐式地指定为 final 办法。
• 应用 final 办法的起因有两个。第一个起因是把办法锁定，以防任何继承 类批改它的含意；第二个起因是效率。在晚期的 Java 实现版本中，会将 final 办法转为内嵌调用。然而如果办法过于宏大，可能看不到内嵌调用 带来的任何性能晋升（当初的 Java 版本曾经不须要应用 final办法进行这些优化了）。类中所有的 private 办法都隐式地指定为 final。

咱们测试下润饰类后到底能不能继承：

package com.nz;public class InheritDemo4 {}// 父类final class Fu {    private String name;}//class Zi extends Fu{ // Cannot inherit from final 'com.nz.Fu' 会显示没方法继承Fu//}

后果：能够看进去在被final润饰的Fu类没方法继承，而且在编译期间就会报错了，没方法通过运行。

2.7 办法重写

2.7.1 介绍

子类中呈现与父类截然不同的办法时（返回值类型，办法名和参数列表都雷同），会呈现笼罩成果，也称为重写或者复写。申明不变，从新实现。

2.7.2 应用场景与案例

产生在子父类之间的关系。
子类继承了父类的办法，然而子类感觉父类的这办法不足以满足本人的需要，子类从新写了一个与父类同名的办法，以便笼罩父类的该办法。

写个测试案例：

package com.nz;public class InheritDemo5 {    public static void main(String[] args) {        // 创立子类对象        Cat lanMao = new Cat();        // 调用父类继承而来的办法        lanMao.run();        // 调用子类重写的办法        lanMao.sing();    }}class Animal{    public void sing(){        System.out.println("动物都能够唱歌！");    }    public void run(){        System.out.println("动物都能够跑！");    }}class Cat extends Animal {    public void sing(){        System.out.println("咱们一起学猫叫，一起喵喵喵！让咱们一起撒个娇");    }}

运行后果：

动物都能够跑！咱们一起学猫叫，一起喵喵喵！让咱们一起撒个娇

能够看出，蓝猫调用了重写后的sing办法。

2.7.2 @Override重写注解

• @Override：注解，重写注解校验！
• 这个注解标记的办法，就阐明这个办法必须是重写父类的办法，否则编译阶段报错。

• 倡议重写都加上这个注解，一方面能够进步代码的可读性，一方面能够避免重写出错！

  加上后的子类代码模式如下：

  class Cat extends Animal {    // 申明不变，从新实现    // 办法名称与父类全副一样，只是办法体中的性能重写了！    @Override    public void sing(){        System.out.println("咱们一起学猫叫，一起喵喵喵！让咱们一起撒个娇");    }}

2.7.3 注意事项

1. 办法重写是产生在子父类之间的关系。
2. 子类办法笼罩父类办法，必须要保障权限大于等于父类权限。
3. 子类办法笼罩父类办法，返回值类型、函数名和参数列表都要截然不同。

2.8 小结

继承是应用已存在的类的定义作为根底建设新类的技术，新类的定义能够减少新的数据或新的性能，也能够用父类的性能，但不能选择性地继承父类。通过应用继承咱们可能十分不便地复用以前的代码。

注: 如果文章有任何谬误和倡议，请各位大佬纵情留言！如果这篇文章对你也有所帮忙，心愿可恶亲切的您给个三连关注下，非常感谢啦！也能够微信搜寻太子爷哪吒公众号进行私聊我，感激各位大佬！