黑马程序员_Java面向对象3

------- android培训、java培训、期待与您交流！ ----------

Java面向对象3

一：多态

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

2.针对引用类型：
   编译期间状态。
   运行期间状态。

3.举例：

            水(水,冰,水蒸气)

            狗：狗是狗，狗是动物，狗是宠物，狗是食物

4.前提条件：
(1).要有继承关系。

(2).要有方法重写。

(3).要有父类引用指向子类对象。

5.代码体现

class Fu {
          public void show() {
                     System.out.println("fu show");
          }
}

class Zi extends Fu {
          public void show() {
                     System.out.println("zi show");
          }
}

class DuoTaiDemo {
          public static void main(String[] args) {
                     Fu f = new Fu();//f是Fu的引用

                     Zi z = new Zi();//new Zi()是Zi的对象

                     //多态

                     Fu fu = new Zi();
         }
}

6.多态间的成员特点：方法有重写。而变量没有。

(1).成员变量
                    编译看左边,运行看左边。

(2).成员方法
                    编译看左边,运行看右边。

7.多态弊端:父类引用不能使用子类特有功能。

(1).基本类型：隐式转换(小到大)，强制转换(大到小)。

(2).引用类型：向上转型(小到大)，向下转型(大到小)。

(3).代码体现

class Fu {
          public void show() {
                     System.out.println("fu show");

          }
}

class Zi extends Fu {
          public void show() {
                     System.out.println("zi show");
          }

          public void method() {
                     System.out.println("zi method");
          }
}

class DuoTaiDemo3  {
          public static void main(String[] args)  {
                      //多态
                      Fu f = new Zi(); //向上转型
                      f.show();
                      //f.method();

                      /*
                     Zi z = new Zi();
                     z.show();
                     z.method();
                     */
                     Zi z = (Zi)f; //向下转型
                     z.show();
                     z.method();

          }
}

8.多态的好处：为了提高代码的扩展性和可维护性。

二：抽象类

1.思想

class Dog {

          public void eat() {
                     System.out.println("eat 骨头");

          }
}

class Cat  {

          public void eat() {
                     System.out.println("eat 鱼");

          }
}

目前来看，这两个类能不能抽取内容呢?

能。因为他们的方法声明是相同的。

所以，就抽取了方法的声明。

abstract class Animal {
               public abstract void eat();
}

针对没有方法体的方法，java提供了一种表示形式：抽象方法。
这个时候，就有了一个关键字用来表示抽象的意思：abstract

class Dog extends Animal {

          public void eat() {
                     System.out.println("eat 骨头");
          }
}

class Cat extends Animal {

          public void eat() {
                     System.out.println("eat 鱼");
          }
}

2.由来：

            从很多对象中抽取方法声明，从而定义在一个新的类中。

            没有方法体的方法被称为抽象方法。有抽象方法的类被称为抽象类。


3.抽象类的特点：
(1).抽象方法和抽象类用关键字abstract表示。

(2).有抽象方法的类一定是抽象类(或者接口)。

      抽象类中不一定有抽象方法。

(3).抽象类不能被实例化。

     那么，怎么实例化呢?

     通过子类对象进行实例化。

(4).如果一个类继承抽象类，

     那么这个类要么本身也是抽象类。
     这个类重写父类的所有抽象方法。

4.在继承中，我们为什么有些时候，会选择父类是抽象类?
   作用：强制要求子类必须完成某些功能。

代码体现

abstract class Animal {
               public abstract void eat();
}

class Dog extends Animal {
          public void eat() {

                     System.out.println("eat dog");

          }
}

class AbstractDemo {
          public static void main(String[] args)  {
                      //创建对象 抽象类不能实例化
                      //Animal a = new Animal();

                      //抽象类的多态
                      Animal a = new Dog();
                      a.eat();
          }
}

5.抽象类的成员特点：
(1).成员变量 可以有成员变量，也可以有常量。

(2).构造方法 有构造方法的。
      既然不能被实例化，那么有构造方法有什么用?
      可以用于子类访问父类数据前，对父类数据进行初始化。

(3).成员方法
      可以有抽象方法，也可以有非抽象方法。
      抽象方法是为了要求子类做某些事情。
      非抽象方法是为了提高代码复用性，被子类继承。

三：接口

1.思想

abstract class Animal {
               public abstract void eat();
}

这个抽象类中，只有抽象方法。针对这种情况，java就提供了一种更加抽象的表示形式：接口
类我们知道，用class表示，那么接口用什么表示呢?interface.
这样的话,就可以把上面的抽象类改写:

interface Animal {
                public abstract void eat();
}

有了接口该怎么用呢?
必须也要有具体的类来实现。
用哪个关键字表示呢?implements

格式：
class 类名 implements 接口名
        {

        }

class Cat implements Animal {
          public void eat() {
                     System.out.println("eat cat");
          }
}

class Dog implements Animal {
          public void eat() {
                     System.out.println("eat dog");
          }
}

Cat c = new Cat();
c.eat();

Dog d = new Dog();
d.eat();

接口多态：

Animal a = new Cat();
a = new Dog();

2.接口:是一种特殊的抽象类。比抽象类更抽象。因为它里面的方法都是抽象的。

3.接口的特点：

(1).接口不能被实例化。

(2).接口中的方法：
     要么被子类重写。
     要么子类也是抽象类。

4.代码体现

interface Animal {
                public abstract void eat();
}

class Dog implements Animal {
          public void eat() {
                     System.out.println("eat dog");
          }
}

class InterfaceDemo  {
          public static void main(String[] args) {
                      //错误
                      //Animal a = new Animal();
                      Dog d = new Dog();
                      d.eat();

                      //接口多态

                      Animal a = new Dog();

                      a.eat();
         }
}

5.接口的成员特点：
(1).成员变量:接口中只有常量。

     因为接口的成员变量有默认修饰符:public static final

     推荐:永远自己给出修饰符。

(2).构造方法：

     没有构造方法。

     任何类如果没有继承父类，那么这个类就继承自Object类。

(3).成员方法：接口中的方法都是抽象的。
                        因为接口中的成员方法有默认修饰符:public abstract
                        推荐:永远自己给出修饰符。

(6).类和接口的关系：
A.类与类关系:继承关系。而且只能单继承，可以多层继承。

B.类与接口的关系：
    实现关系。可以单实现，也可以多实现。

    并且还可以在继承一个类的同时，实现多个接口。

C.接口与接口的关系:继承关系。可以单继承，也可以多继承。

(7).接口和抽象类的特点：

A.成员特点
抽象类：
            成员变量：可以是变量，也可以是常量。
            构造方法：有构造方法。
            成员方法：可以是抽象方法，也可以是非抽象方法。

接口：
            成员变量：只能是常量。
            默认修饰符：public static final
            成员方法：只能是抽象方法。
            默认修饰符：public abstract

B.关系特点

类与类：
             继承关系,只能单继承,可以多层继承。

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

接口与接口：
                    继承关系,可以单继承,也可以多继承。

C.设计理念的区别
抽象类被继承,这个类中定义的是整个继承体现的共性内容。
体现：is a 

接口被实现,这个接口中定义的是整个体现的扩展内容。

体现：like a

四：总结

1.多态
(1).对象在不同时刻表现出来的不同状态。
     举例：水(冰，水，水蒸气)

(2).多态的前提
A.要有继承或者实现关系。

B.要有方法的重写。

C.要有父类引用或者父接口引用指向子类对象。

注意：多态有三种体现形式
           类多态
           抽象类多态
           接口多态

(3).多态中的成员特点：

A.成员变量
                  编译看左边，运行看左边。
B.成员方法
                  编译看边，运行看右边。

(4).多态的弊端：

                        父类(接口)引用不能使用子类特有功能。
                        为了解决这个弊端，我们需要向下转型。

                        Fu f = new Zi(); //向上转型
                        Zi z = (Zi)f; //向下转型

                        Zi z = new Zi();

(5).多态的好处：
                        可以提高代码的扩展性和可维护性。

2.抽象类
(1).如果多个类中存在相同的方法声明，而方法体不一样，我们就可以只提取方法声明。

     如果一个方法只有方法声明，没有方法体，那么这个方法必须用抽象修饰。
     而一个类中如果有抽象方法，这个类必须定义为抽象类。

(2).抽象类的特点
A.抽象类和抽象方法必须使用abstract修饰

B.抽象类不能被实例化

C.抽象类有抽象方法，用于子类实例化使用

D.如果一个类是抽象类，那么，继承它的子类
    要么是抽象类。
    要么重写所有抽象方法。

(3).抽象类的成员特点
A.成员变量    可以是变量，也可以是常量

B.构造方法    有构造方法

C.成员方法    可以是抽象方法，也可以是非抽象方法

(4).抽象类的几个小问题
A.抽象类不能被实例化，为什么有构造?
    用于子类实例化使用。

B.一个类没有抽象方法，为什么定义为抽象类?
    不想被实例化。

C.abstract不能和哪些关键字共存。

    final
    private
    static

3.接口
(1).如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种更抽象的表示形式：接口。

      接口：interface

      实现：implements

      格式：
                interface 接口名{}

                class 类名 implements 接口名 {}

(2).接口的特点：
A.接口不能被实例化。

B.一个类如果实现了接口：
    要么是抽象类。
    要么实现接口中的所有方法。

(3).接口的成员特点：
A.成员变量    只能是常量。默认修饰符 public static final

B.成员方法    只能是抽象方法。默认修饰符 public abstract

推荐：永远手动给出修饰符。

(4).接口的思想特点：
A.对外暴露的规则

B.是功能的扩展

C.降低耦合度
    耦合：类与类的关系
    内聚：类自己完成某件事情的能力
    高内聚，低耦合。

D.接口可以多实现。

(5).类，接口的关系
A.类与类
   继承关系,只能单继承，可以多层继承。

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

C.接口与接口
    继承关系，可以单继承，也可以多继承。