面向对象思想

首先需要理解两个概念：面向过程和面向对象的概念。

面向过程：可以理解为如果遇到一件事情需要进行处理，需要自己亲自去一步一步的解决这件事情的过程。

面向对象：这相当与面向过程的升级，可以理解为遇到一件事情需要去处理，我们可以找懂这件事情的人来做，我们只需要去指挥这个人去完成这件事情即可，从一个执行者转变成了指挥者。

面向对象的好处

1、 面向对象思想更符合人类的思考习惯。

2、 面向对象思想将复杂的问题简单化。

3、 面向对象思想将自己从执行者（自己做事情）的角色转变为指挥者（只会对象做事情）。

对象在代码中的体现

有一种说法是世间万物皆为对象，将世间存在的事物都可以看成是对象，我们可以通过代码的形式进行描述这些事物。

下面通过代码来描述一下小汽车这个事物

l  定义小汽车类

package cn.itcast.Demo01;
/*
 * 通过类的定义，来描述小汽车
 * 需要对小汽车的属性和功能两个方面进行描述，将这两点定义在类中
 *  属性（特点）：
 *    颜色
 *    轮胎数
 *  功能（行为）：
 *    运行（跑）
 * 它的属性就是成员变量，功能就是成员方法
 */
public class Car {
   //属性（成员变量）
   //定义颜色
   String color;
   //定义轮胎数
   int count;
   //功能（成员方法）
   public void run(){
      System.out.println("小汽车在跑..."+color+"..."+count);
   }
}

l  小汽车的测试类

package cn.itcast.Demo01;
/*
 * 测试类，测试小汽车类
 * 创建小汽车类的对象：Car c = new Car();
 * 通过对象名.的形式调用成员变量并进行赋值，并调用成员方法
 */
public class CarTest {
   public static void main(String[] args) {
      //创建Car类的对象
      Car c = new Car();
      //通过对象名.的方式调用成员变量并进行赋值
      c.color = "黑色";
      c.count = 4;
      //调用成员方法
      c.run();
   }
 
}

面向对象中类和对象的概念

类：是对事物的抽象描述，比如人有姓名，有年龄，会吃饭，会学习，这些都是人本来就有的属性和功能的抽象描述，并不知道是哪一个人。

对象：就是对抽象事物的具体描述，现在我们可以对这个人进行定义姓名，年龄，将这个抽象的事物具体体现出来，这时候我们可以定义对象定义出很多具体的人。

成员变量和局部变量的区别

1、 定义位置上的不同

a)        成员变量定义在类中，方法外

b)        局部变量定义在方法中，语句内

2、 作用域不同

a)        成员变量的作用范围在整个类中都有效

b)        局部变量的作用范围只在方法中，语句内有效

3、 默认值不同

a)        成员变量有自己的默认值，类型不同，默认值也不同

b)        局部变量没有默认值，需要自己去赋值才能使用

4、 内存位置不同

a)        成员变量是跟随对象的创建就存在在堆内存中

b)        局部变量是跟随方法的，跟随方法进入栈内存

5、 生命周期不同

a)        成员变量的生命周期相对较长，类结束之后，等待垃圾回收机制的清理而消亡

b)        局部变量的生命周期较短，方法结束，跟随方法的弹栈而消亡

面向对象：封装

封装的体现：其实类和方法就是代码功能的封装

封装的好处：

1、 隐藏了功能的实现细节，仅对外提供了访问方式，便于调用者调用。

2、 提高了代码的复用性

3、 提高了代码的安全性

private关键字

private关键字：权限修饰符，私有的，该关键字只能修饰成员，不能修饰局部变量。

作用：提高了代码的安全性，对成员进行私有化，限制外部对其进行直接操作，造成安全隐患，这是将该成员私有化，仅对外提供一个公共的访问方式，被private修饰的成员只在本类中有效，这时就需要将私有的成员定义在方法中，外部调用这个方法就可以了。该关键字的具体代码体现如下：

l  定义人的类

package cn.itcast.Demo02;
/*
 * 定义一个类，对人进行描述
 *  属性：
 *    姓名
 *    年龄
 *  功能：
 *    讲话
 */
public class Person {
   //属性
   //定义姓名成员变量
   String name;
   //定义年龄成员变量，将该变量私有化，防止出现姓名为负数，或者年龄过大的问题
   private int age;
   //将私有的年龄封装进方法中，外部调用该方法即可，防止出现年龄为负数，年龄过大的安全隐患
   public void setAge(int a){
      //对年龄进行判断，如果为负数或者过大，直接将年龄赋值为20,
      if(a<0 || a>120){
         age = 20;
      }else{
         age = a;
      }
   }
   //功能
   public void speak(){
      System.out.println("人会讲话..."+name+"..."+age);
   }
}

l  测试人的类

package cn.itcast.Demo02;
/*
 * 测试类：测试描述人的类
 */
public class PersonTest {
   public static void main(String[] args) {
      //创建Person类的对象
      Person p = new Person();
      //调用姓名并进行赋值
      p.name = "王杰";
      //调用年龄的方法
      p.setAge(-30);
      //调用说话的方法
      p.speak();
   }
 
}

setXxx方法和getXxx方法

在类中定义了成员变量，都应该对成员变量进行私有化操作，对外提供setXxx（设置值）方法和getXxx（获取值）方法就可以了，还是对人的描述进行定义，代码如下：

l  定义人的类

package cn.itcast.Demo03;
/*
 * 定义一个类，对人进行描述
 *  属性：
 *    姓名
 *    年龄
 *  功能：
 *    讲话
 */
public class Person {
   //属性
   //定义姓名成员变量
   private String name;
   //定义年龄成员变量，将该变量私有化，防止出现姓名为负数，或者年龄过大的问题
   private int age;
   //将私有的年龄封装进方法中，外部调用该方法即可，防止出现年龄为负数，年龄过大的安全隐患
   public void setAge(int a){
      //对年龄进行判断，如果为负数或者过大，直接将年龄赋值为20,
      if(a<0 || a>120){
         age = 20;
      }else{
         age = a;
      }
   }
   //将姓名封装进方法，设置值
   public void setName(String n){
      name = n;
   }
   //获取值的方法
   public String getName(){
      return name;
   }
   public int getAge(){
      return age;
   }
   //功能
   public void speak(){
      System.out.println("人会讲话..."+name+"..."+age);
   }
}

l  测试类

package cn.itcast.Demo03;
 
import cn.itcast.Demo03.Person;
 
/*
 * 测试类：测试描述人的类
 */
public class PersonTest {
   public static void main(String[] args) {
      //创建Person类的对象
      Person p = new Person();
      //调用方法进行赋值
      p.setAge(20);
      p.setName("王杰");
      p.speak();
      //调用方法获取值
      System.out.println(p.getName());
      System.out.println(p.getAge());
   }
 
}

面向对象

原文：http://blog.51cto.com/13502869/2050446