黑马程序员---面向对象



------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1、面向对象思想：

    (1)概述：面向对象是基于面向过程的编程思想，面向过程强调的是功能，面向对象强调的是将功能封装进对象，

         强调具备功能的对象；

    (2)思想特点：

         A:是一种更符合我们思想习惯的思想；

         B:可以将复杂的事情简单化；

         C:将我们从执行者变成了指挥者；

     比如我要达到某种结果，我就寻找能帮我达到该结果的功能的对象，如我要洗衣服我就买洗衣机，至于怎么洗我不管。

    (3)特征：

封装(encapsulation)：隐藏对象的属性和实现细节，仅对外提供公共访问方式。比如电脑机箱、笔记本等

            好处：

                将变化隔离；

                方便使用；

                提高复用性；

                提高安全性

     关键字private：封装在代码中的体现

                (1)私有的意思，权限修饰符

                (2)用来修饰成员变量和成员函数

                (3)用private修饰的成员只在本类中有效

                (4)私有是封装的一种体现

继承(inheritance): 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，

只要继承那个类即可。

多态(polymorphism):一个事物的多种形态。同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。

        多态前提

        A:存在着继承或者实现关系

        B:有方法的重写 

        C:父类(接口)引用指向子类(实现)对象

        多态的好处和弊端：

        好处：多态的存在提高了程序的扩展性和后期可维护性

        弊端：父类不能访问子类的特有方法，如果非要访问，向下转型(强转)。

向上转型
    从子到父
    父类引用指向子类对象
 向下转型
    从父到子
    父类引用转为子类对象

    多态中对象调用成员的特点

            Fu f = new Zi();

        A:成员变量

            编译看左边，运行看左边

        B:成员方法

            编译看左边，运行看右边

        C:静态方法

            编译看左边，运行看左边

        多态的思想：

            指挥同一批对象做事情。举例：带兵打仗，下课等。

抽象类:

 抽象类：包含抽象方法的类，就是抽象类。 需要使用关键字 abstract修饰

 抽象方法：只有方法声明，没有方法体， 需要使用关键字 abstract修饰
 抽象类特点

  1：抽象类和抽象方法必须用abstract关键字修饰

   格式

    abstract class 类名 {}

    public abstract void eat();

  2：抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

  3：抽象类不能实例化

   那么，抽象类如何实例化呢?

    按照多态的方式，由具体的子类实例化。

    其实这也是多态的一种，抽象类多态。

  4：抽象类的子类

   要么是抽象类

   要么重写抽象类中的所有抽象方法

   注意：想创建对象，必须要将所有的抽象方法实现，才能创建对象

 抽象类的成员特点:

  （1）成员变量

   可以是变量

   也可以是常量

  （2）构造方法

   有构造方法，但是不能实例化

   那么，构造方法的作用是什么呢?

    用于子类访问父类数据的初始化
  （3）成员方法

   可以有抽象方法 限定子类必须完成某些动作

   也可以有非抽象方法 提高代码服用性
 abstract不能和哪些关键字共存

  private 冲突

  final 冲突 

  static 无意义
接口:

 1、接口特点

   接口用关键字interface表示
   格式：interface 接口名 {}
  2、类实现接口用implements表示

      格式：class 类名 implements 接口名 {}

 3、接口不能实例化

   那么，接口如何实例化呢?

     按照多态的方式，由具体的子类实例化。

     其实这也是多态的一种，接口多态。

 4、接口的子类

    要么是抽象类

    要么重写接口中的所有抽象方法
 接口成员特点

  1、成员变量

     只能是常量

     默认修饰符 public static final

   2、构造方法

     没有，因为接口主要是扩展功能的，而没有具体存在

   3、成员方法

      只能是抽象方法

      默认修饰符 public abstract

类与类关系：

     继承关系，只能单继承，但是可以多层继承

类与接口关系：

     实现关系，可以单实现，也可以多实现

    还可以在继承一个类的同时实现多个接口
 接口与接口关系:

     继承关系，可以单继承，也可以多继承

抽象类和接口的区别?

   （1）成员区别

      抽象类 

         变量,常量

         抽象方法

         非抽象方法
       接口 

         常量

         抽象方法
    （2）关系区别

        类与类 

          继承，单继承

        类与接口

           实现，单实现，多实现
        接口与接口 
          继承，单继承，多继承
      （3）设计理念区别
         抽象类 被继承体现的是：”is a”的关系。共性功能
         接口 被实现体现的是：”like a”的关系。扩展功能

 2、类和对象：

    类：是一组相关的属性和行为的集合，抽象的概念。

    对象：是该类事物的具体体现。（万物皆对象）

  举例：
    类 学生

    对象 班长就是一个对象

成员变量和局部变量的区别:

  （1）在类中的位置不同

     成员变量 类中方法外

     局部变量 方法内或者方法声明上

  （2）在内存中的位置不同

     成员变量 堆内存

     局部变量 栈内存

  （3）生命周期不同

    成员变量 随着对象的存在而存在，随着对象的消失而消失

    局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

  （4）初始化值不同

    成员变量 有默认的初始化值

    局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

方法的形式参数是类名的时候如何调用:

   形式参数：方法的参数列表中的参数

   实际参数：调用方法时，传递的参数

基本数据类型：

    形式参数的改变 对 实际参数没有影响

引用数据类型：

    形式参数的改变 对 实际参数   有影响
     class类型的参数，也属于引用数据类型

  调用方式如下：
  
 class Student {
  public void study(){
   System.out.println("正在复习中");
  }
 } 
 
 class Test {
  public static void main(String[] args){
   //创建Test对象
   Test t = new Test();
   Student s = new Student();
   t.method( s );
  }
  
  public void method( Student s ){
  
   //this --> t对象
   s.study();
  }
 }
 

3、内部类

    (1)把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。

    (2)访问特点：

        A:内部类可以直接访问外部类中的成员，因为内部类持有外部类的引用，

          格式为：外部类名.this

        B:外部类要想访问内部类的成员，必须创建对象访问。

    (3)内部类的访问格式：

        A:当内部类定义在外部类的成员位置，而且非私有，则可以在其他外部类中直接建立内部类对象

          格式：外部类名.内部类名  变量名= new 外部类对象.内部类对象

            如：Outer.Innerin = new Outer().new Inner()

        B:当内部类在外部类成员位置，且被static修饰时

            外部其他类可直接访问静态内部类的非静态成员

              格式：new 外部类名.内部类名().内部类成员

              如：new Outer.Inner().function();

            外部其他类可直接访问静态内部类的静态成员

              格式：new 外部类名.内部类名.内部类成员

              如：new Outer.Inner.function();

    (4)什么使用时候内部类呢？

        假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，

        需要创建A类对象进行访问，这个时候，就可以把A类定义为B类的内部类。

 

class Outer{   

private static int num = 31;

class Inner // 内部类。

       {     void show(){

                     System.out.println("showrun..."+num);

              }/*staticvoid function() //如果内部类中定义了静态成员，该内部类也必须是静态的。

              {     System.out.println("function run...."+num);

              }*/

       }publicvoid method(){ 

       Inner in = new Inner();

              in.show();

       }

}

class InnerClassDemo

{     publicstatic void main(String[] args){

            //Outerout = new Outer();

            //out.method();//直接访问外部类中的内部类中的成员。

            // Outer.Innerin = new Outer().new Inner();

            //in.show();//如果内部类是静态的。 相当于一个外部类

            //Outer.Innerin = new Outer.Inner();

            //in.show();//如果内部类是静态的，成员是静态的。

            //Outer.Inner.function();

       }

}

 

    (5)内部类的位置

        A:成员位置

            可以被private修饰(Body，Heart)

            可以被static修饰。(它访问的外部类的成员必须是静态的)

        B:局部位置

            可以直接访问外部类中的成员，因为还持有外部类的持用

            也可以直接访问局部成员，但是局部成员要用final修饰。     

        注意：局部内部类不能用private和static修饰    

    (6)通过class文件我们就可以区分是否带有内部类，以及内部类的位置

        Outer$Inner:成员内部类

        Outer$1Inner:局部内部类

4、匿名内部类：就是没有名字的对象，是对象的一种简化表示形式

        (1)前提：继承一个类或者实现一个接口

        (2)格式：

            new 父类名或者接口名()

            {

                重写父类方法或者实现接口中的方法。

                也可以自定义其他方法。

            };

        (3)什么时候定义匿名内部类？

            匿名内部类只是为了简化书写，匿名内部类有局限，通常定义匿名内部类时，该类方法不超过3个

        （4）匿名对象的两种使用情况:
            对象调用方法仅仅一次的时候
               new Student().study();

            作为实际参数传递
               t.method( new Student() );

        (5)匿名内部类的好处和弊端：

            好处：简化代码书写

            弊端：

                不能直接调用自己的特有方法

                不能执行强转换动作

                如果该类里面方法较多，不允许使用匿名内部类