面对对象上

1                            面向过程

       在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口本身的定义没有任何关系，如HideWindow，MoveWindow，MinimizeWindow，这些函数都需要接受一个代表要被操作的窗口参数 ，是一种谓语与宾语的关系 。

面向对象

     定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，还要指定该窗口可能具有的动作 ，如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的 ，这是一种主语与谓语的关系。

面向对象的三大特征

封装  (Encapsulation)

继承  (Inheritance)

多态  (Polymorphism)

类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。

类的定义：

class Person

{

      int age;

      void shout()

      {

             System.out.println(“oh,my god! I am “ + age);

      }

}

age是类的属性 ，也叫类成员变量 。

shout是方法也叫类的成员函数。

shout方法可以直接访问同一个类中的age变量 ，如果一个方法中有与成员变量同名的局部变量，该方法中对这个变量名的访问是局部变量，而不再是成员变量。 

2    

类的封装性：

如果外面的程序可以随意修改一个类的成员变量，会造成不可预料的程序错误，就象一个人的身高，不能被外部随意修改，只能通过各种摄取营养的方法去修改这个属性。

在定义一个类的成员（包括变量和方法）时，使用private关键字说明这个成员的访问权限，这个成员成了类的私有成员，只能被这个类的其他成员方法调用，而不能被其他的类中的方法所调用。

类的封装性的实现：

为了实现良好的封装性，我们通常将类的成员变量声明为private，再通过public的方法来对这个变量进行访问。对一个变量的操作，一般都有读取和赋值操作，我们分别定义两个方法来实现这两种操作，一个是getXxx()（Xxx表示要访问的成员变量的名字），用来读取这个成员变量操作，另外一个是setXxx()用来对这个成员变量赋值。

如：package com.Text1;

class Person{

        

      private int age;

     

  void print(){

      age=60;

      System.out.println("My age is"+age);  

  }

  public void setAge(int age){

      this.age=age;

  }

  public int getAge(){

      return age;

  }

 }

  class Text{

  public static void main(String[] args){

      Person p1=new Person();

     

      p1.age=-30;//这不能修改age的值，体现了类的封装性

      p1.print();

  }

}

3        关键字 this的引用

This与对象关联，它代表当前对象，

public class PassTest {

  int x;

  PassTest(int x) {

           this.x=x;// 指明此对象的变量 x 应赋值为通过构造函数传递的自变量 x 的值。

  }

  public void passingValue(){

    System.out.println(“x 等于 " +x);  

  }

  public static void main(String args[]) {

    PassTest test = new PassTest(10);

    test.passingValue();     

  }

}

4  static静态变量

   当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

（1）  在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。

（2） 静态方法不能以任何方式引用this和super关键字（super关键字在下一章讲解）。与上面的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。

（3） main() 方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在以后的例子中会多次碰到。

5  内部类

定义：在一个类中定义的类叫做内部类

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

（2）在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引用。

（3）如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可声明static成员，但是，非static的内部类中的成员是不能声明为static的。static的内部类不能再使用外层封装类的非static的成员变量，这个道理不难想象！所以static嵌套类很少使用。

如：public class Outer

{
 private int size;
 public class Inner

       {
          private int size;
          public void doStuff( int size)

              {
                 size++; // 引用的是doStuff函数的形参

                         this.size++; //引用的是Inner类中的成员变量

                         Outer.this.size++; // 引用的Outer类中的成员变量

             }

       }

}

通过外部类可以引用内部类：

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();

           }

    }