java-面向对象<二>-《上篇》

1，面向过程

           比如对一个windows窗口的操作，要隐藏窗口，移动窗口，最小化窗口，为这些操作定义各种的函数，

        而这些函数对窗口本身的定义没有任何关系。程序的中心集中在函数的实现

2，面向对象

         窗口的属性，大小，颜色，位置，背景等等，还有窗口的动作，如最小化，移动等，这都是针对窗口本身的定义来实现

3，java面向对象的三个特征

            a.封装  b.继承  c. 多态

 4，匿名对象

       不定义对象的句柄，而直接调用该对象称为匿名对象，如 new Person ( ) .

        使用匿名对象的两种情况

        a. 对一个对象只需要进行一次方法调用

        b.将匿名对象作为实参传给一个函数调用，如 getSomeone (new Person  ( ) ) ;

5,实现类的封装性

             通过private 关键字对类的成员保护，只能在本类的代码块内访问。

             我们通过将类的成员变量声明为私有的，在通过一个公有的方法来对其访问和修改，这种方式称为封装。封装达到以下目的

             a.隐藏类的实现细节

             b.让使用者只能通过设定好的方法来访问数据，可以方便地加入控制逻辑，限制对属  

                性的不合理操作

             c.便于修改，增强代码的可维护性

             d.可进行数据检查

             e.对于现实中的错误赋值，我们可以通过抛异常的方式对其处理

6.构造函数与重载

     每当创建对象时，构造方法都会被自动调用一次.

     其访问权限一般为public，不能是private，因为对象产生时，系统会自动调用它

     名称与类名相同

     无返回值

     不能在方法中return一个值

  注意：定义一个有参数的构造方法，最好多定义一个无参数的构造方法

7，this句柄

     this是指本身,可用在构造方法里，如this.name=name ;

   this可作为实参传入方法里。

      某一个类的方法中调用另一个类的实例，而该实例的构造方法的参

      数是这个类的实例时。即通过this引用把当前的对象作为一个参数  

      传递到其他的方法和构造方法中

8，垃圾回收方法finalize方法

      finalize()方法是在对象被当成垃圾将要从内存释放前调用，而不是对象被当成垃圾时就调用。

    垃圾回收器的启用不由程序员控制的，也无规律可循。这不是一个很可靠机制，所以我们无法

    保证每个对象的finalize最终都被调用

9，System.gc ()

      强制启动垃圾回收器回收垃圾，即调用finalize方法

  

public class Person {
  public void finalize ()
{
System.out.println("the object is going");
}
      public static void main(String[] args) {
// TODO Auto-generated method stub
new Person ();
new Person ();
new Person ();
System.gc();
System.out.println("this is ending");
     }
 }

 运行如下：

      the object is going

      the object is going

      the object is going

      this is ending

10.1，static关键字

          静态变量类似全局变量，它是类的所有实例共有的属性，如果它的访问权限不是private的，

          则可以在类的外部以“类名.静态变量”方式访问，不需要通过实例来访问。

          static修饰的变量，在类被载入时就创建，类存在则该变量存在，不是实例化时才创建。

      注意：任何方法体内都不能声明静态变量，理由是类被载入时，方法没被创建,但方法体内可访问静态变量

10.2，静态方法（使用规则与上面的静态变量一样）

     可以以“类名.静态方法名”使用，类的非静态方法可以访问类的静态方法。所以System.out.println();是静态方法

    注意：

           静态方法中只可以访问类中的其他静态成员（如静态变量或静态方法），不可以访问非静态成员。

           静态方法中不可以引用this，super关键字

           main方法是静态的，所以其方法内不可以访问该类的其他非静态成员。

11，静态代码块

    静态代码块可以不在任何方法体中，当类被载入时，静态代码块被执行，且只被执行一次，静态代码块常被用了进行类属性的初始化    

class StaticCode
{
static String country ;
static {
country="中国";
System.out.println("static code is loading..");
}
}
public class TestStaticCode {
     public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("test static code");
        new StaticCode ();
        new StaticCode ();
}
}

 

运行

    test static code

    static code is loading..

    上面证明，只有类被使用时才会装载，也就是类的第一次使用时才被装载，main方法是程序的入口。

12，单态设计模式

       采用一定的方法保证整个软件系统中，对某一个类只存在一个对象实例，并且该类只提供一个取得其对象实例的方法

       构造方法：必须是private修饰，则外部不可new出来，只能通过get方法得到实例

       get方法：必须是public，static修饰，外部可以访问，返回一个静态实例

class TestSingle
{
//确保唯一一个对象实例
private static final TestSingle onlyone=new   TestSingle () ;
public static TestSingle getTestSingle()
{
return onlyone ;
}
private TestSingle ()
{
 };
}

   可以通过TestSingle.getTestSingle()获得该类对象实例

13，内部类

     在一个类的内部定义类，这就是嵌套类，也叫内部类，或内置类。

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

13.1 类中的定义的内部类

          A类定义了一个内部类B,则B为A所知，却不被A的外面所知。B类像A类中的其他非static成员的功能一样，

       可以直接访问或引用A类中的所有成员，内部类可以声明为private  或protected

  作用：内部类使得程序代码更为紧凑，程序更具模块化。

  使用的情况：当A类要得到B类一个实例对象，而B类又要访问A类的成员时，将B类写成A类的内部类是比较好的

  注意:内部类可以直接访问外部类，而外部类却不可以访问内部类的成员

         内部类最好不要定义成static类，因为static的内部

        类不能使用外部类的非static成员，而且它相当于一个外部定义的类.同理，非static的内部类中不可以定义static成员。

13.2 内部类如何被外部引用

     先将内部类声明为public，再创建一个外部类的实例对象，然后通过该实例new 一个内部类的实例对象   

class Outer
{
private int x=1;
public class Iner
{
public void hello ()
{
System.out.println("outer:x="+x);
}
}
}
public class Testiner {
   public static void main(String[] args) {
Outer out=new Outer();
Outer.Iner iner=out.new Iner();
iner.hello();
     } }

 

13.3 方法中定义的内部类

   可以在方法中定义内部类，也可以在方法中的for循环里定义内部类。内部类可以直接访问方法外的外部类成员

  如果要访问该方法里的成员，则必须是final类型，因为final类型变量的生命周期超过了方法运行的生命周期。