黑马程序员--面向对象的特征（继承、多态、内部类等）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承

继承是面向对象编程的重要特征之一。继承就是在现有类的基础上构建新类以满足新的要求。在继承过程中，新的类继承原本的方法和实例变量，并且能添加自己的方法和实例变量。

1、继承的好处

提高了代码的复用性。

让类与类之间产生了关系，提供了另一个特征多态的前提。

2、继承的使用

通过extends关键字让类与类之间产生继承关系。多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有的属性和行为。

子类无法继承父类中私有的内容。

父类的由来其实是由多个类不断向上抽取共性内容而来的。

3、继承的特点

Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。但是java支持多重继承。A继承B  B继承C  C继承D。多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。

4、在子父类中，成员的特点体现

成员变量

子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。

     如果想要调用父类中的属性值，需要使用一个关键字：super

     this：代表是本类类型的对象引用。

     super：代表是子类所属的父类中的内存空间引用。

当本类的成员和局部变量同名用this区分。

当子父类中的成员变量同名用super区分父类。

注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。

 

成员函数

当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。这种现象，称为覆盖操作，这是函数在子父类中的特性。在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

 

构造函数

发现子类构造函数运行时，先运行了父类的构造函数，这是因为在子类的构造函数中，第一行有一个默认的隐式语句：super();。

 

 

5、子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数。因为每一个构造函数的第一行都有一条默认的语句super();。

super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。

注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();

如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。

如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

 

6、方法覆盖

在父类中实现的方法可能不够精确，不满足子类的需求，子类中就重新定义了该方法，叫做覆盖。

覆盖中注意：

子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。

覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)

 

7、final关键字

编写程序时可能需要把类定义为不能继承的，即最终类，或者有的方法不希望被子类继承，这时候就需要使用fianl关键字来声明。把类或方法声明为final类或final方法的方法很简单，在类前面加上final关键字即可。

特点：

final是一个修饰符，可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量，只能赋值一次。

为什么要用final修饰变量。其实在程序如果一个数据是固定的，那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。而且这个变量名称的值不能变化，所以加上final固定。写法规范：常量所有字母都大写，多个单词，中间用_连接.

二、抽象类（abstract）

抽象：笼统，模糊，看不懂，不具体，看不明白。抽象类表象体现。

在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。

抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

抽象类的特点：

1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。

2：抽象方法只定义方法声明，并不定义方法实现。

3：抽象类不可以被创建对象(实例化)。

4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

 

抽象类的细节：

1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。

2：抽象类中是否可以定义非抽象方法？

     可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。

3：抽象关键字abstract和哪些不可以共存？final , private , static

4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

 

三、接口

接口是java提供的一项非常重要的结构。它定义了一系列的抽象方法和常量，形成一个属性集合。接口定义完成后任何类都可以实现接口，而且一个类可以实现多个接口。实现接口的类必须实现接口中定义的抽象方法，具体实现细节类自己定义。可以说接口定义了类的框架，它实际上是一种完全的抽象类

 

1、  接口的定义

修饰符interface 接口名

{//接口内容

//声明变量

类型 变量名；

……

//声明方法

 返回值类型 方法名（）；

……

}

 

1：是用关键字interface定义的。

2：接口中包含的成员，最常见的有全局常量、抽象方法。

注意：接口中的成员都有固定的修饰符，接口中的成员都是公共的权限。

     成员变量：public static final

  成员方法：public abstract

interface Inter{

    publicstatic final int x = 3;

     publicabstract void show();

}

3：接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

4：类与类之间存在着继承关系，类与接口中间存在的是实现关系。

    继承用extends  ；实现用implements ；

5：接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多实现来体现。

6：一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。

7：其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。

 

2、接口都用于设计上，设计上的特点：（可以理解主板上提供的接口）

1：接口是对外提供的规则。

2：接口是功能的扩展。

3：接口的出现降低了耦合性。

 

3、抽象类与接口：

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

抽象类和接口的共性：都是不断向上抽取的结果。

 

4、抽象类和接口的区别：

1：抽象类只能被继承，而且只能单继承。

接口需要被实现，而且可以多实现。

2：抽象类中可以定义非抽象方法，子类可以直接继承使用。

接口中都是抽象方法，需要子类去实现。

3：抽象类使用的是  is a 关系。

接口使用的 like a 关系。

4：抽象类的成员修饰符可以自定义。

接中的成员修饰符是固定的。全都是public的。

在开发之前，先定义规则，A和B分别开发，A负责实现这个规则，B负责使用这个规则。至于A是如何对规则具体实现的，B是不需要知道的。这样这个接口的出现就降低了A和B直接耦合性。

四、多态

多态是面向对象语言的又一重要特性。函数本身就具备多态性，某一种事物有不同的具体的体现。 

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

    1：必须要有关系，比如继承、或者实现。

    2：通常会有覆盖操作。

多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

class 毕姥爷{void 讲课(){System.out.println("企业管理");}void 钓鱼(){System.out.println("钓鱼");}}class 毕老师 extends 毕姥爷{void 讲课(){System.out.println("JAVA");}void 看电影(){System.out.println("看电影");}}class {public static void main(String[] args) {毕姥爷 x = new 毕老师(); //毕老师对象被提升为了毕姥爷类型。 //x.讲课();//x.看电影();  //错误.毕老师 y = (毕老师)x; //将毕姥爷类型强制转换成毕老师类型。 y.看电影();//在多态中，自始自终都是子类对象在做着类型的变化。}}

如果想用子类对象的特有方法，如何判断对象是哪个具体的子类类型呢？

可以可以通过一个关键字instanceof ;//判断对象是否实现了指定的接口或继承了指定的类

 

格式：<对象 instanceof 类型>，判断一个对象是否所属于指定的类型。

Student instanceof Person = true;//student继承了person类

 

多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。

    在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

    再说的更容易记忆一些：成员变量 --- 编译运行都看 = 左边。

2，成员函数。

    编译时期：参考引用型变量所属的类中是否有调用的方法。

    运行事情：参考的是对象所属的类中是否有调用的方法。

    为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

    简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

    更简单：成员函数 --- 编译看 = 左边，运行看 = 右边。

3，静态函数。

    编译时期：参考的是引用型变量所属的类中是否有调用的成员。

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

    调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。

    简单说：静态函数 --- 编译运行都看 = 左边。

五、内部类

1、  内部类的定义

内部类是定义在其他类内部的类，内部类所在的类称为宿主类。内部类是Java提供的一个非常有用的特性，通过内部类的定义，可以把一些相关的类放在一起。由于内部类只能被它的宿主类使用，所以通过内部类的使用可以很好地控制类的可见性。

class Outer{

    int num = 4;   

    class  Inner {

        void show(){

            System.out.println("innershow run "+num);         

        }

    }

    public void method(){

        Inner in = new Inner();//创建内部类的对象。

        in.show();//调用内部类的方法。

    }

}

 

2、  内部类的特点

内部类可以直接访问外部类中的成员。而外部类想要访问内部类，必须要建立内部类的对象。

3、  内部类的位置

当内部类定义在外部类中的成员位置上，可以使用一些成员修饰符修饰 private、static。

1：默认修饰符。

直接访问内部类格式：外部类名.内部类名 变量名 =  外部类对象.内部类对象;

Outer.Inner in = new Outer.newInner();//这种形式很少用。

     但是这种应用不多见，因为内部类之所以定义在内部就是为了封装。想要获取内部类对象通常都通过外部类的方法来获取。这样可以对内部类对象进行控制。

2：私有修饰符。

     通常内部类被封装，都会被私有化，因为封装性不让其他程序直接访问。

3：静态修饰符。

如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。

     注意；如果内部类中定义了静态成员，那么该内部类必须是静态的。

 内部类编译后的文件名为：“外部类名$内部类名.java”；

为什么内部类可以直接访问外部类中的成员呢？

那是因为内部中都持有一个外部类的引用。这个是引用是外部类名.this

  内部类定义在局部位置上， 也可以直接访问外部类中的成员。

当内部类被定义在局部位置上，只能访问局部中被final修饰的局部变量。

4、  匿名内部类

定义：没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。
前提：内部类可以继承或实现一个外部类或者接口。
格式：new 外部类名或者接口名(){覆盖类或者接口中的代码， (也可以自定义内容。 )}
简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象。
匿名内部类的使用场景：

当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。

其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。

好处：增强阅读性。

 

六、Object

所有类的直接或者间接父类，Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

具体方法：

1，boolean equals(Objectobj)：用于比较两个对象是否相等，其实内部比较的就是两个对象地址。

而根据对象的属性不同，判断对象是否相同的具体内容也不一样。所以在定义类时，一般都会复写equals方法，建立本类特有的判断对象是否相同的依据。

  public boolean equals(Object obj){

      if(!(objinstanceof Person))

          return false;

      Personp = (Person)obj;

      returnthis.age == p.age;

  }

2，String toString()：将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName() + '@' +Integer.toHexString(hashCode())

  为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。

  public String toString(){

      return"person : "+age;

  }

3，Class getClass()：获取任意对象运行时的所属字节码文件对象。

4，int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。

 

通常equals，toString，hashCode，在应用中都会被复写，建立具体对象的特有的内容。