java的三大特性----封装、集成、多态

当我们被问到你对java的封装、继承、多态是什么看法的时候，你会想到什么？

想到的会不会是封装就是将类的成员属性用privet修饰一下，达到私有化的目的，只暴露方法，从而达到成员变量私有化的目的。

而继承就是子类继承父类，重写父类的非私有化方法，获得父类的非私有化属性

而多态就是基于继承、重写。而达到相同的消息使得不同的类做出不同的响应。

面向对象的三大特性：

1、封装：主要实现了隐藏细节，对用户提供访问接口，无需关心方法的具体实现。 

2、继承：很好的实现了代码的复用，提高了编程效率。 

3、多态：程序的可扩展性及可维护性增强。

一、封装

封装从字面上来理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节，但可以通过该对象对外的提供的接口来访问该对象。

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有三大好处：

1、良好的封装能够减少耦合。

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

3、可以对成员进行更精确的控制。

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

封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果不想被外界方法，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

public class Husband {  

      

    /* 

     * 对属性的封装 

     * 一个人的姓名、性别、年龄、妻子都是这个人的私有属性 

     /  

    private String name ;  

    private String sex ;  

    private int age ;  

    private Wife wife;  

      

    / 

     * setter()、getter()是该对象对外开发的接口 

     */  

    public String getName() {  

        return name;  

    }  

  

    public void setName(String name) {  

        this.name = name;  

    }  

  

    public String getSex() {  

        return sex;  

    }  

  

    public void setSex(String sex) {  

        this.sex = sex;  

    }  

  

    public int getAge() {  

        return age;  

    }  

  

    public void setAge(int age) {  

        this.age = age;  

    }  

  

    public void setWife(Wife wife) {  

        this.wife = wife;  

    }  

}

封装可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码。就可以对成员变量进行更精确的控制。

`public void setAge(int age) {

if(age > 120){

System.out.println("ERROR：error age input....");    //提示错误信息

}else{

this.age = age;

}

}

public String getSexName() {

if("0".equals(sex)){

sexName = "女";

}

else if("1".equals(sex)){

sexName = "男";

}

else{  

             sexName = "人妖";  

         }

return sexName;

}  `

版权声明：本文为CSDN博主「jianyuerensheng」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：https://blog.csdn.net/jianyuerensheng/article/details/51602015

二、继承

1、继承的关键词

extends

例如：  class B extends A  {}

则表示B类继承了A类

java仅支持"单一继承"

继承的好处： 实现代码的重用。

java.lang.Object是所有类的超类。

2、子类可以继承父类的哪些内容？

a、成员变量

b、成员方法

c、构造方法不能继承

3、子类创建对象时，会调用父类的构造方法吗？构造方法的调用顺序？

会调用父类的构造方法。

先调用父类的构造方法，再调用子类的构造方法

4、子类可以有自己扩展的属性和方法？

可以。

父类中存放的是所有子类共有的属性和方法 。 因此 父类更加通用。

子类除了继承父类的属性和方法外，还可以有自己扩展的属性和方法，因此子类更具体。

5 继承关系中的父类如何得到？

类：具有相同属性和方法的一组对象"抽象"而得

父类：具有大量相同代码（属性和方法)一组类的”抽象"

子类和父类之间存在 is -a 的关系

2、方法的覆盖

1、什么是方法重写？

在子类中定义了一个与父类相同的方法  ==》子类覆盖了父类的方法，或子类重写了父类的方法

2、方法重写的特点？

a、在继承关系的子类中

b、子类的方法名和参数与父类的方法名和参数相同

c、子类中的方法的访问权限不可低于父类的访问权限

d、子类中的返回值类型与父类的返回值类型一致，或是父类方法返回值类型的子类类型

e、子类的方法不能声明比父类更宽泛的异常

3、何时方法重写？

当父类中的方法不能满足子类功能的需求时，在子类中重写父类中的方法

4、注意事项：

a) 子类重写了父类的方法，子类对象调用方法时，调用子类重写后的方法

b) 子类中的方法的参数与父类不同，则不是方法重写，而是在子类中构成了方法的重载。

可以在子类方法不添加"@Override"验证重写的格式是否正确

c) 方法重写仅对于成员方法，同时某些方法是不能重写的

i. 私有的成员方法不能重写

ii. 父类中的final方法不能重写

iii. 父类中的静态方法不能重写

iv. 成员变量不存在重写

3、super关键字

1、super是什么？

super关键词不是引用，super中存储的不是内存地址，super指向的不是父类对象

super代表的是当前子类对象中的父类型特征。

2、何时使用

子类和父类中有相同名称的属性时，使用super.属性名访问父类的属性

3、supe可以用在什么地方？

3.1 super在子类的成员方法中使用

super.属性名：访问的是父类中的属性

super.方法名(参数):访问的是父类中的成员方法

3.2 super可以在子类的构造方法中使用，调用父类的构造方法。

语法：super(参数)  必须写在子类构造方法的"第一行"

三、多态

1 多态的前提

1.1 继承的存在

1.2 方法重写

2 多态表现方式：

2.1 语法：

父类类型  引用名= new 子类类型();

2.2 多 态的一般格式为：方法的参数

使用一个方法可以对应父类的所有子类。

1. 将父类的引用做为方法的形参。
   
   2)将子类的实例做为方法的实参。
   
   3 多态的好处：
   
   3.1  满足开发的原则：  开-闭原则
   
   开： 对功能的扩展开放。---》创建新的子类，通过方法重写修改原父类中的方法的功能。
   
   闭合 ：对原有代码的修改是闭合。 同时保证原有功能和新功能都可以执行。==》以多态的方式，在不修改原代码的情况下使用子类
   
   3.2 多态的作用： 代码的复用，易扩展。易维护。

引用类型之间的类型转换： 前提类之间有继承关系

1、向上转型 父类类型的引用 引用 子类对象

1） 语法： 父类类型  引用名= new 子类类型();

2）父类型的引用可以访问哪此方法

a 、父类中声明的方法

b、如果子类中重写了父类的方法，则执行子类重写后的方法

c、 不能访问子类中特有的方法。

3） 示例：

 

2、向下转型

1） 语法：

（子类类型)父类引用;  //父类引用所引用的对象为子类对象

2) 向下转型是不安全的。 引发异常： java.lang.ClassCastException

3）向下转型 之间使用instanceof关键词判断。

语法：

引用名  instanceof 类名或接口名

编译期： instanceof 类名  与引用名的类型之间有继承关系，无则编译错误！

运行期： 引用的对象的类型为 "instanceof 类"的同类或子类  返回true, 其他 返回false

多态的好处