面向对象总结（下）

一、继承

1、  把多个类中的相同的属性和行为进行抽取，封装到一个类中，然后再建立新类的时候，不需要从头做起，继承刚才定义的那个类即可。

2、  继承的好处：

1）  提高了代码的复用性。

2）  让类与类之间产生了一个关系，是多态的前端。

3、  继承的弊端：

1）破坏了封装性。

2）提高了耦合性。

         4、继承的特点：

                   1）java只支持单继承。

                   2）java可以多层继承

         5、子类不能继承父类的私有成员和构造方法。

         6、继承中的成员的特点：

                   1）成员变量;

                            (1)一个属于this区域，一个属于super区域

                   2）构造方法

                            (1)子类构造在执行前会先执行父类构造。

                            (2)如果有继承关系，会有一个多层数据初始化。

                   3）成员方法：

                            (1)方法重写：

                                     <1>方法声明相同，最好和父类一模一样。

                                     <2>注意事项：

²  子类的返回值类型小于等于父类的返回值类型

²  子类的访问权限大于等于父类的访问权限

²  父类私有方法不能被重写

²  静态方法只能被静态方法重写

7、案例

         多个类中存在相同属性和行为时，将这些内容抽取出来，定义到一个类中。

         则这一个类为父类，多个类为子类。

 

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

         子类不可以直接访问父类的私有属性和行为。子类是看不到父类的私有方法的。

class Demo
{
         public static void main(String[] args)
         {
                   Person p = new Person();
                   p.eat();
                   System.out.println(p.age);
                   System.out.println(p.sex);
         }
}
class Animal
{
         int age;
         String sex;
 
         public void eat(){
                   System.out.println("吃了");
         }
}
 
//人类继承了动物
class Personextends Animal
{
}
//猴子继承了动物类
class Monkeyextends Animal
{
}
//海龟继承了动物类
class Turtleextends Animal
{
}

二、多态

1.      同一个对象在不同的时刻表现出来的状态。

1)      编译期类型和运行期类型不一致。

 2． 多态的前提：

         1)要有继承或者实现关系。

         2)要有方法重写：因为，很多时候，父类都是一个抽象的，如果没有方法重写，就没有意义。

         3)要有父类(或者父类接口)引用指向子类对象。

3.  多态的好处：

       1) 维护性

       2) 扩展性

4.  多态的弊端：

       1) 不能使用子类的特有功能

5.  类型转换

       1) 向上转型

       2) 向下转型

6.  多态中的成员的特点：

       1) 成员变量：编译看左边，运行看左边。

       2) 成员方法：编译看左边，运行看右边。

       3) 静态成员变量和静态成员方法：编译和运行都看左边。

7.  多态的体现形式：

       1) 具体类多态

       2) 抽象类多态

       3) 接口多态

三．抽象类

1. 多个具体的类中有相同的方法声明，方法体不同。我们把这多个方法声明给抽取出来了，而一个只有方法声明没有方法的方法在java中被称为抽象方法。并且，如果一个类中有抽象方法。那么，这个类也必须被定义为抽象类。

2. 抽象类的特点：

     1) 抽象类和抽象方法都必须用abstract修饰。

     2) 抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类。

     3) 抽象类不能被实例化。只能按照多态的的形式使用。

     4) 子类继承抽象类，要么本身是抽象类，要么重写父类所有抽象方法。

3. 抽象类的成员特点：

     1) 成员变量：可以是常量也可以是量。

     2) 构造方法：有。用于子类访问父类数据的初始化。

     3) 成员方法: 可以抽象也可以非抽象。

4. 抽象类的注意事项：

        1) 抽象类不能被实例化，那么还要构造方法干什么？

            用于子类方问父类数据的初始化。

2)  一个类中没有抽象方法，而该类却被定义为了抽象类，为什么？

为了让该类不能实例化

3)      Abstract不能和那些关键字共存？

Private    inal    static  

四．接口

         1.接口：如果一个抽象类中只有抽象方法，java就提供了一种更加抽象的表达方式，叫接口。

         2.接口的特点：

                   1)接口用interface定义

                   2)接口不能被实例化

                   3)接口中只有抽象方法

                   4)子类实现接口，要么本身就是抽象类，要么重写接口中所有抽象方法。

         3.接口的成员特点：

                   1)成员变量只能是常量。(public static final)

                   2)成员方法只能是抽象。(public abstrace)

         4.接口注意事项：

                   1)如果接口中没有内容，那么这样的接口有意义吗？

                            这样的接口是标记接口。

         5.抽象类和接口的区别：

                   1)成员的区别：

                            (1)抽象类的成员特点：

u  成员变量：可以常量,也可以变量。

u  构造方法：有。用于子类访问父类数据的初始化。

u  成员方法: 可以抽象也可以非抽象。

(2) 接口的成员特点：

u  成员变量：只能是常量。（publicstatic final）

u  成员方法: 只能是抽象。（publicabstract）

2) 关系区别：

         (1) 类与类：继承关系，只能是但继承。可以多层继承。

         (2) 类与接口：实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口。

         (3) 接口与接口：继承关系：可以单继承，也可以多继承。

     3) 设计区别：

          (1) 抽象类被继承体现的是：is a的关系。它里面定义的是该体系的共性功能。

          (2) 接口被实现体现的是：like a 的关系。它里面定义的是该体系的扩展功能。

五．内部类

         1.定义：内部类是把一个类定义在另一个类的内部。

         2.访问特点：

                   1)内部类可以直接访问外部类成员，包括私有。

                   2)外部类要想访问内部类成员，必须创建对象。

         3.按照位置划分内部类：

                   1)成员位置：成员内部类：private static

                   2)局部位置：局部内部类

                            (1)匿名内部类：

u  前提：存在一个类或者接口

u  格式：newParentName(){//内部类的定义}

u  理解：本质是一个继承了父类或者实现了接口的子类匿名对象。

六．关键词总结

         1.访问权限修饰符：public  protected  default  private(权限由大到小)

         2.引用修饰符：this  super

         3.抽象类关联：abstract  extends

         4.接口关联：interface  implements

         5.状态修饰符：static  final