JAVA--OOP I

本章目标

•了解什么是面向对象

•面向对象的基本概念

>类

>对象

>封装

>继承

>多态

•如何定义类，如何创建对象

•成员运算符

•访问控制权限：public和private

•构造方法

什么是面向对象？

Object    Oriendted       Programming

对象      以…为导向的    程序设计

面向对象就是使用对象进行程序设计，简写成OOP

面向对象的编程语言

•如今，面向对象的编程思想已经成为主流；

•面向对象的编程语言正大行其道，最具代表性的有：

•C++

•Java

•C#

•连数据库也开始面向对象了，如Oracle。

SP和OOP对比

	面向过程  (SP)	面向对象(OOP)
设计思路	自顶向下、层次化、分解	自底向上、对象化、综合
程序单元	函数模块	对象
设计方法	程序 = 算法 + 数据结构	程序 = 对象 = 数据 + 方法
优点	相互独立，代码共享	接近人的思维方式 模拟客观世界
缺点	数据与程序不一致 维护困难	客观世界的无序性 概念不成熟

面向对象的三大原则

     封装  继承   多态

对象

•对象是面向对象编程的核心部分，是实际存在的具体实体，具有明确定义的状态和行为；

•对象其实就是“数据”和“函数”的封装体，其中：

>数据表示自身的状态，也称作“属性”或“成员数据”；

>函数表示自身的功能，也称作“方法”或“成员函数”。

类

•人们为了更好地认识世界，将现实生活中的事物（对象）划分成类；

•同一类中的事物总是具有一些共性；

•类以共同的特性和行为定义实体；

•类是具有相同属性和和行为的一组对象的集合。

属性

•事物的特性在类中用变量表示；

•每个对象的每个属性都拥有其特定的值；

•属性名称由类的所有对象共享；

对象或实体拥有的特征在类中表示时称为属性      

方法

•事物的行为和动作在类中用函数表示；

•每个对象都有相同的动作和行为；

•对象执行的操作在类中表示为方法。

类和对象的区别

•类是用来描述实体的“模板”或“原型”；

•对象是实际的实体，每一个对象都是类的一个具体实例；

•类用来定义对象所有的属性和方法，同一类的所有对象都拥有相同的特征和操作；

•可以将类理解成生产产品的模具，而对象则是根据此模具生产的一个个产品。

类与结构

封装

•将某些东西包装在一起，然后以新的完整形式呈现出来；

•隐藏属性、方法或实现细节的处理方式称为封装；

•封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题。

继承

•继承就是重用现有的类来生成新类的一种特征；

•通俗地讲就是从现有的类（即父类或基类）创建新类（子类或派生类）的过程；

•现实生活中，继承可以达到财产重用的目的，而在Java中，继承可以使代码重用。

多态

•多态是指同一函数在不同的类中有不同的实现；

•多态的好处就是使类更灵活，更便于扩充。

这里还有一个不得不说的的 “抽象”

抽象

•把相同的或相似的对象归为一类的这个过程就是抽象，所以，抽象就是分析问题的方法；

•抽象的基本原则：

>只关心主要问题，而不关心次要问题；

>只关心主要矛盾，而不关心次要矛盾；

>只关心相同的东西，而不关心不同的东西；

>只关心问题是什么，能够完成什么，而不关心怎样去完成。

•抽象的过程其实就是面向对象编程的核心思想。

在Java中定义类

在Java中创建对象

创建对象的语法

•和数组相似，对象也是引用数据类型，只能使用new运算符从堆中分配内存；

•创建对象的一般语法：

  类名 引用名 = new 类名();

•使用已经定义好的类，创建该类对象的过程称为“实例化”。

成员运算符  “ . ”

•只有先实例化类的对象，才可以访问到类中的成员（属性和方法）；

•使用成员运算符（.）来访问成员属性或成员方法；

•一般语法是：

  对象名.成员名

•如：std.age = 18;   //为成员属性赋值

   std.dining();  //调用成员方法

访问权限：public和private

•C语言中结构体的成员可以从任何地方进行访问，这将给数据的安全留下极大的隐患；

•为了避免从类外部直接访问类成员而造成的数据损坏，Java对类成员的访问制定了约束；

•关键字public和private是访问修饰符，用来说明某个成员是否可以从类外部进行访问；

•public修饰的成员可以在任何地方进行访问，不受任何约束；

•private修饰的成员只能够被本类中的其它成员访问，而不能从类的外部进行访问。

•无法从类的外部访问私有成员；

•其它类的私有成员对于当前类也是隐藏的。

访问权限示例

class Student {
  private String name;   //姓名，私有的，不可以从类外部直接访问
  private int age;       //年龄，私有的，不可以从类外部直接访问
  private float weight;  //体重，私有的，不可以从类外部直接访问
  
  //吃饭的方法，公有的，可以从任何地方访问
  public void dining() {
    System.out.println("吃饱了...");
    weight++;  //dining方法是类内部成员，可以直接访问本类私有成员
  }
  
  //走路的方法，公有的，可以从任何地方访问
  public void walk() {
    System.out.println("走累了...");
    weight--;  //walk方法是类内部成员，可以直接访问本类私有成员
  }
}

public class Test {
  public static void main(String[] args) {
    Student std = new Student();  //实例化一个Student对象
    std.age = 18;   //试图从类外部访问私有成员，将会报出一个错误
    std.dining();   //允许访问公有成员
  }
}

访问权限（续）

•加上访问修饰符有时候可能会给操作数据带来不便，但可以在很大程度上保证数据的安全；

•一般地，我们会将成员属性声明为private，而将成员方法声明为public，但这样做并不是绝对的；

•有时候，类外部可能要操作到某些私有数据成员，那么就可以增加一个公有的方法，再由这个方法来操作私有数据，避免因类外部的误操作而造成的数据损坏；

•因为main方法要由类外部的虚拟机来调用，所以main方法必须声明成public。

如：修改Student类

class Student {  //定义学生类
  private String name;   //姓名，私有
  private int age;       //年龄，私有
  private float weight;  //体重，私有

  public void setName(String name) {   //为姓名赋值的方法，公有
    this.name = name;
  }
  public void setAge(int a) {       //为年龄赋值的方法，公有
    age = a;
  }
  public void setWeight(float w) {  //为体重赋值的方法，公有
    weight = w;
  }
  public void display() {           //将所有信息打印出来的方法，公有
    System.out.println("姓名：" + name + ",年龄：" + age + ",体重：" + weight);
  }
  public void dining() {……}         //吃饭的方法，公有，代码略
  public void walk() {……}           //走路的方法，公有，代码略
}

public class Test {
  public static void main(String[] args) {
    Student std = new Student();  //实例化学生类对象
    std.setName("张三");           //为姓名赋值
    std.setAge(18);               //为年龄赋值
    std.setWeight(55);            //为体重赋值
    std.dining();                 //调用吃饭的方法
    std.display();                //将信息打印出来
  }
}

对象初始化

•在上例中，只能逐个地为数据成员赋值，如果想在对象实例化的同时就初始化成员属性，就使用到了构造方法；

•构造方法是特殊的成员方法，它与类同名，在对象实例化时由虚拟机自动调用；

•请注意：构造方法没有返回值类型，也不能有返回值。

构造方法示例：

/*定义ConstructorDemo类，对构造方法进行测试*/
class ConstructorDemo
{
  /*构造方法，方法名与类名完全一致
  无需指定返回值类型，也不能有返回值*/
  public ConstructorDemo()
  {
    System.out.println("这是构造方法");
  }
}

/*Test类，用来容纳main方法
一般将包含有main方法的类声明为public*/
public class Test
{
  /*main方法，程序入口*/
  public static void main(String[] args)
  {
    /*实例化ConstructorDemo类的对象*/
    ConstructorDemo cd = new ConstructorDemo();
  }
}       //会输出“这是构造方法”

构造方法

•正是由于在实例化对象的同时会自动调用构造方法，所以构造方法一般用来给数据成员分配资源或初始化数据成员；

•构造方法的一般形式：

  访问权限 类名（形参列表） {

    方法体

  }

•因为是由虚拟机来调用构造方法，所以构造方法一般应定义成public。

如：为Student类添加构造方法

class Student {  //定义学生类
  private String name;   //姓名，私有
  private int age;       //年龄，私有
  private float weight;  //体重，私有

  //构造方法，根据传递进来的参数，为数据成员赋值
  public Student(String n, int a, float w) {
    //分别为每个数据成员赋初始值
    name = n;
    age = a;
    weight = w;
  }
  public void setName(String n) {……}  //为姓名赋值的方法，公有，代码略
  public void setAge(int a) {……}      //为年龄赋值的方法，公有，代码略
  public void setWeight(float w) {……} //为体重赋值的方法，公有，代码略
  public void display() {……}   //将所有信息打印出来的方法，公有，代码略
  public void dining() {……}    //吃饭的方法，公有，代码略
  public void walk() {……}      //走路的方法，公有，代码略
}

public class Test {
  public static void main(String[] args) {
    //利用构造方法，为数据成员指定初始值
    Student std = new Student("张三", 18, 55);
    std.display();                //将信息打印出来
  }
} 

构造方法（续）

•每个对象在生成时都必须执行构造方法，而且只能执行一次；

•如果构造方法调用失败，那么对象也无法创建；

•不可以显式地直接调用构造方法；

•在没有定义构造方法的情况下，类会自动产生一个无参数的默认构造方法，这个默认的构造方法什么都不做；

•一旦显式地定义了构造方法，默认构造方法自动消失。故一般定义无参和有参两个构造方法。

总结

•对象由状态（属性）和行为（方法）组成；

•类是具有相同属性和方法的对象的集合；

•封装可以隐藏对象实现的具体细节；

•必须先实例化类的对象，才可以访问到其中的成员；

•成员运算符用于访问对象的成员；

•成员可以定义为公有，也可以定义为私有；

•构造方法一般用来初始化对象中的数据成员；

•如果不定义构造方法，将有默认的构造方法，一旦定义，默认的构造方法自动消失。

作业

•编写一个包含名为Calculator类的程序。定义两个整型属性以及对该两个变量的setter和getter，编写用于对两个属性执行加、减、乘、除运算方法。在main方法里创建该类的对象并访问这些方法。

•编写一个名为Box的类，含整型的height,width,length，volume四个属性，要求在构造方法中将其初始化，并定义一个计算体积的calcVolume方法和一个输出体积的print方法，在main方法中进行调用。

逻辑趣味思考题

•有三筐水果，一筐装的全是苹果，第二筐装的全是橘子，第三筐是橘子与苹果混在一起。筐上的标签都是骗人的，（比如，如果标签写的是橘子，那么可以肯定筐里不会只有橘子，可能还有苹果）你的任务是拿出其中一筐，从里面只拿一只水果，然后正确写出三筐水果的标签。

•一列时速15英里的火车从洛杉矶出发，驶向纽约。另外一列时速20英里的火车从纽约出发，驶向洛杉矶。如果一只鸟以每小时25英里的速度飞行，在同一时间从洛杉矶出发，在两列火车之间往返飞行，到火车相遇时为止，鸟飞了多远？