面向对象三大特征：继承、封装、多态 （泛型）

时间  2019-12-07 标签 面向对象 三大 特征 继承 封装

封装：封装是一个概念，它的含义是把方法、属性、事件集中到一个统一的类中，并对使用者屏蔽其中的细节问题。数据被保护在抽象数据类型的内部，尽量地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。html

好比咱们将一个房子看作是一个对象，里面的漂亮的装饰，如沙发、电视剧、空调、茶桌等等都是该房子的私有属性，可是若是咱们没有那些墙遮挡，是否是别人就会尽收眼底呢？没有一点儿隐私！就是存在那个遮挡的墙，咱们既可以有本身的隐私，并且咱们能够随意的更改里面的摆设而不会影响到其余的。可是若是没有门窗，一个包裹的严严实实的黑盒子，又有什么存在的意义呢？因此经过门窗别人也可以看到里面的风景。因此说门窗就是房子对象留给外界访问的接口。java

使用封装的好处：设计模式

1、类内部的结构能够自由修改。架构

2、隐藏信息，实现细节。app

3、能够对成员进行更精确的控制。（若是输入有问题的时候，能够在调用的时候进行判断。）框架

4，封装确实可使咱们容易地修改类的内部实现，而无需修改使用了该类的客户代码。性能

通常咱们写的类的属性就是用的封装的思想，里面的属性都是private，好比：优化

public class Husband {  
     private String name ;  
     private String sex ;  
     private int age ;  
     private Wife wife; 
}

而后外部经过getter和setter方法去访问这个类里面的数据，

Husband husband=new Husband();ui

husband.setName(xx);//更改Husband类里面的name的时候用，this

husband.getName();//得到husband对象里面的name

01.public class Husband {  
02.      
03.    /* 
04.     * 对属性的封装 
05.     * 一我的的姓名、性别、年龄、妻子都是这我的的私有属性 
06.     */  
07.    private String name ;  
08.    private String sex ;  
09.    private int age ;  
10.    private Wife wife;  
11.      
12.    /* 
13.     * setter()、getter()是该对象对外开发的接口 
14.     */  
15.    public String getName() {  
16.        return name;  
17.    }  
18.  
19.    public void setName(String name) {  
20.        this.name = name;  
21.    }  
22.  
23.    public String getSex() {  
24.        return sex;  
25.    }  
26.  
27.    public void setSex(String sex) {  
28.        this.sex = sex;  
29.    }  
30.  
31.    public int getAge() {  
32.        return age;  
33.    }  
34.  
35.    public void setAge(int age) {  
36.        this.age = age;  
37.    }  
38.  
39.    public void setWife(Wife wife) {  
40.        this.wife = wife;  
41.    }  
42.}


继承：若是两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中能够调用父类的方法和变量，若是想要在子类里面作一系列事情，应该放在父类无参构造器里面。在java中，只容许单继承，也就是说一个类最多只能显示地继承于一个父类。可是一个类却能够被多个类继承，也就是说一个类能够拥有多个子类。

java类不容许多继承。缘由：

1，当不一样的父类存在相同属性方法的时候，没法断定调用哪一个。

2，因为子类实例化须要调用父类的无参构造器，没法识别是那个父类的构造器，

1.子类继承父类的成员变量

　　当子类继承了某个类以后，即可以使用父类中的成员变量，可是并非彻底继承父类的全部成员变量。具体的原则以下：

1）可以继承父类的public和protected成员变量；不可以继承父类的private成员变量；

2）对于父类的包访问权限成员变量，若是子类和父类在同一个包下，则子类可以继承；不然，子类不可以继承；

3）对于子类能够继承的父类成员变量，若是在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。若是要在子类中访问父类中同名成员变量，须要使用super关键字来进行引用。super.属性名

2.子类继承父类的方法

　　一样地，子类也并非彻底继承父类的全部方法。

1）可以继承父类的public和protected成员方法；不可以继承父类的private成员方法；

2）对于父类的包访问权限成员方法，若是子类和父类在同一个包下，则子类可以继承；不然，子类不可以继承；

3）对于子类能够继承的父类成员方法，若是在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。若是要在子类中访问父类中同名成员方法，须要使用super关键字来进行引用。super.方法名（形参列表）

　　注意：隐藏和覆盖是不一样的。隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。隐藏：调用的时候用谁的引用，则调用谁的版本。

3.构造器

子类是不可以继承父类的构造器，可是要注意的是，

若是父类的构造器只带有参数的，则必须在子类的构造器中显示地经过super关键字调用父类的构造器并配以适当的参数列表，若是不想用super调用，那父类必定要有一个显示声明的无参构造器。

若是父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，若是没有使用super关键字，系统会自动调用父类的无参构造器。

4.super

super主要有两种用法：

1）super.成员变量/super.成员方法;

2）super(parameter1,parameter2....)

　　第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，若是是用在子类构造器中，则必须是子类构造器的第一个语句。

好比：下面的类DBHelper继承与SQLiteOpenHelper,DBHelper类里面的构造器调用了父类的构造器，


5.重写父类的方法：

1）子类必须与父类使用相同的方法名、参数列表，

2）子类的访问权限不能比父类的更严格

3）子类返回值类型<=父类的返回值类型的范围

4）若是父类使用static修饰，则子类必须用static

5）若是父类的方法用了final，则子类不能重写该方法

若是父类必需要本身的每个子类都重写本身的某个方法，则把父类的该方法写成抽象的方法，则子类继承的时候自动的重写该方法。

例如：


上面的类是为了以后写的BaseAdapter子类都继承与ParentAdapter，这样就不用再去重写BaseAdapter里面的getItemId(),getCount(),getItem()这三个方法，只须要重写getView()就能够了，原本把getView()方法定义成abstarct就能够了，可是由于getView是重写的，因此咱们只能更改方法体里面的，其余都不能更改，包括返回值，关键字，因此把ParentAdapter类定义成抽象的，这样子类都必须从新getView().

  重载：

在同一个类中存在同名的方法

1）重载方法名必须形同

2）参数列表必须不一样

  重构


重构就是经过调整程序代码改善软件的质量、性能，使其程序的设计模式和架构更趋合理，提升软件的扩展性和维护性。总的来讲就是代码优化。

 

多态：多态性是指相同的操做可做用于多种类型的对象上并得到不一样的结果。不一样的对象，收到同一消息能够产生不一样的结果，这种现象称为多态性。

多态：父类型的引用能够指向子类型的对象。


多态，是面向对象的程序设计语言最核心的特征。多态，意味着一个对象有着多重特征，能够在特定的状况下，表现不一样的状态，从而对应着不一样的属性和方法。从程序设计的角度而言，多态能够这样来实现（以java语言为例）：

public interface Parent//父类接口{
    public void simpleCall();
  }

 public class Child_A implements Parent{
    public void simpleCall();{
    //具体的实现细节；
    }
  }
 
  public class Child_B implements Parent{
    public void simpleCall();{
    //具体的实现细节；
    }
  }

而后，咱们就能够看到多态所展现的特性了：
Parent pa = new Child_A();pa.simpleCall()则显然是调用Child_A的方法；
Parent pa = new Child_B();pa.simpleCall()则是在调用Child_B的方法。
因此，咱们对于抽象的父类或者接口给出了咱们的具体实现后，pa 能够彻底不用管实现的细节，只访问咱们定义的方法，就能够了。事实上，这就是多态所起的做用，能够实现 控制反转这在大量的J2EE 轻量级框架中被用到，好比 Spring的依赖注入机制。







泛型：

泛型是对数据类型的抽象，体现了参数的多态性


(1)定义泛型属性：

咱们常常在定义一个集合的时候，还不肯定是线性链表ArrayList仍是LinkedList，或者是其余，这个时候，在类里面定义的时候咱们多用泛型;List list;

在使用的时候，list=new ArrayList();

一样的，咱们在定义变量的时候，为了增长代码的可扩展性，咱们可使用泛型定义，好比：ArrayList<T> list;

在使用的时候，根据须要传入对象，好比我如今须要创一个String类型的list，那么list=new ArrayList<String>();



(2)定义泛型类

是在实例化类的时候指明泛型的具体类型；

这个时候用的T也是用的多态的思想，由于咱们不知道子类会传什么对象过来，同时这样写也增长了子类的扩展性，

子类就能够像下面这样根据本身的须要传入对象：





(3)定义泛型方法：

是在调用方法的时候指明泛型的具体类型。


图片信息来源：http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html

定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，


/**  * 将对象转化为String  *  * @param object  * @return  */  public static  <T>  String objectToString(T object) {
    if (object == null) {
        return "Object{object is null}";
    }
    if (object.toString().startsWith(object.getClass().getName() + "@")) {
        StringBuilder builder = new StringBuilder(object.getClass().getSimpleName() + " { ");
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            boolean flag = false;
            for (String type : types) {
                if (field.getType().getName().equalsIgnoreCase(type)) {
                    flag = true;
                    Object value = null;
                    try {
                        value = field.get(object);
                    } catch (IllegalAccessException e) {
                        value = e;
                    } finally {
                        builder.append(String.format("%s=%s, ", field.getName(),
                                value == null ? "null" : value.toString()));
                        break;
                    }
                }
            }
            if (!flag) {
                builder.append(String.format("%s=%s, ", field.getName(), "Object"));
            }
        }
        return builder.replace(builder.length() - 2, builder.length() - 1, " }").toString();
    } else {
        return object.toString();
    }
}

上面定义了方法，在使用的时候：

ActiveJumpEntity entity;
entity = new ActiveJumpEntity(101, "13991193813", "111", "11",  "重庆", "南岸区", "重庆市南岸区四千米");
String string = objectToString(entity);

调用的时候，传入的是entity，也就是ActiveJumpEntity的对象。这样的写法，便于扩展，这样一个方法能够用在不少不一样的对象上面，好比上面这个方法，是把一个类对象转化成String，便于咱们打印Log，若是直接用Log打印传入这个entity，那么打印的是entity的地址，而咱们的想法是看到对象内部的具体值，因此就用泛型方法的思想写这样的一个方法objectToString() ,以后就能够传入不一样的类，扩展性很强。


网友说多态与泛型没有关系，不过我暂时还不能理解。

联系我们 沪ICP备13005482号-10