关于java:Java基础封装和继承

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

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

那封装是什么呢？

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

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

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

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

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

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

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

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 变量）之间产生的同名的抵触。

创立一个用户类 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

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

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

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

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

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

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

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

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

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

class A {
}
 
class B extends A {(对的)
}

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

class C extends B {（对的）}

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

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

构造如下：

代码如下：

父类 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());
    }
}

后果如下：

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

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

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

这里先将这两个关键字，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 : eat
cat : eat
animal : eat

留神：

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

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

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

演示过程：

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 子类继承 Person
class 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 子类继承 Person
class 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): 张三三

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

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

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 类没方法继承，而且在编译期间就会报错了，没方法通过运行。

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

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

写个测试案例：

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 办法。

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

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

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

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

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

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

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

关于java:Java基础封装和继承

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

一. 封装

1.1 封装的目标

1.2 封装的益处

1.3 封装的步骤

1.4 封装的例子

1.5 小结

二. 继承

2.1 继承的介绍

2.2 生存中的继承

2.3 继承的益处

2.4 继承的格局

2.5 继承的 demo

2.6 子类不能继承的内容

2.6.1 super 与 this 关键字

2.6.2 结构器不能被继承

2.6.3 final 润饰的类不能被继承

2.7 办法重写

2.7.1 介绍

2.7.2 应用场景与案例

2.7.2 @Override 重写注解

2.7.3 注意事项

2.8 小结