java中面向对象的一些知识（一）

一：基本概念

---

举例：写一个程序，实现如下功能：
      一群宠物，宠物有各种类型，如猫、狗、企鹅等
      让这群宠物，按照各自的能力不同，进行各种比赛（如爬树、游泳、跳水）；扩展性需求： 游泳比赛游泳池的参数、飞盘的大小和重量等

	1.首先从里面抽象出名词性的概念（需求分析，抽取概念模型）
	 宠物、猫、狗、企鹅、比赛、能力、宠物类型

    　　2. 把名词抽象成相应的class，或class的属性

   　　 3.提取动词    --------------------  把这些动词，抽象成对象的行为
      　　爬树、游泳、跳水

类和对象的关系：

类是用于描述同一类的对象的一个抽象的概念，类中定义了这一类对象所具有的静态属性和动态属性
类可以看成一类对象的模板，对象可以看成该类的一个具体实例。

下面看一段代码

package com.chen.biz;
/**
 * 构建了一个宠物类
 *
 * @author 陈家小哥
 *
 */
public class Pet {
    private String name; // 宠物的名字
    private String sex; // 宠物的性别

    //构造函数（空的）
    public Pet() {
        // TODO Auto-generated constructor stub
    }
    /**
     * 方法
     * 宠物都可以玩游戏
     * @param pet
     */
    public void playGame(Pet pet){
    }
}

 构造函数：

创建一个对象，必须调用它的构造函数。当一个类中没有构造函数时，会自动生成一个空的构造函数。 
构造函数的作用：给成员变量进行初始化。如果没有给成员变量初始化，系统会分配默认值给这些成员变量。

二：常量和变量

---

常量：永远不会改变（static final）

      编译期常量（static final）：在程序编译的时候，所有调用常量的位置，都被常量代表的值所替换 ， 最大的好处是节省内存
      程序运行期常量（final）：一次赋值之后，永远不能改变
      常量的命名一定要大写 ，如名字较长，用下划线进行间隔    SEX_MALE   

变量
1.局部变量：通过参数传入或者在方法中定义

public void Play(String name){
    string age;  //局部变量
    System.out.print(name); //name也是局部变量
}
 

局部变量的作用域是该变量所在的{}  。
局部变量的生命期：
基本类型：超出局部变量定义的{}，就会被标识为无效，等待GC来回收。
引用类型：超出局部变量定义的{}，会引用计数-1，如果引用计数为0，就会被GC下次扫描时回收。
2.成员变量（对象变量）
	成员变量是定义咋方法外的变量。

public class Pet {
    private String name; // 宠物的名字 成员变量
    private String sex; // 宠物的性别  成员变量
    /**
     * 方法
     * 宠物都可以玩游戏
     * @param pet
     */
    public void playGame(String cc){
        System.out.println(cc);
    }
}

成员变量的作用域：就是所在class内的所有方法
成员变量的生命期：与它所在的对象的生命期一致

在没有static静态变量的情况下程序运行顺序如下：
	1.系统给属性赋默认值
	2.用户在成员变量级直接赋默认值
	3.在构造函数中对成员变量进行初始化。
static变量：
	1.称为类变量，它是所有对象共享的内存；
	2.不需要类的实例，可以直接通过类的名字调用。
	3.作用域类似于全局变量
	4.在第一次调用这个变量时，分配内存。

下面是几个小例子：

public class Test {
      public static final double PAI = 3.1415926;  //静态常量
      public final double PAI2 = 3.1415926;//常量
      public static double PAI3 = 3.1415926;//静态变量

      public Test(){          

      }
}

public class Test {
      public static final double PAI;
      public final double PAI2;
      public static double PAI3;

      public Test(){
         this.PAI =  3.1415926;    //错误，必须在定义时就赋值
         this.PAI2 =  3.1415926; //可以，初始化赋值。
         this.PAI3 = 3.1415926;//不可以 不能再构造方法中给静态变量赋值，因为静态变量加载时可能这个类并没有被加载。
      }
}

public class Test {
      public static final double PAI = 3.1415926;
      public final double PAI2  = 3.1415926;;
      public static double PAI3 = 3.1415926;;
      public double PAI4 = 3.1415926;      

      public static void test(){
        this.PAI = 3.14;
        this.PAI2 = 3.14;
        this.PAI3 = 3.14;
        this.PAI4 = 3.14;        //均存在错误，因为静态方法中不可以用this关键字
      }
}

public class Test {
      public static final double PAI;
      public final double PAI2;
      public static double PAI3 = 3.1415926;;

      public static void test(){
        PAI = 3.14;     //编译期常量不能在这赋值
        PAI2 = 3.14;   //静态方法不能直接调用成员变量，原因是这个成员变量还没有分配内存，需要通过对象调用
        PAI3 = 3.14;   //静态方法调用静态变量OK
}

package com.chen.test;
/**
 * 说出输出顺序
 * @author 陈家小哥
 *
 */
public class Test extends A {
    int num = 7777;
    private static A mm = new A();
    static {
        System.out.println("1111");
    }
    {
        System.out.println("2222");
    }

    public Test() {
        System.out.println("3333");
    }
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.num);
    }
}

class A {
    int num = 5555;

    public A() {
        System.out.println(num);
    }
}
输出结果：
5555
1111
5555
2222
3333
7777

解释：当类被加载时，先初始化静态的变量，输出5555和1111，然后调用父类的构造函数，输出5555，然后输出2222，最后调用子类的构造函数，输出子类的成员变量。