忆Java基础知识之——面向对象设计

     Java语言是完全面向对象的程序设计语言，它的所有内容都包含在类中。Java中的类与基本类型在本质上是一样的，都是对某一具有相同特性的事物的抽象。例如基本类型int就是对在一定范围内的整数集的一个抽象。而String类就是对字符串集的抽象。Java中的普通类都可以生成对象，对象是类的实现，也可以说类是实现对象的蓝图，何为对象，万物皆为对象。每个对象都有三个特性即标识，状态，接口。每个类生成的所有对象都可以由标识区分，而且都有自己特定的状态，接口是对象内部或与其他对象通信的方式。Java语言面向对象的三大基石分别为封装，继承，多态。
  在编写Java代码时，一般首先实现类，然后再使用这些类创建对象，最后通过对象之间的通信来完成所要实现的任务。类主要由实例域（字段）与方法（C语言中称为函数）组成。构造器是类中的一种特殊方法。用来初始化对象。构造器的名字与类名相同，由于Java中可以由类来创建不同方式的对象，故构造器拥有不同类型的传递参数。但构造器的名字却与类名相同。这就需要使用重载技术。重载就是名称相同而传递参数类型不同的方法。不光构造器可以使用重载，类中的其他方法也可以是用重载。重载只可以使用参数类型来区分，就算如下例中的两个他么也是重载关系。
    void test(String str,int n)...{
        System.out.println(str + n);
                     }
    void test(int n,String str)...{
        System.out.println(str + n);
                     }
  Java中this关键字有两种使用方法，一是用来表示调用方法或实例域的那个对象，另外一种使用方法是在以个构造器中调用另外一个重载了的构造器，注意此时必须在构造器中的第一行。例如
      public class ThisTest...{
        ThisTest(String str)...{
           System.out.println(str);
         }
         ThisTest(String str,int n)...{
            this(str);
            System.out.println(str + n);
         }
        
        public static void main(String[] args)...{
            ThisTest t = new ThisTest("hello ",6);
         }
                                           }    

         显示结果为:hello

                  hello 6
在上面的例子中我们用到了这样一句：
        public static void main(String[] args)
这个main方法是J2SE应用程序的入口，所有的J2SE应用程序都从这个方法开始运行。现在先来介绍一下static关键字，后面再来介绍main方法与初始化方面的知识。
   static关键字可以用在方法与实例域前面。当static用于实例域时，表示此实例域是静态的，即只能赋值一次。当static用于方法时，表示此方法是静态方法。一般我们将静态实例域与静态方法称为类实例域与类方法。因为他们不需要创建对象就可以直接由类名调用。例如：
   class StaticATest...{
     StaticATest()...{
        System.out.println("StaticATest()");
      }
    
     void test()...{
        System.out.println("StaticATest.Test()");
      }
   }

  class StaticBTest...{
     static StaticATest st = new StaticATest();
    static void test()...{
        System.out.println("StaticATest.Test()");
     }
   }

  public class StaticTest...{
    public static void main(String[] args)...{
       StaticBTest.test();
       StaticATest t = StaticBTest.st;
       t.test();
    }
  }
  现在来介绍封装，什么是封装？在解释这个概念前我们先来认识一下包与可见权限。包是由package关键字定义的，创建包的主要用途是管理命名。Java语言中有四种可见权限，这四种可见权限分别是：
（a）public：表示在整个Java中都可以见（使用）。
（b）private：表示只可在类中可见（使用）。
（c）protected:表示在包中可见（使用）且在子类中也可见（使用）。
（d）default（默认）：只可在包中使用（可见）。
  现在我们来解释封装的概念，封装其实就是把类中一些实例域或方法隐藏起来，不让外部直接访问到这些内容。具体操作就是将类中所有的实例域都定义为private，并且为每个实例域创建一个public的方法，使外部可以调用它。将不对外的方法全部使用private。
  类的扩展有两种方法，一种是组合，另外一种是继承。组合即将一个对象作为另外一个类的实例域。继承即用一个新类来扩展另外一个类，这个新类被称为子类，被用来扩展的那个类称为父类。子类拥有父类除private定义外的所有实例域和方法。继承需要使用关键字extends来扩展新类。若父类中有一个非private的方法，此时我们在子类中定义一个同样的方法，则子类的这个方法覆盖了父类的那个方法。覆盖父类方法后的可见性不可低于父类方法。在子类覆盖父类的那个方法中调用父类的那个被覆盖的方法，我们需要使用super关键字。且关键字必须放在方法作用域的第一行。Java语言只可以单继承。且Java语言中的所有类都用一个共同父类Object，这个父类有以下几个重要方法equals()，toString()等方法。其中equals()方法是比较两个对象的内容是否相等。在类库中这个方法大部分是这样实现的，但是它的默认方式却是比较两个对象的引用。故在创建新类时要覆盖此方法以达到所需要应用目的。toString()方法是返回类中各实例域的信息。在创建自己的类时也要覆盖此方法。抽象类是一种不可以创建对象的类，此类只可以做为继承的父类。一般将公共的信息作为此类的元素。抽象类中还可以定义抽象方法，若继承抽象类的类中用抽象方法，则此类仍然为抽象类。抽象类由abstract关键字定义。
  介绍完类的继承后，现在我们来了解一下类的初始化。类的初始化顺序一般为以下几步：
     1、父类static实例域的初始化。
     2、子类static实例域的初始化。
     3、父类普通实例域按定义顺序进行初始化。
     4、运行父类构造器。
     5、子类普通实例域按定义顺序进行初始化。
     6、运行子类构造器。
      例如：
  class FatherStaticTest...{
    FatherStaticTest()...{
        System.out.println("FatherStaticTest()");
     }
   }

  class FatherTest...{
    FatherTest()...{
        System.out.println("FatherTest()");
     }
   }

  class SonStaticTest...{
    SonStaticTest()...{
        System.out.println("SonStaticTest()");
     }
   }

  class SonTest...{
    SonTest()...{
        System.out.println("SonTest()");
    }
   }

 class FatherClass...{
    FatherClass()...{
        System.out.println("FatherClass()");
     }
    
    public static void Test()...{
        System.out.println("FatherClass.Test()");
     }

     private FatherTest ft = new FatherTest();
     private static FatherStaticTest 

              fst = new FatherStaticTest();
                   }

 class SonClass extends FatherClass...{
    SonClass()...{
        System.out.println("SonClass()");
    }
    
    private SonTest st = new SonTest();
    private static SonStaticTest 

             sst = new SonStaticTest();
    
    public static void main(String[] args)...{
       System.out.println("main()");
        
       SonClass sc = new SonClass();
    }
                  }
    运行显示结果：FatherStaticTest()
               SonStaticTest()
               main()
               FatherTest()
               FatherClass()
               SonTest()
               SonClass()
   static定义的内容仅在调用static实例域，调用static方法，创建对象时才被初始化。记住static方法是不能使用this关键字，即static方法中，不可使用对象。
  Java语言中还有一关键字也需要交代一下，那就是定义常量的final关键字，这个关键字在Java语言类中也有其他的含义，若在定义类时，在类名前加上final关键字，则此类不可以被继承。若类中一个方法前使用final关键字，则此方法不可以被覆盖。注意，使用private关键字的方法，自动将其设置为final。
  多态是Java面向对象的基石之一。何为多态，多态即子类的对象可以向上转型为其父类对象，但在实际应用中，又可以准确调用子类自己的方法。例如：
  abstract class Animal...{
    public void call()...{}
   }

  class Dog extends Animal...{
     Dog(String s)...{
         this.s = s;
      }
     public void call()...{
         System.out.println("Dog " + s<img src="">);
      }
    
      private String s;
   }

  class Cat extends Animal...{
     Cat(String s)...{
          this.s = s;
      }
      public void call()...{
          System.out.println("Cat " + s);
      }
    
      private String s;
   }

  public class AnimalTest...{
     public static void main(String[] args)...{
          Animal a1 = new Dog("汪汪");
          Animal a2 = new Cat("喵喵");
        
          a1.call();
          a2.call();
         }
                       }

    运行结果为:Dog 汪汪
             Cat 喵喵
   Java语言值得我们使用的最重要一点就是垃圾处理机制，奶奶的，设计出Java语言的那位天才真的想的很周到，将很多的内容都交给了类库与Java虚拟机来完成，不过这也带来了一定的弊端，就是内存与速度。不过世界上也没有十全十美的东西。它所带来的好处也是多多的。不然他就不会这么流行。
  到这里为止Java语言的基本内容可以说已经全部介绍完了。也许有人会问接口，内部类等等，这些我认为已经算是高级的东西了。等下篇我在来介绍。