黑马程序员_java面向对象

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------

 

 

 

面向对象的三大特征：封装  (Encapsulation)，继承  (Inheritance)，多态  (Polymorphism)

比较两个数组对象的内容是否相等可以使用Arrays.equals()方法;

模块设计追求强内聚（许多功能尽量在类的内部独立完成，不让外面干预），弱耦合（提供给外部尽量少的方法调用）。

每个成员方法内部，都有一个this引用变量，指向调用这个方法的对象。

System.gc(); 调用 gc 方法暗示着 Java 虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。
调用 System.gc() 实际上等效于调用： Runtime.getRuntime().gc()。
对象被回收之前会调用对象的finalize()方法，此方法是Object类的方法，子类可以重写。

Object类中有一个clone()方法，可以获取对象的一份拷贝，返回类型是Object对象。
如果一个类的对象需要支持拷贝（或者是克隆），那么这个类就需要实现Cloneable接口，然后需要重写clone()方法，并在该方法里面调用super.clone();
public Object clone() throws CloneNotSupportedException {
 return super.clone();
}
         注意：拷贝对象中的变量时，对于引用类型的变量，拷贝的是引用地址，我们也可以对该引用所代表的类进行支持拷贝。
Cloneable接口是标识接口，里面没有声明任何方法。

为什么我们要在派生类中覆盖Object类中的clone()方法时，一定要调用super.clone()呢？
因为在运行时刻，Object中的clone()方法会自动识别出你要复制的是那一个对象，然后为此对象分配空间，并进行对象的复制，
将原始对象中的数据一一复制到新对象的存储空间中。

对于更深层一些的拷贝见如下例子：
package com.heima.exam;

public class CloneableTest {

/**
       * @param args
      */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub

  Professor professor = new Professor("教授1");
         CloneAttachment catt0 = new CloneAttachment("zhangsan", 20, professor);
         CloneAttachment catt1 = (CloneAttachment) catt0.clone();
           catt1.name = "lisi";
           catt1.age = 30;
           catt1.profe.name = "教授2";
  
           System.out.println(catt0);
           System.out.println(catt1);
 }

}

class CloneAttachment implements Cloneable {
          String name;
          int age;
          Professor profe;
 
 public CloneAttachment(String name, int age, Professor profe) {
           this.name = name;
           this.age = age;
           this.profe = profe;
 }
 
 public Object clone() throws CloneNotSupportedException {
           CloneAttachment camt = (CloneAttachment) super.clone();
           camt.profe = (Professor) profe.clone();
           return camt;
 }
 
 public String toString() {
           return name + ":" + age + ":" + profe.name;
 }
}

class Professor implements Cloneable {
          String name;
          public Professor(String name) {
           this.name = name;
 }
 public Object clone() throws CloneNotSupportedException {
          return super.clone();
 }
}

如果一个类的对象需要被排序，例如：A[] aArr = new A[] {...}; Arrays.stor(aArr);
那么A类必须实现Comparable接口，并且重写compareTo(Object obj)方法。如：
public int compareTo(Object o) {
           A a = (A)o;
           int retVal = 1;
           if(this.age < a.age) {
           retVal = -1
 }
           return  retVal;
}

对已经进行过排序处理（Arrays.sort()）的数组，我们可以用Arrays.binarySearch(...)方法来对数组进行搜索，返回一个数组索引值。

当一个程序中用到了其他的类，类是在第一次被使用的时候才被加载，而不是在程序启动时就加载程序中所有可能要用到的类。
一个类被加载的时候会执行类的静态代码块。static {...}

单态设计模式。
       如下是饱汉模式：
package com.heima.exam;

public class Singleton {

 private static final Singleton singleton = new Singleton();
 
 private Singleton() {}
 
 public static Singleton getInstance() {
            return singleton;
 }
}

如下是饥汉模式：
package com.heima.exam;

public class Singleton {

 private static Singleton singleton = null;
 
 private Singleton() {}
 
 public static Singleton getInstance() {
  if(singleton == null) {
             singleton = new Singleton();
  }
            return singleton;
 }
}

          嵌套类可以直接访问嵌套它的类的成员，包括private成员，但是嵌套类的成员却不能被嵌套它的类直接访问。

一个内部类，不管它嵌套有多深，都可以访问外部类的所有成员。

在内部类对象保存了一个对外部类对象的引用(Outer.this)，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引用。(即：this.变量不存在的情况下，传递给Outer.this.变量)

如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可声明static成员，
但是，非static的内部类中的成员是不能声明为static的。static的内部类不能再使用外层封装类的非static的成员变量

内部类也可以是abstract类，也可以是final类。

内部类如何被外部引用:如下例子说明。
class Outer
{
     private int size=10;
     public class Inner
     {
      public void doStuff()
      {
          System.out.println(++size);
      }
     }
}
public class TestInner
{
 public static void main( String[] args)
 {
            Outer outer = new Outer();
            Outer.Inner inner = outer.new Inner();
            inner.doStuff();
 }
}

在类的外部需要派生内部类子类的程序代码如下：
package com.heima.exam;

public class NewInClassOverOutClass {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
            C c = new C(new A());
            c.sayHello();
 }

}

class A {
 
 class B {
  public void sayHello() {
             System.out.println("hello");
  }
 }
}

class C extends A.B {
 
 public C(A a) {
  a.super();
  /* 因为要产生一个派生类的对象时，会调用基类的构造函数，
   * 由于基类是内部类，所以首先要产生外部类对象，才能产生内部类对象，
   * 从而建立起内部类对象到外部类对象的引用关系。*/
 }
}

          嵌套类并非只能在类里定义，也可以在几个程序块的范围之内定义内部类。例如，在方法中，或甚至在for循环体内部，都可以定义嵌套类 。
          在方法中定义的内部类只能访问方法中的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。

使用Java的文档注释：文档注释以“/**”开始，以“*/”标志结束，相应的信息和批注所对应的位置很重要！ 类的说明应在类定义之前，方法的说明应在方法的定义之前。
批注参数来标记一些特殊的属性及其相应的说明 。
@author<作者姓名>
@version<版本信息>
@param<参数名称><参数说明>
@return<返回值说明>

 

子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。在子类的构造方法中可使用语句super(参数列表) 调用父类的构造方法。

如果子类的构造方法中没有显式地调用父类构造方法（super(...)），也没有使用this关键字调用重载的其它构造方法，
则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。

子类对象的实例化过程：
1，分配成员变量的存储空间并进行默认的初始化，就是用new关键字产生对象后，对类中的成员变量按第三章的表3.1中的对应关系对对象中的成员变量进行初始化赋值；
2，绑定构造方法参数，就是new Person（实际参数列表)中所传递进的参数赋值给构造方法中的形式参数变量；
3，如有this()调用，则调用相应的重载构造方法（被调用的重载构造方法又从步骤2开始执行这些流程），被调用的重载构造方法的执行流程结束后，
   回到当前构造方法，当前构造方法直接跳转到步骤6执行；
4，显式或隐式追溯调用父类的构造方法(一直到Object类为止，Object是所有Java类的最顶层父类，在本章后面部分有详细讲解)，
   父类的构造方法又从步骤2开始对父类执行这些流程，父类的构造方法的执行流程结束后，回到当前构造方法，当前构造方法继续往下执行；
5，进行实例变量的显式初始化操作，也就是执行在定义成员变量时就对其进行赋值的语句；
6，执行当前构造方法的方法体中的程序代码。

覆盖（重写）（Override）父类的方法：（三同，更宽，更小，更少）
       覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型；
       覆盖方法时，不能使用比父类中被覆盖的方法更严格的访问权限；
       必须扔出父类方法抛出的相同的异常或异常的子类，或者不抛出异常；
       必须扔出父类方法抛出的那些异常的一个子集,也就是说不能扔出新的异常。
       如果在子类中想调用父类中的那个被覆盖的方法，我们可以用super.方法的格式。

 

方法重载（Overload）：重载的方法，参数列表必须不相同(参数个数不同、参数类型不同、参数顺序不同，只要满足其一就表示参数列表不同。)
其他无任何规定，重载的方法可以是返回值不同的，但是参数列表必须不相同。可以看如下例子：

package com.heima.exam;

public class OverloadTest {
 
 public void method() {
         System.out.println("无参数方法");
 }
 
 public void method(String str) {
         System.out.println("一个String类型的参数为：" + str);
 }
 
 public void method(int i) {
         System.out.println("一个int类型的参数为：" + i);
 }
 /*
  * 如下的重载方法是不合法的。因为参数列表跟上面的方法是一样的
  * 只是返回值不同，那不能构成方法的重载。
  * 但是只要参数列表不同了，那么返回值可以是任何类型，都是合法的重载方法。
 public int method(int i) {
         return i;
 }
 */

 public void method(int i, String str) {
         System.out.println("两个参数，分别为int类型, String类型的参数为：" + i + ":" + str);
 }
 
 public void method(String str, int i) {
         System.out.println("两个参数，分别为String, int类型的参数为：" + str + ":" + i);
 }
 
 public int method(int i, int j) {
         return i + j;
 }
 
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
         OverloadTest olt = new OverloadTest();
         olt.method();
         olt.method("hello");
         olt.method(999);
         olt.method(8, "haha");
         olt.method("haha", 9);
         System.out.println(olt.method(5, 15));
 }

}

 

在Java中，传递参数时，都是以传值的方式进行传递。
       对于基本数据类型：传递数据的拷贝；
       对于引用类型：传递引用地址的拷贝。

 

       在Java中声明类、属性和方法时，可使用关键字final来修饰。
       final标记的类不能被继承。
       final标记的方法不能被子类重写。
       final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
       方法中定义的内置类只能访问该方法内的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期，将一个形参定义成final也是可以的，这就限定了我们在方法中修改形式参数的值。 
       public static final共同标记常量时，这个常量就成了全局的常量。
       为了节约内存，我们一般情况下都把声明为final的变量同时也用static修饰。
       因为声明为static的变量为类成员变量，不用为每个产生的实例对象做一份拷贝。
       final变量一般在声明时初始化，也可以在构造函数中初始化。

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

       声明为native的方法是本地方法，其中需要用到JNI(java native interface)，JNI是Java和本地应用程序的中介。还需要用到javah命令生成类的头文件。
本地方法的主要目的是利用本地资源扩展Java功能，而与Java本身的机制无关。
       一个本地方法如同一个抽象方法，并没有实际的方法体，因为本地方法的实现不是Java语言，而是采用依赖本地平台的其他语言编写的位于Java虚拟机之外的函数库中，可以通过System.loadLibrary()方法装入。System.loadLibrary()通常放置在静态初始化代码中。如果本地方法没有装载成功，则抛出UnsatisfiedLinkError异常。

对本地方法的调用和Java中的其他方法一样的调用，本地方法的实现对调用者是透明的。实际上，在Object类上定义的clone()方法和notify()方法就是本地方法。

接口是抽象方法和常量值的定义的集合

接口中的成员都是public访问类型的。
接口中的变量默认是用public static final标识的 。所以接口中的变量在其实现类中可以直接访问，也可以通过其实现类的实例去访问。
       接口中的方法默认是用public abstract 修饰的。所以实现接口中的方法的时候需要声明为public的。

我们也可以定义一个类用implements关键字去实现一个接口中的所有方法，我们还可以去定义一个抽象类用implements关键字去实现一个接口中定义的部分方法。

一个接口可以继承自另一个接口，而且接口可以是多继承。如：
       interface Sofa extends Sittable, Lie {}

       instanceof 操作符可以用它来判断一个实例对象是否属于某一个类。

       运行时异常(RuntimeException)如：ArithmeticException, NullPointerException, IndexOutOfBoundsException等之类的异常可以不用显式的捕获或者抛出。

如果我们编写的一个方法中有可能发生异常，那么就应该在方法后面声明要抛出异常，用“throws <异常类1,异常类2,...>”。

异常有很多种，我们可以编写自己的异常类，这个类必须继承Exception类。

在程序中需要抛出自定义的异常，用throw关键字。

finally语句块始终都会被执行，除非在try或catch中执行了System.exit(0);

小技巧：利用异常的处理机制，我们可以在一个方法中使用throw，try…catch语句来实现程序的跳转。

类本身只能有两种访问控制符（内部类除外）public修饰的类能被所有的类访问，默认修饰（即class关键字前没有访问控制符）的类，只能被同一包中的所有类访问。

类成员中的访问控制修饰符有：
       private:   同一类
       (缺省):    同一类，同一包中的类
       protected: 同一类，同一包中的类，子类
       public:    所有类

jar –cvf  （打包）
       jar –tvf  （查看包内容）
       jar –xvf  （解压包）
       jar –tvf  >a.txt   （查看包内容，把查看结果输出到一个文件里面）