黑马程序员——面向对象

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

 

一、面向对象
   （一）面向对象概念
       1、理解面向对象
        面向对象是相对面向过程而言的，现象对象和面向过程都是一种思想。面向过程强调的是功能行为；面向对象是将功能封装进对象，强调具备了功能的对象，面向对象是基于面向过程的。
        2、面向对象的三大特征：
         封装、继承、多态。对象用于封装数据。用new关键字在堆内存中创建对象实体。
   （二）类与对象的关系
         1、类就是对现实生活中事物的描述。对象就是这类事物实实在在存在的个体。类是对具体对象的共性的抽象抽取。调用对象成员的方式：对象.对象成员。
         2、成员变量：作用于整个类中；局部变量：作用于函数中或语句中。成员变量存储在堆内存中，因为对象的存在，才在内存中存在；局部变量存储在栈内存中。
         3、匿名对象
            匿名对象是对象的简化形式，匿名对象有两种使用情况：a.当对对象方法仅进行一次调用时。b.匿名对象可以作为实际参数进行传递。
   （三）封装（encapsulation）
        1、封装是指隐藏对象属性和实现细节，仅对外提供公共访问方式。
        2、封装的优点：将变化隔离，便于使用，提高重用性，提高安全性。
        3、封装的原则：将不需要对外提供的内容都隐藏起来。把属性都隐藏提供公共方法对其访问。
         4、private（私有）：权限修饰符，用于修饰类中的成员（成员变量，成员方法）。私有只在本类中有效。私有仅仅是封装的一种体现形式。         
   （四）构造函数
        1、特点：函数名与类名相同；不用定义返回值类型；不可以写return语句。
        2、作用：给对象进行初始化。对象一建立就会调用与之对应的构造函数。
        3、当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，系统就不默认构造函数了。
        4、构造函数和一般函数的不同：构造函数和一般函数不仅在写法上有一定的区别，而且在运行上也有不同：构造函数是在对象一建立就运行，给对象初始化，一个对象建立，构造函数只运行一次；而一般方法当对象调用时才执行，是给对象添加对象应具备的功能并且一般方法可以被对象调用多次。
         5、构造函数的建立：当分析事物时，该事物一存在就具备的一些特性或者行为，那么就将这些内容定义在构造函数中。
         6、构造代码块：定义的是所有对象的共性，是给所有对象进行统一的初始化，对象一建立就运行，且在构造函数之前运行。构造函数是给指定对象初始化。
   （五）this关键字
         1、this区分成员变量和局部变量。this代表所在函数所属对象的引用。简单的说：那个对象调用this所在的函数，那么this就代表这个对象。this是对象的引用，当定义类中功能时，该函数内部要用到调用该函数的对象时，就用this代表这个对象。
          2、this在构造函数互相调用时的应用：
           事例：class person
                     {
                        person（string name）
                           {
                              this.name=name;
                            }
                         person(string name,int age)
                             {
                                this(name);//this.name=name;this语句调用上个构造//方法.
                                
                                 this.age=age;
                                }
                      }
           注意：构造函数间的调用只能用this且传给相应的参数，this语句只能定义在构造函数的第一行。因为初始化动作要先执行。
                       
   （六）static关键字
        1、static 用于修饰成员(成员变量和成员函数)不能修饰局部，被修饰后的成员具备以下特点：随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名调用：类名.静态成员。
         2、使用注意：
          静态方法只能访问静态成员；静态方法中不可以写this，super关键字；主函数是静态的。非静态的既可以访问静态的也可以访问非静态的。
          3、实例变量和类变量的区别：
           a.存放位置：类变量随着类的加载而存在于方法区中；实例变量随着对象的创建而存在于堆中。
           b.生命周期：类变量生命周期最长，随着类的消失而消失；实例变量生命周期随着对象的消失而消失。]
          4、什么时候定义静态变量（成员变量也就是类变量）？
          当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据定义成非静态存放在堆内存。
           5、什么时候定义静态函数呢？
            当函数内没有访问到非静态数据（对象的特有数据）时，那么该函数可以定义成静态的。
           6、程序说明书的制作
              对每一个功能都用文档注释说明，用一个工具抽取文档，这个工具就是javadoc。（javadoc -d myhelp -author -version Arraytool.java）。注意：要提取的这个类必须用public修饰。
             7、静态代码框格式
                static
                     {
                        静态代码框中的执行语句；
                      }
                静态代码框随着类的加载而执行且只执行一次，优先于主函数执行，用于给类进行初始化。
          事例：class StaticCode
                   static
                     {
                       System.out.println("a");
                      }
                   class StaticCodeDemo
                      {
                          static
                               {
                                     System.out.println("b");
                                }
                          public static void main(String[] args)
                             {
                               new StaticCode();
                               new StaticCode();   
                             }
                           static
                               {
                                     System.out.println("c");
                                }

                       }//执行的结果是：b c a（为什么只有一个a呢？
因为静态代码框在类加载的时候只执行一次，后边调用时类已经在内存中了，所以静态代码框也就不执行了）。
   （七）单例设计模式
        1、设计模式：解决某一类问题最行之有效的方法。java中有23中设计模式。
        2、单例设计模式一
        先初始化对象，称为：饿汉式
  事例：
/*
要想保证对象唯一：
 1、为了保证其他程序过多建立该类的对象，先禁止其他程序建立该类对象。（将构造函数私有化）
 2、还为了让其他程序可以访问该类对象，只好在本类中自定义一个对象。（在类中创建一个本类对象）
 3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。（提供以一个方法可以获取该对象）

*/
     class Single
      {
          private Single（）{}
          private static single s= new single();
          public static Single getInstance()
                    {
                       return s;
                     }
         }
      class SingleDemo
          {
               public static void main(String[] args)
                  {
                        Single ss=Single.getInstance();
                  }
            }
     3、单例设计模式二
      对象是在方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式。
  
            class Single
              {
                   private static Single s=null;
                   private Single()}{}
                   public static Single getInstance（）
                     {
                        if（s==null）
                                s=new Single（）；
                           return s；
                        }
               }
             class  SingleDemo
                    {
                        public static void main（String[] args)
                               {
                                  Single ss=Single.getInstance（）；
                                 }
                     }

          (八)继承（extends）
            1、继承的特点：
            提高了代码的复用性；让类与类之间产生了关系，有了这个关系，才有了多态的特性。在java语言中只支持单继承，不支持多继承，因为多继承容易带来安全隐患（当多个父类中定义了相通的功能，但功能内容不同时，不确定要运行哪一个）。java支持多层继承，也就是一个继承体系。
            2、子父类中成员的特点：
             变量：如果子父中出现了非私有的同名变量时，子类要访问本类中的变量用this；子类要访问父类中的同名变量用super。super和this的用法几乎一样。this代表子类对象的引用，super代表父类对象的引用。
             函数：当子类和父类出现一模一样的函数时，子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一种特性：重写（覆盖）。继承中覆写的特性可以拓展程序的功能。
            注意：子类覆盖父类必须保证子类的权限大于等于父类的权限。静态只能发、覆盖静态。
              构造函数：在子类对象初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super（）。super（）会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）。
              3、子类访问父类构造函数的原因：
                因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据初始化的。所以子类在对象初始化时，要先访问以下父类中的构造方法。如果要访问父类中自定义的构造方法，可以通过手动定义super语句的方式来指定。注意：super语句一定定义在子类构造函数的第一行。
               4、结论：
                  子类中所有的构造函数默认都会访问父类中空参数的构造方法；因为子类的每一个构造方法的第一行都有默认的隐式语句super（）；当父类中没有空参数的构造方法时，子类必须手动通过supe（）语句形式访问类中的构造函数。当然子类的构造函数第一行也可以手动指定this（）语句来访问本类中的构造函数，但子类中至少有一个构造函数会访问父类中的构造函数。                          
         （九）final关键字
             final可以修饰类、方法、变量（成员变量和局部变量）；final修饰的类是不可被继承；final修饰的方法不可以被覆盖；final修饰的变量是一个常量，只能赋值一次；内部类只能访问被final修饰的局部变量。
          （十）抽象类
            当多个类中出现相同功能，但功能主体不同，这是可以进行向上抽取。这时只抽取功能定义，而不抽取功能主体。抽象类的特点：抽象方法一定定义在抽象类中，抽象方法和抽象类都被abstract关键字修饰；抽象类不可以用new创建对象，因为没有意义；抽象类中的方法要被使用，必须有子类覆写所有的抽象方法后，建立子类对象调用；如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类；抽象类中即可有抽象类也可以有非抽象类。抽象类中可以不定义抽象方法，这种作用仅仅用于不让该类创建对象。
      抽象类事例：
            class Employee
            {
                  private string name;
                  private string id;
                  private double pay;
                   Employee(string name,string id,double pay)
                      {
                            this.name=name;
                            this.id=id;
                             this.pay=pay;
                      }
                   public abstract void work();
              }
            class Manager extends Employee
              {
                private int bonus;
                Manager(string name,string id,double pay,int bonus)
                        {
                           super(name,id,pay);
                            this.bonus=bonus;
                         }
                 public void work()
                    {
                          System.out.println("manager work");
                      }
              }
             class Pro extends Employee
               {
                   class Pro(string name,string id,double pay)
                        {
                           super(name,id,pay);
                         }
                   public void work()
                       {
                             System.out.println("Pro work");
                        }
                 }
                public class  AbstactDemo
                      {

                         public static void main(String[] args)
                                {
                                Manager man=new Manager(zhansan,01,100.00,400 );
                                    Pro p=new Pro(lisi,05,200.00);
                                    man.work();
                                    p.work();
                                  }
                      }
           （十一）模板方法
             在定义功能时，功能一部分是确定的，另一部分功能是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该子类去完成。
            （十二）接口
                  1、接口的格式：interface{}
                  2、接口中的成员修饰符是固定的：成员变量：public static final
                    成员函数 ：public abstract
                  3、接口的出现将“多继承”通过另一种形式体现出来，即“多实现”
                  4、implements  关键字，用于类实现接口。
                  5、一个类在继承一个类的同时还可以实现多个接口。
                  6、接口与接口之间也有继承关系。接口与接口之间也可能有多继承。
            （十三）接口的特点
                 接口是对外暴露的规则；接口是程序的功能扩展；接口可以用来多实现；类与接口之间是实现关系，而且类可以在继承一个类的同时实现多个接口；接口与接口之间可以有继承关系，而且在特殊情况下接口与接口之间可以有多继承关系。            

二、多态
   定义：某一类事物多种存在形态.提高了代码的扩展性。
   （一）多态的体现形式
        父类的引用指向了自己的子类对象；父类的引用也可以接收自己的子类对象。
   （二）多态的好处
        多态的出现大大的提高了程序的扩展性。
   （三）多态的前提
        必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖。
    （四）多态的弊端
       提高了扩展性，但是只能使用父类的引用访问父类中的成员。
     (五)多态-转型
         向上转型：父类的引用指向子类的对象。向下转型：强制把父类的引用转成子类类型。
     （六）instanceof关键字
          判断一个引用是否为指定类型。
      （七）在多态中非静态成员函数的特点：（非多态绑定）
         在编译时期：参阅引用类型变量所属的类中是否有编译方法，如果有编译通过，如果没有编译失败。
         在运行时期：参阅对象所属的类中是否有调用方法。
          结论：成员函数在多态调用时，编译看左边，运行看右边。
        （八）在多态中成员变量的特点
            无论编译和运行，都参考左边（引用类型所属的类）。
         （九）在多态中静态成员函数的特点
             无论是编译还是运行，都参考左边。（静态绑定）
         事例：模拟电脑
                 interface PCI
                   {
                      public void open（）；
                      public void close（）；
                   }
                  class MainBoard
                       {
                         public void run()
                                  {
                                     System.out.println("run");
                                   }
                         public void usePCI(PCI p)//多态，接口的引用指向接口对象
                                 {
                                      if(p!=null)
                                             {
                                                p.open;
                                                p.close;       
                                              }
                                  }
                             
                        }
              （十）Object 类
                   类Object 是类层次结构的根类，每个类都是用Object作为超类。所有对象（包括数组）都实现这个类的方法。
三、内部类
    （一）定义
    将一个类定义在另一个类的里边。把里边的那个类就成为内部类（内置类、嵌套类）。
    （二）访问特点：
       内部类可以直接访问外部类的成员，包括私有成员（是因为内部类持有了一个外部内的引用，格式：外部类名.this）。而外部类要访问内部类的成员必须要建立内部类的对象。
     事例：class outer
            {
               private int x=3；
                class inner//内部类
                   { 
                     void function()
                      {
                     System.out.println("inner:"+x);//x 之前省略了outer.this x
                        }
                   }
                 void method()
                    {
                       inner in=new inner（）；//建立内部类的对象
                       in.function；
 
                     }
              }
        class OutInterDemo()
               {
                  public static void main(String[] args)
                        {
                              outer out = new outer();//通过外部内的对象调用内部类的方法
                              out.method;
                               //outer.inner in=new outer().new inner();
                               //in.function;//直接访问内部类的成员
                        }
                }
        技巧：1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象，格式为：外部类名.内部类名 变量名 = 外部对象.内部对象
                          outer.inner in=new outer().new inner();
        （三）静态内部类
             事例：class outer
                        {

                          private static int x = 3；
                           static class inner//静态内部类
                                 {
                                    void function（）
                                            {
                                            System.out.println("inner:"+x);
                                             }
                                  }
                          }
                    class InnerClassDemo
                             {
                                 public static void main（String[] args）
                                     {//当静态内部类的成员非静态时，调用成员的方法
                                         new outer.inner（）.function（）；
                                      //当静态内部类的成员也静态时，调用成员的方法
                                        outer.inner.function()
                                      }
                              }
              技巧：当内部类在成员位置上，就可以被成员修饰符所修饰，比如，private：将内部类在外部类中进行封装。static：使内部类具有static的特性，当内部类被static修饰后，就只能访问外部类中的static成员，出现了访问受限。
               在外部其他类中，如何访问静态内部类的非静态成员呢？
                  格式： new outer.inner（）.function（）
               在外部其他类中，如何访问静态内部类的静态成员呢？
                  格式：outer.inner.function（）
              注意：当内部类中定义了静态成员，那么该内部类也必须是静态的。
                    当外部内的静态方法要访问内部类时，该内部类也必须是静态的。
        （四）局部内部类
            事例：class outer
                  {
                    int x=3;
                    void method()
                      { 
                          final int y=4
                           class inner//局部内部类，相当于局部变量，它不能被成员                                        //修饰符所修饰
                                {
                                  void function()
                                      {
                                         System.out.println(y)；//y必须使用final修饰
                                       }
                                 }
                             new inner().function（）；
                       }
                             
                  }
                注意：局部内部类不可以被成员修饰符修饰；可以直接访问外部内中的成员，因为还持有外部内中的引用outer.this；但是不可以访问他所在局部中的局部变量，只能访问被final修饰的局部变量。
            （五）匿名内部类
               匿名内部类其实就是内部类的简写格式。定义匿名内部类的前提是：内部类必须继承一个类或实现接口。
              事例：abstract class AbsDemo
                       {
                           abstract void show（）；
                      }
                     class outer
                        {
                             public void function（）
                                    {
                                         new AbsDemo（）//匿名内部类
                                           {
                                              void show（）
                                                      {
                                                        System.out.println("x="+x);
                                                      }
                                            }.show（）;//用匿名内部类调用内部类的方                                                          法
                                     }
                         }
                  1、匿名内部类的格式：new 父类或者接口（）{定义子类内容}
                  
                    2、匿名内部类其实就是匿名的子类对象,可以理解为带内容的对象。  
                 
                   3、匿名内部类可以作为对象的实际参数传递。  
四、异常
      （一）异常就是程序在运行时出现的不正常情况。
       （二）异常的由来：问题也是现实生活中的一个具体事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是java对不正常情况进行描述后的体现。
        （三）问题的划分
           问题可以分为两种：一种是严重的问题，java通过Error类进行描述。另一种非严重的问题，javaException类进行描述。对于Error一般不编写针对性的代码进行处理。对于Exception可以使用针对性的处理方式进行处理.
         (四)异常的处理
            1、 java提供了特有的语句进行处理
               try
                {
                  需要被检验的代码；
                 }
               catch（异常类 变量）
                  {
                   处理异常的代码；（处理方式）
                  }
                finally
                   {
                     一定会执行的语句；
                    }
       注意：catch适用于处理异常的，如果没有catch就代表着异常没有被处理过，如果该异常是检测时异常，那么必须声明该异常。
            （五）异常的声明
                 1、在功能上声明：throws Exception
                  事例：class  Demo
                           {//声明异常
                              int div（int a，int b）throws Exception
                                 {return a/b；}
                            }
            （六）自定义异常
                 因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java对问题的封装思想将特有问题，进行自定义的描述。
           事例：自定义异常对象：
                   class FuShuException extends exception//自定义异常必须继承Exception。因为异常体系有一个特点：因为异常类和异常对象都被抛出，它们都具备可抛性，这个可抛性是Throwable这个体系中独有的特点。只有这个体系中的类和对象才可以被throws和throw操作。
                      {
                            FuShuException（String message）
                                 {
                                      //super（message）；//父类已经定义过了不必自己                                                              再定义了
                                          private int value；
                                        FuShuException（String message，int value）
                                            {
                                                    super（message）；
                                                    this.value=value；
                                             }
                                            public int getValue（）
                                                 {
                                                       return value；
                                                   }
                                  }
                       }
                    class Demo
                        {
                            int div（int a，int b）throws FuShuException
                               {
                                   if（b<0）
                                       throw new FuShuException(“出现负数”，b);//                                                                   自定义函数声明
                                    return a/b;
                                }
                              
                         }
            注意：当在函数内部出现了throw抛出的异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理，要么在函数上声明让调用者处理。一般情况下，函数内部出现异常，函数上需要声明。
               throws和throw的区别：throws使用在函数上，throw使用在函数内；throws后面跟的是异常类，可以跟多个，要用逗号隔开；throw后跟的是异常对象。
                  
            (七)对多异常的处理
                 1、声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
                 2、对方声明有几个异常，就对应有几个catch块，不要定义多余的catch块。
                 3、如多个catch块中的异常出现继承关系，父异常catch块放在最下边。
            （八）RuntimeException异常
                  Exception中有一个特殊的异常——RuntimeException，这个类以及这个类的子类有一些特殊的性质：
      1、如果函数内抛出该异常以及该异常的子类，函数上可以不声明，编译一样通过。
      2、如果在函数上声明了该异常以及该异常的子类，调用者可以不进行处理，编译一样通过。
     总之，之所以不用再函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后对代码进行修正。
             （九）对于异常分两种
                 1、编译时被检测的异常
                 2、编译时不被检测的异常（运行时异常：RuntimeException以及它的子类）
              （十）异常finally
                   finally中放的是一定要被执行的语句。通常用于释放资源。finally只有一种情况不被执行，就是前面有System.exit（0）时。
              （十一）异常在子父类中的体现
                1、子类在覆盖父类时，如果父类方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类。
                2、如果父类方法抛出多个异常，那么子类在覆盖方法时只能抛出父类异常的子集。
                3、如果父类或者接口的方法中没有抛出异常，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须进行try catch处理，绝对不能抛。
                (十二)异常的好处
                 1、将问题进行封装。
                 2、将正常流程代码和异常处理代码相分离，方便阅读。
                （十三）异常处理的原则
                 1、处理方式有两种：try或者throws。
                 2、调用抛出问的功能时，抛出几个就处理几个，一个try对应几个catch。
                 3、异常处理如果有多个catch，父类的catch放到最下边。
                 4、catch内要顶针对性的处理方式，不要简单的定义printStackTrace输出语 句。也不要不写，当捕获的异常，本功能处理不了时，可以再catch语句中继续向外抛：
                    try
                      {
                        throw new Aexception（）；
                       }
                        catch（Aexception e）
                            {
                              throw e；                              
                            }
    注意：如果该异常处理不了，但并不属于该功能的异常，可以将异常转换后吗，再抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道并处理。也可以将捕获的异常处理后，转换新的异常。

五、包（package）
     （一）对文件进行分类管理
     （二）给类提供多层命名空间
     （三）写在程序文件的第一行，例如 package pack；
     （四）类名的全称是：包名.类名
           创建包 javac -d 包的路径
     （五）包也是一种封装形式
                
      （六）总结
           包与包之间进行访问，被访问的保重的类以及类中的成员需要public修饰；不同包中的子类还可以直接访问父类中被protected权限修饰的成员。包与包之间可以使用的权限只有两种：public，protected。
       （七）导入包中类的关键字:import
六、jar包
    命令是 jar

 

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