黑马程序员——面向对象总结

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

一   面向对像的含义

       所谓的面向对象，就是将每个要处理的事物实体用对象来表示。对象包括属性和行为。将属性相似的对象归纳为类。类封装了同一种对象的共有属性和方法。

二   面向对象的三个基本特征

        1  封装

            将不需要对外暴露的属性和实现细节隐藏起来，但对外提供访问方式。（让使用者只需知道某个类的对象具备怎样的功能，而不去关心具体的实现细节）

            封装的原则：1 将不需要对外提供的内容隐藏起来。

                                      例如：

                                      class Tool

                                   {

                                          public void show()

                                        {

                                               getConn();

                                      }

    

                                      private void getConn()

                                      {

                                         System.out.println("获取链接");

                                      }

                               }

Tool类中的getConn方法并不需外界知道故此使用private关键字隐藏起来。

                                       2 属性私有化，但对外提供访问方法；

                                         class A

                                                {

                                                     private  String  name；

                                                     public    void  setName(String name)

                                                              { 

                                                                 this.name = name;

                                                               }

                                                     public   String  getName()

                                                      {

                                                              return name;

                                                          }

                                                    }

            2   继承

                继承的目的：1  子类可继承父类拥有的属性和方法。提高代码的复用性

                                        2  通过继承让类与类之间产生关系。 is  a 的关系，为多态奠定了基础。

               继承的前提：类与类之间存在所属关系时，才继承。并非只是为了获得其他类的功能，简化代码而去继承。

                                       纯粹为简化代码可以再类中定义一个它类的对象即可。不必继承它类。

              java语言中类只支持单继承：因为当存在不同类父类中存在相同的方法时情况时 JVM不知道访问具体的哪一个方法

class A

{

    public  viod show（）

       {

          System.out.println("a");

       }

}

class B

{

    public  viod show（）

       {

          System.out.println("b");

       }

}

class C extends A,B

{

}

C c= new C();

c.show();????//不确定运行哪一个show（）。

  但是  java中接口之间支持多继承

   interface   A

{

      public abstract show();

} 

interface B

{

   public abstract show();

}

interface C extendsA,B

{

}

class Demo implements C

{

     public void show()

{

}

}

虽然接口C中存在2个show（）;但这2个方法不存在方法体。C的实现类Demo的show（）方法同时覆盖了C中的2个show（）；当Demo d = new Demo（）；d.show();时jvm能知道调用哪一个具体的show（）；

          继承过程中的覆盖和隐藏

          对变量而言：当子类存在和父类相同的变量时，通过子类对象访问到的时子类的变量。父类的同名变量此时被隐藏。

          对于方法而言：当子父类存在相同的函数时，子类函数会覆盖父类函数，通过子类对象访问该函数时访问的是子类的函数。

         由于子类可以覆盖父类方法，一定程度上提高了功能扩展性，但同时也在一定程度上破坏了封装性。

        final关键字可一定程度上的保证封装性。

        final  修饰的类不能被继承

        final  修饰的变量为常量，只能赋值一次，且不能改变其值。

        final修饰的方法不能被重写。     

          但子类对象赋值给父类引用时，通过父类引用对子父类相同的属性，方法访问时具有如下规律：

          Fu   f = new   Zi();

          f.show();

          通过父类引用调用子父类非静态相同的方法时：

          编译时：看引用型变量所属的类是否存在该方法，存在则编译通过，否则编译失败。

         运行时：看对象所属类中是否有该调用方法。有则按对象所属类中该方法的具体实现来执行。

         总结就是：

成员函数在多态调用时，编译看左边，运行看右边。

          对子父类存在同名变量时

          无论编译还是运行，都参看左边 

          子父类中存在相同静态变量，函数时。

          无论编译和运行，都参看左边。

       如下实例：

class Fu
{
private int num = 1;
static String name = "Fu";
int num2 = 2;

public void show()
{
System.out.println("Fu");
}
public void speek()
{
System.out.println("fu_speek");
}

public static void getName ()
{
System.out.println(name);
}

}

class Zi extends Fu
{
int num = 3;
int num2 = 4;
static String name = "Zi";

public void show()
{
System.out.println("Zi");
}

public static void getName ()
{
System.out.println(name);
}
}

public class blogTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
//向上转型
Fu f = new Zi();
System.out.println(f.num2);
System.out.print
4000
ln(f.name);
f.show();
f.getName();

输出结果为：2 Fu Zi Fu

 /*
Zi z = new Zi();
System.out.println(z.num2);
System.out.println(z.name);
z.show();
z.getName();
*/
输出结果为 4 zi zi zi
 }

}
     3  多态
        抽象类：

         抽象类和抽象方法都用关键字abstract修饰

         抽象类不能创建对象实例。

        抽象类必须由子类重写（覆盖）所有抽象方法后，才能建立子类对象调用期方法。如子类只覆盖部分抽象方法子类任为抽象类。

       抽象类，除了里面有抽象方法，不能创建对象外。其他与普通类完全一样。

       特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

      接口interface

      接口中的变量  全为：public static  final类型

      接口中的方法都是：public  abstract 类型的抽象方法。

     接口也不能创建对象实例。接口需要它的实现类实现其中所有的抽象方法后才能实例化对象调用其方法。

     接口与接口之间可以继承。

     接口中内有构造函数吗？ 不能：因为构造函数类型为  Public 类名（）{}；而接口中的函数全部为

 *                                                public abstract的抽象函数；

      接口可以继承接口吗？ Y

 *   接口可以继承抽象类吗?N

 *   抽象类可以继承接口吗？N 只能实现

 *   接口可以创建对象吗？N

       多态的根本在于：子类对父类方法的覆盖。

        函数的：重载和覆盖也是多态的体现。

1 多态的体现

    父类的引用指向自己的子类对象：动物  d = new Cat（）；

2 多态的前提

    1 必须是类与类之间有关系：要么是继承，要么是实现

    2 存在覆盖。（父类或借口中定义的方法被子类所覆盖了）

3 多态的好处 ：

 

  提高代码的扩展性。：只要是extends父类的对象都能被使用。

  但只能使用父类引用访问父类中所定义的方法

4 多态的应用 ：子类对象传值给父类的引用。由父类的引方法用调用具体的方法实现。

abstract class Animal
{

abstract void eat();
public Animal(){

System.out.println("父类构造函数调用");
};

}

class Dog extends Animal
{
String name = "wangcai";
public void eat()
{
System.out.println("eat bone"+"name:"+name);
}

public void kanjia()
{
System.out.println("kan jia");
}
}

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

public void cathcmouse()
{
System.out.println("zhua hao zi");
}
}

public class duoTaiDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
function1(new Dog());
function1(new Cat());
/*
Dog d = new Dog();
d.eat();

Cat c = new Cat();
c.eat();
*/
//Animal a = new Dog();//类型提升， 向上转型。
//a.eat();
//若需要调用子类的特有方法，可将父类的 引用 向下转型为子类引用
//Dog d = (Dog)a;
//d.kanjia();
/*
* 如果 父类能创建对象，千万不能将父类对象 转为子类类型
* Animal a = new Animal（）；
* Cat c = （Cat）a 是不行的。
* 多态自始至终都是子类对象在做着变化
* */

}

public static void function1(Animal a)
{
a.eat();
//通过类型判断调用子类特有的方法
if(a instanceof Dog)
{
Dog d = (Dog)a;
d.kanjia();
}else if(a instanceof Cat)
{
Cat c = (Cat)a;
c.cathcmouse();

}
}

}