Java面向对象封装和继承

以你之姓@ 2022-04-14 06:57 292阅读 0赞

## **面向对象** ##

**什么是面向过程、面向对象？**

面向过程与面向对象都是我们编程中，编写程序的一种思维方式。

*    面向过程的程序设计方式，是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。例如：公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向过程的程序设计方式会思考“打扫卫生我该怎么做，然后一件件的完成”，最后把公司卫生打扫干净了。

*   面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象，他要怎么做这件事是他自己的事，反正最后一群对象合力能把事就好就行了。例如，公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向对象的程序设计方式会思考“我该让谁来做，如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”,这里的“小明、小丽、小郭、小强”就是对象，他们要打扫卫生，怎么打扫是他们自己的事，反正最后一群对象合力把公司卫生打扫干净了。

**举例：**

*  买电脑（组装机）

先使用面向过程说明买电脑这件事：假如我们需要买组装电脑，这时首先会在网上查询具体每一个硬件的参数和报价。然后会去电脑城进行多家询价，接着询价结束后回家根据具体的结果分析出自己比较满意的哪家报价，接着会到这家店里进行组装，组装时还需要进行现场监督，组装完成安装相应的系统，然后电脑抱回家。

分析上述整个过程大体分一下几步：上网查询参数和报价、电脑城询价、现场安装和监督、抱电脑回家。在整个过程中我们参与了每一个细节，并且会感觉相当累。

使用面向对象说明买电脑这件事：假如我们需要买组装机，这时应该找一个懂电脑硬件的人，让他帮我们查看参数和报价，并进行询价和杀价，以及现场组装监督。而我们自己并不需要亲历亲为具体怎么做，只要告诉这个人我们想要的具体需求即可。

分析上述整个过程，发现瞬间变的十分轻松，只要找到懂电脑硬件的这个人，我们的问题都可以解决。并且在这个过程中我们不用那么辛苦。

**面向对象思维方式的好处：**

通过生活中的真实场景使用面向对象分析完之后，我们开始分析面向过程和面向对象的差异做出总结：

*    面向对象思维方式是一种更符合人们思考习惯的思想
 *    面向过程思维方式中更多的体现的是执行者（自己做事情），面向对象中更多的体现是指挥者（指挥对象做事情）。
 *    面向对象思维方式将复杂的问题简单化。

类和对象：

在我之前的篇[博客][Link 1]中，详细描述了类和对象，可以看看。

## 封装 ##

提起封装，大家并不陌生。前面我们学习方法时，就提起过，将具体功能封装到方法中，学习对象时，也提过将方法封装在类中，其实这些都是封装。

封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。接下来我们具体学习封装。

封装的表现：

1、方法就是一个最基本封装体。

2、类其实也是一个封装体。

从以上两点得出结论，封装的好处：

*  提高了代码的复用性。
 *  隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
 *  提高了安全性。

**封装举例：**

机箱：

一台电脑，它是由CPU、主板、显卡、内存、硬盘、电源等部件组长，其实我们将这些部件组装在一起就可以使用电脑了，但是发现这些部件都散落在外面，很容造成不安全因素，于是，使用机箱壳子，把这些部件都装在里面，并在机箱壳上留下一些插口等，若不留插口，大家想想会是什么情况。

总结：机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。

**私有private**

了解到封装在生活的体现之后，又要回到Java中，细说封装的在Java代码中的体现，先从描述Person说起。

描述人。Person

属性：年龄。

行为：说话：说出自己的年龄。

class Person {
        int age;
        String name;
    
        public void show() {
            System.out.println("age=" + age + ",name" + name);
        }
    }
    
    public class PersonDemo {
        public static void main(String[] args) {
            // 创建Person对象
            Person p = new Person();
            p.age = -20; // 给Person对象赋值
            p.name = "美女";
            p.show(); // 调用Person的show方法
        }
    }

通过上述代码发现，虽然我们用Java代码把Person描述清楚了，但有个严重的问题，就是Person中的属性的行为可以任意访问和使用。这明显不符合实际需求。

可是怎么才能不让访问呢？需要使用一个Java中的关键字也是一个修饰符 private(私有，权限修饰符)。只要将Person的属性和行为私有起来，这样就无法直接访问。

class Person {
        private int age;
        private String name;
    
        public void show() {
            System.out.println("age=" + age + ",name" + name);
        }
    }

年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，这样还是不行，那肿么办呢？按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。只要对外提供可以访问的方法，让其他程序访问这些方法。同时在方法中可以对数据进行验证。

一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。

class Person {
        // 私有成员变量
        private int age;
        private String name;
    
        // 对外提供设置成员变量的方法
        public void setAge(int a) {
            // 由于是设置成员变量的值，这里可以加入数据的验证
            if (a < 0 || a > 130) {
                System.out.println(a + "不符合年龄的数据范围");
                return;
            }
            age = a; 
        }
    
        // 对外提供访问成员变量的方法
        public void getAge() {
            return age;
        }
    }

*  总结：

类中不需要对外提供的内容都私有化，包括属性和方法。

以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。

*   注意：私有仅仅是封装的体现形式而已。

**this关键字：**

成员变量和局部变量重名的问题:

可以在成员变量名前面加上this.来区别成员变量和局部变量

class Person {
        private int age;
        private String name;
        public void speak() {
            this.name = "小强";
            this.age = 18;
            System.out.println("name=" + this.name + ",age=" + this.age);
        }
    }
    
    class PersonDemo {
        public static void main(String[] args) {
            Person p = new Person();
            p.speak();
        }
    }

对象内存的解释:

这里需要画图一步一步演示，严格按照画图流程讲解内存对象创建使用过程。

class Person {
        private int age;
        public int getAge() {
            return this.age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
    public class PersonDemo {
        public static void main(String[] args) {
            Person p = new Person();
            p.setAge(30);
            System.out.println("大家好，今年我" + p.getAge() + "岁");
        }
    }

![1408728-20181125183702645-1647498248.png][]

程序执行流程说明：

1、 先执行main方法（压栈），执行其中的 Person p = new Person()；

2、 在堆内存中开辟空间，并为其分配内存地址0x1234，紧接着成员变量默认初始化(age = 0)；将内存地址0x1234赋值给栈内中的Person p 变量

3、 继续执行p.setAge(30)语句，这时会调用setAge(int age)方法，将30赋值为setAge方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；

4、 setAge()方法执行完毕后（弹栈），回到main()方法，执行输出语句System.out.println()，控制台打印p对象中的age年龄值。

注意：

this到底代表什么呢？this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在的方法，this就代表哪个对象。

上述代码中的 p.setAge(30)语句中，setAge(int age)方法中的this代表的就是p对象。

**应用**:

需求：在Person类中定义功能，判断两个人是否是同龄人

class Person {
        private int age;
        private String name;
        
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void speak() {
            System.out.println("name=" + this.name + ",age=" + this.age);
        }
    
        // 判断是否为同龄人
        public boolean equalsAge(Person p) {
            // 使用当前调用该equalsAge方法对象的age和传递进来p的age进行比较
            // 由于无法确定具体是哪一个对象调用equalsAge方法，这里就可以使用this来代替
            /*
             * if(this.age == p.age) { return true; } return false;
             */
            return this.age == p.age;
        }
    }

现在总结this关键字：

*  this是在方法中使用的，那个对象调用了该方法，那么，this就代表调用该方法的对象引用
 *  this什么时候存在?当创建对象的时候,this存在
 *  this的作用:用来区别同名的成员变量与局部变量(this.成员变量)

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

## 继承 ##

概念:

在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如公司中的研发部员工和维护部员工都属于员工，程序中便可以描述为研发部员工和维护部员工继承自员工，同理，JavaEE工程师和Android工程师继承自研发部员工，而维网络维护工程师和硬件维护工程师继承自维护部员工。这些员工之间会形成一个继承体系，具体如下图所示。

![1408728-20181125181237671-215930855.png][]

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。

**继承的格式和使用**

格式：
    class 子类 extends 父类 {}

接下来通过一个代码来学习子类是如何继承父类的

/*
     * 定义员工类Employee
     */
    class Employee {
        String name; // 定义name属性
        // 定义员工的工作方法
        public void work() {
            System.out.println("尽心尽力地工作");
        }
    }
    
    /*
     * 定义研发部员工类Developer 继承 员工类Employee
     */
    class Developer extends Employee {
        // 定义一个打印name的方法
        public void printName() {
            System.out.println("name=" + name);
        }
    }
    
    /*
     * 定义测试类
     */
    public class Example01 {
        public static void main(String[] args) {
            Developer d = new Developer(); // 创建一个研发部员工类对象
            d.name = "小明"; // 为该员工类的name属性进行赋值
            d.printName(); // 调用该员工的printName()方法
            d.work(); // 调用Developer类继承来的work()方法
        }
    }

在上述代码中，Developer类通过extends关键字继承了Employee类，这样Developer类便是Employee类的子类。从运行结果不难看出，子类虽然没有定义name属性和work()方法，但是却能访问这两个成员。这就说明，子类在继承父类的时候，会自动拥有父类的成员。

**继承的好处和注意事项**

继承的好处：

1、继承的出现提高了代码的复用性，提高软件开发效率。

2、继承的出现让类与类之间产生了关系，提供了多态的前提。

在类的继承中，需要注意一些问题，具体如下：

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

class A{} 
         class B{}
         class C extends A,B{}  // C类不可以同时继承A类和B类

2、多个类可以继承一个父类，例如下面这种情况是允许的。

class A{}
         class B extends A{}
         class C extends A{}   // 类B和类C都可以继承类A

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。

class A{}
         class B extends A{}   // 类B继承类A，类B是类A的子类
         class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。

**继承-子父类中的成员变量的特点:**

了解了继承给我们带来的好处，提高了代码的复用性。继承让类与类或者说对象与对象之间产生了关系。那么，当继承出现后，类的成员之间产生了那些变化呢？

成员变量：如果子类父类中出现不同名的成员变量，这时的访问是没有任何问题。

class Fu
    {
        //Fu中的成员变量。
        int num = 5;
    }
    class Zi extends Fu
    {
        //Zi中的成员变量
        int num2 = 6;
        //Zi中的成员方法
        public void show()
        {
            //访问父类中的num
            System.out.println("Fu num="+num);
            //访问子类中的num2
            System.out.println("Zi num2="+num2);
        }
    }
    class Demo 
    {
        public static void main(String[] args) 
        {
            Zi z = new Zi(); //创建子类对象
            z.show(); //调用子类中的show方法
        }
    }

代码说明：Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类是不能直接访问的。

当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

在子类中，访问父类中的成员变量格式：
    super.父类中的成员变量

class Fu
    {
        //Fu中的成员变量。
        int num = 5;
    }
    class Zi extends Fu
    {
        //Zi中的成员变量
        int num = 6;
        void show()
        {
            //子父类中出现了同名的成员变量时
            //在子类中需要访问父类中非私有成员变量时，需要使用super关键字
            //访问父类中的num
            System.out.println("Fu num="+super.num);
            //访问子类中的num2
            System.out.println("Zi num2="+this.num);
        }
    }
    class Demo5 
    {
        public static void main(String[] args) 
        {
            Zi z = new Zi(); //创建子类对象
            z.show(); //调用子类中的show方法
        }
    }

**继承-子父类中成员方法特点-重写和应用**

子父类中成员方法的特点

当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

class Fu{
        public void show(){
            System.out.println("Fu类中的show方法执行");
        }
    }
    class Zi extends Fu{
        public void show2(){
            System.out.println("Zi类中的show2方法执行");
        }
    }
    public  class Test{
        public static void main(String[] args) {
            Zi z = new Zi();
            z.show(); //子类中没有show方法，但是可以找到父类方法去执行
            z.show2();
        }
    }

成员方法特殊情况——覆盖

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖。

class Fu
    {
        public void show()
        {
            System.out.println("Fu show");
        }
    }
    class Zi extends Fu
    {
        //子类复写了父类的show方法
        public void show()
        {
            System.out.println("Zi show");
        }
    }

方法重写（覆盖）的应用:

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

举例：比如手机，当描述一个手机时，它具有发短信，打电话，显示来电号码功能，后期由于手机需要在来电显示功能中增加显示姓名和头像，这时可以重新定义一个类描述智能手机，并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能，在其中增加显示姓名和头像功能。

在子类中，访问父类中的成员方法格式：
    super.父类中的成员方法();

public class Test {
        public static void main(String[] args) {
            new NewPhone().showNum();
        }
    }
    
    //手机类
    class Phone{
        public void sendMessage(){
            System.out.println("发短信");
        }
        public void call(){
            System.out.println("打电话");
        }
        public void showNum(){
            System.out.println("来电显示号码");
        }
    }
    
    //智能手机类
    class NewPhone extends Phone{
        
        //覆盖父类的来电显示号码功能，并增加自己的显示姓名和图片功能
        public void showNum(){
            //调用父类已经存在的功能使用super
            super.showNum();
            //增加自己特有显示姓名和图片功能
            System.out.println("显示来电姓名");
            System.out.println("显示头像");
        }
    }

方法重写的注意事项:

*  子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
 *      class Fu(){    
        void show(){}
            public void method(){}
        }
        class Zi() extends Fu{
        public void show(){}  //编译运行没问题
            void method(){}      //编译错误
        }
    
     
 *  写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。

总结：当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法重写。

我有一个微信公众号，经常会分享一些Java技术相关的干货；如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

[Link 1]: https://www.cnblogs.com/Young111/p/9904938.html
[1408728-20181125183702645-1647498248.png]: /images/20220414/5a755823e0c54023916fedc6c1459371.png
[1408728-20181125181237671-215930855.png]: /images/20220414/690d777d29734609959174f79a01d3f3.png